1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* Output dbx-format symbol table data.
24 This consists of many symbol table entries, each of them
25 a .stabs assembler pseudo-op with four operands:
26 a "name" which is really a description of one symbol and its type,
27 a "code", which is a symbol defined in stab.h whose name starts with N_,
28 an unused operand always 0,
29 and a "value" which is an address or an offset.
30 The name is enclosed in doublequote characters.
32 Each function, variable, typedef, and structure tag
33 has a symbol table entry to define it.
34 The beginning and end of each level of name scoping within
35 a function are also marked by special symbol table entries.
37 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
38 and a data type number. The data type number may be followed by
39 "=" and a type definition; normally this will happen the first time
40 the type number is mentioned. The type definition may refer to
41 other types by number, and those type numbers may be followed
42 by "=" and nested definitions.
44 This can make the "name" quite long.
45 When a name is more than 80 characters, we split the .stabs pseudo-op
46 into two .stabs pseudo-ops, both sharing the same "code" and "value".
47 The first one is marked as continued with a double-backslash at the
50 The kind-of-symbol letter distinguished function names from global
51 variables from file-scope variables from parameters from auto
52 variables in memory from typedef names from register variables.
55 The "code" is mostly redundant with the kind-of-symbol letter
56 that goes in the "name", but not entirely: for symbols located
57 in static storage, the "code" says which segment the address is in,
58 which controls how it is relocated.
60 The "value" for a symbol in static storage
61 is the core address of the symbol (actually, the assembler
62 label for the symbol). For a symbol located in a stack slot
63 it is the stack offset; for one in a register, the register number.
64 For a typedef symbol, it is zero.
66 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
67 output while in the text section.
69 For more on data type definitions, see `dbxout_type'. */
78 #include "insn-config.h"
80 #include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions. */
87 #ifdef XCOFF_DEBUGGING_INFO
92 #define ASM_STABS_OP "\t.stabs\t"
96 #define ASM_STABN_OP "\t.stabn\t"
99 #ifndef DBX_TYPE_DECL_STABS_CODE
100 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
103 #ifndef DBX_STATIC_CONST_VAR_CODE
104 #define DBX_STATIC_CONST_VAR_CODE N_FUN
107 #ifndef DBX_REGPARM_STABS_CODE
108 #define DBX_REGPARM_STABS_CODE N_RSYM
111 #ifndef DBX_REGPARM_STABS_LETTER
112 #define DBX_REGPARM_STABS_LETTER 'P'
115 /* This is used for parameters passed by invisible reference in a register. */
116 #ifndef GDB_INV_REF_REGPARM_STABS_LETTER
117 #define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
120 #ifndef DBX_MEMPARM_STABS_LETTER
121 #define DBX_MEMPARM_STABS_LETTER 'p'
124 #ifndef FILE_NAME_JOINER
125 #define FILE_NAME_JOINER "/"
128 /* GDB needs to know that the stabs were generated by GCC. We emit an
129 N_OPT stab at the beginning of the source file to indicate this.
130 The string is historical, and different on a very few targets. */
131 #ifndef STABS_GCC_MARKER
132 #define STABS_GCC_MARKER "gcc2_compiled."
135 /* Typical USG systems don't have stab.h, and they also have
136 no use for DBX-format debugging info. */
138 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
140 /* Nonzero if we have actually used any of the GDB extensions
141 to the debugging format. The idea is that we use them for the
142 first time only if there's a strong reason, but once we have done that,
143 we use them whenever convenient. */
145 static int have_used_extensions
= 0;
147 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
148 for the N_SO filename stabs label. */
150 static int source_label_number
= 1;
152 #ifdef DEBUG_SYMS_TEXT
153 #define FORCE_TEXT text_section ();
160 #define STAB_CODE_TYPE enum __stab_debug_code
162 /* 1 if PARM is passed to this function in memory. */
164 #define PARM_PASSED_IN_MEMORY(PARM) \
165 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
167 /* A C expression for the integer offset value of an automatic variable
168 (N_LSYM) having address X (an RTX). */
169 #ifndef DEBUGGER_AUTO_OFFSET
170 #define DEBUGGER_AUTO_OFFSET(X) \
171 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
174 /* A C expression for the integer offset value of an argument (N_PSYM)
175 having address X (an RTX). The nominal offset is OFFSET. */
176 #ifndef DEBUGGER_ARG_OFFSET
177 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
180 /* Stream for writing to assembler file. */
182 static FILE *asmfile
;
184 /* Last source file name mentioned in a NOTE insn. */
186 static const char *lastfile
;
188 /* Current working directory. */
190 static const char *cwd
;
192 enum typestatus
{TYPE_UNSEEN
, TYPE_XREF
, TYPE_DEFINED
};
194 /* Structure recording information about a C data type.
195 The status element says whether we have yet output
196 the definition of the type. TYPE_XREF says we have
197 output it as a cross-reference only.
198 The file_number and type_number elements are used if DBX_USE_BINCL
203 enum typestatus status
;
210 /* Vector recording information about C data types.
211 When we first notice a data type (a tree node),
212 we assign it a number using next_type_number.
213 That is its index in this vector. */
215 struct typeinfo
*typevec
;
217 /* Number of elements of space allocated in `typevec'. */
219 static int typevec_len
;
221 /* In dbx output, each type gets a unique number.
222 This is the number for the next type output.
223 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
225 static int next_type_number
;
229 /* When using N_BINCL in dbx output, each type number is actually a
230 pair of the file number and the type number within the file.
231 This is a stack of input files. */
235 struct dbx_file
*next
;
237 int next_type_number
;
240 /* This is the top of the stack. */
242 static struct dbx_file
*current_file
;
244 /* This is the next file number to use. */
246 static int next_file_number
;
248 #endif /* DBX_USE_BINCL */
250 /* These variables are for dbxout_symbol to communicate to
251 dbxout_finish_symbol.
252 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
253 current_sym_value and current_sym_addr are two ways to address the
254 value to store in the symtab entry.
255 current_sym_addr if nonzero represents the value as an rtx.
256 If that is zero, current_sym_value is used. This is used
257 when the value is an offset (such as for auto variables,
258 register variables and parms). */
260 static STAB_CODE_TYPE current_sym_code
;
261 static int current_sym_value
;
262 static rtx current_sym_addr
;
264 /* Number of chars of symbol-description generated so far for the
265 current symbol. Used by CHARS and CONTIN. */
267 static int current_sym_nchars
;
269 /* Report having output N chars of the current symbol-description. */
271 #define CHARS(N) (current_sym_nchars += (N))
273 /* Break the current symbol-description, generating a continuation,
274 if it has become long. */
276 #ifndef DBX_CONTIN_LENGTH
277 #define DBX_CONTIN_LENGTH 80
280 #if DBX_CONTIN_LENGTH > 0
282 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
284 #define CONTIN do { } while (0)
287 static void dbxout_init
PARAMS ((FILE *, const char *));
288 static void dbxout_finish
PARAMS ((FILE *, const char *));
289 static void dbxout_start_source_file
PARAMS ((unsigned, const char *));
290 static void dbxout_end_source_file
PARAMS ((unsigned));
291 #if defined(ASM_OUTPUT_SECTION_NAME)
292 static void dbxout_function_end
PARAMS ((void));
294 static void dbxout_typedefs
PARAMS ((tree
));
295 static void dbxout_type_index
PARAMS ((tree
));
296 #if DBX_CONTIN_LENGTH > 0
297 static void dbxout_continue
PARAMS ((void));
299 static void dbxout_type_fields
PARAMS ((tree
));
300 static void dbxout_type_method_1
PARAMS ((tree
, const char *));
301 static void dbxout_type_methods
PARAMS ((tree
));
302 static void dbxout_range_type
PARAMS ((tree
));
303 static void dbxout_type
PARAMS ((tree
, int));
304 static void print_int_cst_octal
PARAMS ((tree
));
305 static void print_octal
PARAMS ((unsigned HOST_WIDE_INT
, int));
306 static void dbxout_type_name
PARAMS ((tree
));
307 static int dbxout_symbol_location
PARAMS ((tree
, tree
, const char *, rtx
));
308 static void dbxout_symbol_name
PARAMS ((tree
, const char *, int));
309 static void dbxout_prepare_symbol
PARAMS ((tree
));
310 static void dbxout_finish_symbol
PARAMS ((tree
));
311 static void dbxout_block
PARAMS ((tree
, int, tree
));
312 static void dbxout_really_begin_function
PARAMS ((tree
));
314 /* The debug hooks structure. */
315 #if defined (DBX_DEBUGGING_INFO)
317 static void dbxout_begin_block
PARAMS ((FILE *, unsigned, unsigned));
318 static void dbxout_end_block
PARAMS ((FILE *, unsigned, unsigned));
320 struct gcc_debug_hooks dbx_debug_hooks
=
324 debug_nothing_int_charstar
,
325 debug_nothing_int_charstar
,
326 dbxout_start_source_file
,
327 dbxout_end_source_file
,
331 #endif /* DBX_DEBUGGING_INFO */
333 #if defined (XCOFF_DEBUGGING_INFO)
334 struct gcc_debug_hooks xcoff_debug_hooks
=
338 debug_nothing_int_charstar
,
339 debug_nothing_int_charstar
,
340 dbxout_start_source_file
,
341 dbxout_end_source_file
,
342 xcoffout_begin_block
,
345 #endif /* XCOFF_DEBUGGING_INFO */
347 #if defined(ASM_OUTPUT_SECTION_NAME)
349 dbxout_function_end ()
351 static int scope_labelno
= 0;
352 char lscope_label_name
[100];
353 /* Convert Ltext into the appropriate format for local labels in case
354 the system doesn't insert underscores in front of user generated
356 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
357 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Lscope", scope_labelno
);
360 /* By convention, GCC will mark the end of a function with an N_FUN
361 symbol and an empty string. */
362 fprintf (asmfile
, "%s\"\",%d,0,0,", ASM_STABS_OP
, N_FUN
);
363 assemble_name (asmfile
, lscope_label_name
);
364 fputc ('-', asmfile
);
365 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
366 fprintf (asmfile
, "\n");
368 #endif /* ! NO_DBX_FUNCTION_END */
370 /* At the beginning of compilation, start writing the symbol table.
371 Initialize `typevec' and output the standard data types of C. */
374 dbxout_init (asm_file
, input_file_name
)
376 const char *input_file_name
;
378 char ltext_label_name
[100];
379 tree syms
= getdecls ();
384 typevec
= (struct typeinfo
*) xcalloc (typevec_len
, sizeof typevec
[0]);
386 /* Convert Ltext into the appropriate format for local labels in case
387 the system doesn't insert underscores in front of user generated
389 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
391 /* Put the current working directory in an N_SO symbol. */
392 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
393 but GDB always does. */
394 if (use_gnu_debug_info_extensions
)
397 if (!cwd
&& (cwd
= getpwd ()) && (!*cwd
|| cwd
[strlen (cwd
) - 1] != '/'))
398 cwd
= concat (cwd
, FILE_NAME_JOINER
, NULL
);
401 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
402 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile
, cwd
);
403 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
404 fprintf (asmfile
, "%s", ASM_STABS_OP
);
405 output_quoted_string (asmfile
, cwd
);
406 fprintf (asmfile
, ",%d,0,0,%s\n", N_SO
, <ext_label_name
[1]);
407 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
411 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
412 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
413 would give us an N_SOL, and we want an N_SO. */
414 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile
, input_file_name
);
415 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
416 /* We include outputting `Ltext:' here,
417 because that gives you a way to override it. */
418 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
419 fprintf (asmfile
, "%s", ASM_STABS_OP
);
420 output_quoted_string (asmfile
, input_file_name
);
421 fprintf (asmfile
, ",%d,0,0,%s\n",
422 N_SO
, <ext_label_name
[1]);
424 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Ltext", 0);
425 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
427 #ifdef DBX_OUTPUT_GCC_MARKER
428 DBX_OUTPUT_GCC_MARKER (asmfile
);
430 /* Emit an N_OPT stab to indicate that this file was compiled by GCC. */
431 fprintf (asmfile
, "%s\"%s\",%d,0,0,0\n",
432 ASM_STABS_OP
, STABS_GCC_MARKER
, N_OPT
);
435 lastfile
= input_file_name
;
437 next_type_number
= 1;
440 current_file
= (struct dbx_file
*) xmalloc (sizeof *current_file
);
441 current_file
->next
= NULL
;
442 current_file
->file_number
= 0;
443 current_file
->next_type_number
= 1;
444 next_file_number
= 1;
447 /* Make sure that types `int' and `char' have numbers 1 and 2.
448 Definitions of other integer types will refer to those numbers.
449 (Actually it should no longer matter what their numbers are.
450 Also, if any types with tags have been defined, dbxout_symbol
451 will output them first, so the numbers won't be 1 and 2. That
452 happens in C++. So it's a good thing it should no longer matter). */
454 #ifdef DBX_OUTPUT_STANDARD_TYPES
455 DBX_OUTPUT_STANDARD_TYPES (syms
);
457 dbxout_symbol (TYPE_NAME (integer_type_node
), 0);
458 dbxout_symbol (TYPE_NAME (char_type_node
), 0);
461 /* Get all permanent types that have typedef names,
462 and output them all, except for those already output. */
464 dbxout_typedefs (syms
);
467 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
468 in the reverse order from that which is found in SYMS. */
471 dbxout_typedefs (syms
)
476 dbxout_typedefs (TREE_CHAIN (syms
));
477 if (TREE_CODE (syms
) == TYPE_DECL
)
479 tree type
= TREE_TYPE (syms
);
481 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
482 && COMPLETE_TYPE_P (type
)
483 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
484 dbxout_symbol (TYPE_NAME (type
), 0);
489 /* Change to reading from a new source file. Generate a N_BINCL stab. */
492 dbxout_start_source_file (line
, filename
)
493 unsigned int line ATTRIBUTE_UNUSED
;
494 const char *filename ATTRIBUTE_UNUSED
;
497 struct dbx_file
*n
= (struct dbx_file
*) xmalloc (sizeof *n
);
499 n
->next
= current_file
;
500 n
->file_number
= next_file_number
++;
501 n
->next_type_number
= 1;
503 fprintf (asmfile
, "%s", ASM_STABS_OP
);
504 output_quoted_string (asmfile
, filename
);
505 fprintf (asmfile
, ",%d,0,0,0\n", N_BINCL
);
509 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
512 dbxout_end_source_file (line
)
513 unsigned int line ATTRIBUTE_UNUSED
;
516 struct dbx_file
*next
;
518 fprintf (asmfile
, "%s%d,0,0,0\n", ASM_STABN_OP
, N_EINCL
);
519 next
= current_file
->next
;
525 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
528 dbxout_source_file (file
, filename
)
530 const char *filename
;
532 char ltext_label_name
[100];
534 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
536 #ifdef DBX_OUTPUT_SOURCE_FILENAME
537 DBX_OUTPUT_SOURCE_FILENAME (file
, filename
);
539 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext",
540 source_label_number
);
541 fprintf (file
, "%s", ASM_STABS_OP
);
542 output_quoted_string (file
, filename
);
543 fprintf (file
, ",%d,0,0,%s\n", N_SOL
, <ext_label_name
[1]);
544 if (current_function_decl
!= NULL_TREE
545 && DECL_SECTION_NAME (current_function_decl
) != NULL_TREE
)
546 ; /* Don't change section amid function. */
549 ASM_OUTPUT_INTERNAL_LABEL (file
, "Ltext", source_label_number
);
550 source_label_number
++;
556 /* Output a line number symbol entry into output stream FILE,
557 for source file FILENAME and line number LINENO. */
560 dbxout_source_line (file
, filename
, lineno
)
562 const char *filename
;
565 dbxout_source_file (file
, filename
);
567 #ifdef ASM_OUTPUT_SOURCE_LINE
568 ASM_OUTPUT_SOURCE_LINE (file
, lineno
);
570 fprintf (file
, "%s%d,0,%d\n", ASM_STABD_OP
, N_SLINE
, lineno
);
574 #if defined (DBX_DEBUGGING_INFO)
576 /* Describe the beginning of an internal block within a function. */
579 dbxout_begin_block (file
, line
, n
)
581 unsigned int line ATTRIBUTE_UNUSED
;
584 ASM_OUTPUT_INTERNAL_LABEL (file
, "LBB", n
);
587 /* Describe the end line-number of an internal block within a function. */
590 dbxout_end_block (file
, line
, n
)
592 unsigned int line ATTRIBUTE_UNUSED
;
595 ASM_OUTPUT_INTERNAL_LABEL (file
, "LBE", n
);
598 #endif /* DBX_DEBUGGING_INFO */
600 /* At the end of compilation, finish writing the symbol table.
601 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
605 dbxout_finish (file
, filename
)
606 FILE *file ATTRIBUTE_UNUSED
;
607 const char *filename ATTRIBUTE_UNUSED
;
609 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
610 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file
, filename
);
611 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
614 /* Output the index of a type. */
617 dbxout_type_index (type
)
620 #ifndef DBX_USE_BINCL
621 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
624 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
625 fprintf (asmfile
, "(%d,%d)", t
->file_number
, t
->type_number
);
630 #if DBX_CONTIN_LENGTH > 0
631 /* Continue a symbol-description that gets too big.
632 End one symbol table entry with a double-backslash
633 and start a new one, eventually producing something like
634 .stabs "start......\\",code,0,value
635 .stabs "...rest",code,0,value */
640 #ifdef DBX_CONTIN_CHAR
641 fprintf (asmfile
, "%c", DBX_CONTIN_CHAR
);
643 fprintf (asmfile
, "\\\\");
645 dbxout_finish_symbol (NULL_TREE
);
646 fprintf (asmfile
, "%s\"", ASM_STABS_OP
);
647 current_sym_nchars
= 0;
649 #endif /* DBX_CONTIN_LENGTH > 0 */
651 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
652 This must be a separate function because anonymous unions require
656 dbxout_type_fields (type
)
661 /* Output the name, type, position (in bits), size (in bits) of each
662 field that we can support. */
663 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
665 /* Omit here local type decls until we know how to support them. */
666 if (TREE_CODE (tem
) == TYPE_DECL
667 /* Omit fields whose position or size are variable or too large to
669 || (TREE_CODE (tem
) == FIELD_DECL
670 && (! host_integerp (bit_position (tem
), 0)
672 || ! host_integerp (DECL_SIZE (tem
), 1)))
673 /* Omit here the nameless fields that are used to skip bits. */
674 || DECL_IGNORED_P (tem
))
677 else if (TREE_CODE (tem
) != CONST_DECL
)
679 /* Continue the line if necessary,
680 but not before the first field. */
681 if (tem
!= TYPE_FIELDS (type
))
686 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem
)));
687 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem
)));
691 fprintf (asmfile
, ":");
695 if (use_gnu_debug_info_extensions
696 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
697 || TREE_CODE (tem
) != FIELD_DECL
))
699 have_used_extensions
= 1;
701 putc ((TREE_PRIVATE (tem
) ? '0'
702 : TREE_PROTECTED (tem
) ? '1' : '2'),
707 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
708 && DECL_BIT_FIELD_TYPE (tem
))
709 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0);
711 if (TREE_CODE (tem
) == VAR_DECL
)
713 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
716 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
));
717 have_used_extensions
= 1;
718 fprintf (asmfile
, ":%s;", name
);
719 CHARS (strlen (name
));
722 /* If TEM is non-static, GDB won't understand it. */
723 fprintf (asmfile
, ",0,0;");
727 fputc (',', asmfile
);
728 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
729 int_bit_position (tem
));
730 fputc (',', asmfile
);
731 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
732 tree_low_cst (DECL_SIZE (tem
), 1));
733 fputc (';', asmfile
);
740 /* Subroutine of `dbxout_type_methods'. Output debug info about the
741 method described DECL. DEBUG_NAME is an encoding of the method's
742 type signature. ??? We may be able to do without DEBUG_NAME altogether
746 dbxout_type_method_1 (decl
, debug_name
)
748 const char *debug_name
;
752 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
754 else /* it's a METHOD_TYPE. */
756 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
757 /* A for normal functions.
758 B for `const' member functions.
759 C for `volatile' member functions.
760 D for `const volatile' member functions. */
761 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
763 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
766 if (DECL_VINDEX (decl
))
772 fprintf (asmfile
, ":%s;%c%c%c", debug_name
,
773 TREE_PRIVATE (decl
) ? '0'
774 : TREE_PROTECTED (decl
) ? '1' : '2', c1
, c2
);
775 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
)) + 6
776 - (debug_name
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
778 if (DECL_VINDEX (decl
) && host_integerp (DECL_VINDEX (decl
), 0))
780 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
781 tree_low_cst (DECL_VINDEX (decl
), 0));
782 fputc (';', asmfile
);
783 dbxout_type (DECL_CONTEXT (decl
), 0);
784 fprintf (asmfile
, ";");
789 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
793 dbxout_type_methods (type
)
796 /* C++: put out the method names and their parameter lists */
797 tree methods
= TYPE_METHODS (type
);
799 register tree fndecl
;
801 char formatted_type_identifier_length
[16];
802 register int type_identifier_length
;
804 if (methods
== NULL_TREE
)
807 type_encoding
= DECL_NAME (TYPE_NAME (type
));
810 /* C++: Template classes break some assumptions made by this code about
811 the class names, constructor names, and encodings for assembler
812 label names. For now, disable output of dbx info for them. */
814 const char *ptr
= IDENTIFIER_POINTER (type_encoding
);
815 /* This should use index. (mrs) */
816 while (*ptr
&& *ptr
!= '<') ptr
++;
827 type_identifier_length
= IDENTIFIER_LENGTH (type_encoding
);
829 sprintf (formatted_type_identifier_length
, "%d", type_identifier_length
);
831 if (TREE_CODE (methods
) != TREE_VEC
)
833 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
834 fndecl
= TREE_VEC_ELT (methods
, 0);
836 fndecl
= TREE_VEC_ELT (methods
, 1);
842 /* Group together all the methods for the same operation.
843 These differ in the types of the arguments. */
844 for (last
= NULL_TREE
;
845 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
846 fndecl
= TREE_CHAIN (fndecl
))
847 /* Output the name of the field (after overloading), as
848 well as the name of the field before overloading, along
849 with its parameter list */
851 /* This is the "mangled" name of the method.
852 It encodes the argument types. */
853 const char *debug_name
;
855 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
856 include TEMPLATE_DECLs.) The debugger doesn't know what
857 to do with such entities anyhow. */
858 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
862 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
));
868 /* Also ignore abstract methods; those are only interesting to
869 the DWARF backends. */
870 if (DECL_IGNORED_P (fndecl
) || DECL_ABSTRACT (fndecl
))
873 /* Redundantly output the plain name, since that's what gdb
877 tree name
= DECL_NAME (fndecl
);
878 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (name
));
879 CHARS (IDENTIFIER_LENGTH (name
) + 2);
883 dbxout_type (TREE_TYPE (fndecl
), 0);
885 dbxout_type_method_1 (fndecl
, debug_name
);
895 /* Emit a "range" type specification, which has the form:
896 "r<index type>;<lower bound>;<upper bound>;".
897 TYPE is an INTEGER_TYPE. */
900 dbxout_range_type (type
)
903 fprintf (asmfile
, "r");
904 if (TREE_TYPE (type
))
905 dbxout_type (TREE_TYPE (type
), 0);
906 else if (TREE_CODE (type
) != INTEGER_TYPE
)
907 dbxout_type (type
, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
910 /* Traditionally, we made sure 'int' was type 1, and builtin types
911 were defined to be sub-ranges of int. Unfortunately, this
912 does not allow us to distinguish true sub-ranges from integer
913 types. So, instead we define integer (non-sub-range) types as
914 sub-ranges of themselves. This matters for Chill. If this isn't
915 a subrange type, then we want to define it in terms of itself.
916 However, in C, this may be an anonymous integer type, and we don't
917 want to emit debug info referring to it. Just calling
918 dbxout_type_index won't work anyways, because the type hasn't been
919 defined yet. We make this work for both cases by checked to see
920 whether this is a defined type, referring to it if it is, and using
922 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
923 dbxout_type_index (type
);
925 dbxout_type_index (integer_type_node
);
928 if (TYPE_MIN_VALUE (type
) != 0
929 && host_integerp (TYPE_MIN_VALUE (type
), 0))
931 fputc (';', asmfile
);
932 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
933 tree_low_cst (TYPE_MIN_VALUE (type
), 0));
936 fprintf (asmfile
, ";0");
938 if (TYPE_MAX_VALUE (type
) != 0
939 && host_integerp (TYPE_MAX_VALUE (type
), 0))
941 fputc (';', asmfile
);
942 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
943 tree_low_cst (TYPE_MAX_VALUE (type
), 0));
944 fputc (';', asmfile
);
947 fprintf (asmfile
, ";-1;");
950 /* Output a reference to a type. If the type has not yet been
951 described in the dbx output, output its definition now.
952 For a type already defined, just refer to its definition
953 using the type number.
955 If FULL is nonzero, and the type has been described only with
956 a forward-reference, output the definition now.
957 If FULL is zero in this case, just refer to the forward-reference
958 using the number previously allocated. */
961 dbxout_type (type
, full
)
966 static int anonymous_type_number
= 0;
968 if (TREE_CODE (type
) == VECTOR_TYPE
)
969 type
= TYPE_DEBUG_REPRESENTATION_TYPE (type
);
971 /* If there was an input error and we don't really have a type,
972 avoid crashing and write something that is at least valid
973 by assuming `int'. */
974 if (type
== error_mark_node
)
975 type
= integer_type_node
;
978 /* Try to find the "main variant" with the same name but not const
979 or volatile. (Since stabs does not distinguish const and volatile,
980 there is no need to make them separate types. But types with
981 different names are usefully distinguished.) */
983 for (tem
= TYPE_MAIN_VARIANT (type
); tem
; tem
= TYPE_NEXT_VARIANT (tem
))
984 if (!TYPE_READONLY (tem
) && !TYPE_VOLATILE (tem
)
985 && TYPE_NAME (tem
) == TYPE_NAME (type
))
991 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
992 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
996 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
998 /* Type has no dbx number assigned. Assign next available number. */
999 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1001 /* Make sure type vector is long enough to record about this type. */
1003 if (next_type_number
== typevec_len
)
1006 = (struct typeinfo
*) xrealloc (typevec
,
1007 typevec_len
* 2 * sizeof typevec
[0]);
1008 memset ((char *) (typevec
+ typevec_len
), 0,
1009 typevec_len
* sizeof typevec
[0]);
1013 #ifdef DBX_USE_BINCL
1014 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1015 = current_file
->file_number
;
1016 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1017 = current_file
->next_type_number
++;
1021 /* Output the number of this type, to refer to it. */
1022 dbxout_type_index (type
);
1024 #ifdef DBX_TYPE_DEFINED
1025 if (DBX_TYPE_DEFINED (type
))
1029 /* If this type's definition has been output or is now being output,
1032 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1037 /* If we have already had a cross reference,
1038 and either that's all we want or that's the best we could do,
1039 don't repeat the cross reference.
1040 Sun dbx crashes if we do. */
1041 if (! full
|| !COMPLETE_TYPE_P (type
)
1042 /* No way in DBX fmt to describe a variable size. */
1043 || ! host_integerp (TYPE_SIZE (type
), 1))
1051 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1052 leave the type-number completely undefined rather than output
1053 a cross-reference. If we have already used GNU debug info extensions,
1054 then it is OK to output a cross reference. This is necessary to get
1055 proper C++ debug output. */
1056 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1057 || TREE_CODE (type
) == QUAL_UNION_TYPE
1058 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1059 && ! use_gnu_debug_info_extensions
)
1060 /* We must use the same test here as we use twice below when deciding
1061 whether to emit a cross-reference. */
1062 if ((TYPE_NAME (type
) != 0
1063 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1064 && DECL_IGNORED_P (TYPE_NAME (type
)))
1066 || !COMPLETE_TYPE_P (type
)
1067 /* No way in DBX fmt to describe a variable size. */
1068 || ! host_integerp (TYPE_SIZE (type
), 1))
1070 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1075 /* Output a definition now. */
1077 fprintf (asmfile
, "=");
1080 /* Mark it as defined, so that if it is self-referent
1081 we will not get into an infinite recursion of definitions. */
1083 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1085 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1086 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1088 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0);
1092 switch (TREE_CODE (type
))
1096 /* For a void type, just define it as itself; ie, "5=5".
1097 This makes us consider it defined
1098 without saying what it is. The debugger will make it
1099 a void type when the reference is seen, and nothing will
1100 ever override that default. */
1101 dbxout_type_index (type
);
1105 if (type
== char_type_node
&& ! TREE_UNSIGNED (type
))
1107 /* Output the type `char' as a subrange of itself!
1108 I don't understand this definition, just copied it
1109 from the output of pcc.
1110 This used to use `r2' explicitly and we used to
1111 take care to make sure that `char' was type number 2. */
1112 fprintf (asmfile
, "r");
1113 dbxout_type_index (type
);
1114 fprintf (asmfile
, ";0;127;");
1117 /* If this is a subtype of another integer type, always prefer to
1118 write it as a subtype. */
1119 else if (TREE_TYPE (type
) != 0
1120 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
1121 dbxout_range_type (type
);
1125 /* If the size is non-standard, say what it is if we can use
1128 if (use_gnu_debug_info_extensions
1129 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1130 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1132 /* If we can use GDB extensions and the size is wider than a
1133 long (the size used by GDB to read them) or we may have
1134 trouble writing the bounds the usual way, write them in
1135 octal. Note the test is for the *target's* size of "long",
1136 not that of the host. The host test is just to make sure we
1137 can write it out in case the host wide int is narrower than the
1140 /* For unsigned types, we use octal if they are the same size or
1141 larger. This is because we print the bounds as signed decimal,
1142 and hence they can't span same size unsigned types. */
1144 if (use_gnu_debug_info_extensions
1145 && TYPE_MIN_VALUE (type
) != 0
1146 && TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
1147 && TYPE_MAX_VALUE (type
) != 0
1148 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
1149 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
1150 || ((TYPE_PRECISION (type
)
1151 == TYPE_PRECISION (integer_type_node
))
1152 && TREE_UNSIGNED (type
))
1153 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
1154 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
1155 && TREE_UNSIGNED (type
))))
1157 fprintf (asmfile
, "r");
1158 dbxout_type_index (type
);
1159 fprintf (asmfile
, ";");
1160 print_int_cst_octal (TYPE_MIN_VALUE (type
));
1161 fprintf (asmfile
, ";");
1162 print_int_cst_octal (TYPE_MAX_VALUE (type
));
1163 fprintf (asmfile
, ";");
1167 /* Output other integer types as subranges of `int'. */
1168 dbxout_range_type (type
);
1175 /* This used to say `r1' and we used to take care
1176 to make sure that `int' was type number 1. */
1177 fprintf (asmfile
, "r");
1178 dbxout_type_index (integer_type_node
);
1179 fputc (';', asmfile
);
1180 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1181 fputs (";0;", asmfile
);
1186 if (use_gnu_debug_info_extensions
)
1188 fputs ("@s", asmfile
);
1189 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1190 BITS_PER_UNIT
* int_size_in_bytes (type
));
1191 fputs (";-20;", asmfile
);
1195 /* Output the type `char' as a subrange of itself.
1196 That is what pcc seems to do. */
1197 fprintf (asmfile
, "r");
1198 dbxout_type_index (char_type_node
);
1199 fprintf (asmfile
, ";0;%d;", TREE_UNSIGNED (type
) ? 255 : 127);
1205 if (use_gnu_debug_info_extensions
)
1207 fputs ("@s", asmfile
);
1208 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1209 BITS_PER_UNIT
* int_size_in_bytes (type
));
1210 fputs (";-16;", asmfile
);
1212 else /* Define as enumeral type (False, True) */
1213 fprintf (asmfile
, "eFalse:0,True:1,;");
1218 putc ('d', asmfile
);
1220 dbxout_type (TREE_TYPE (type
), 0);
1224 /* Differs from the REAL_TYPE by its new data type number */
1226 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1228 fprintf (asmfile
, "r");
1229 dbxout_type_index (type
);
1230 fputc (';', asmfile
);
1231 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1232 2 * int_size_in_bytes (TREE_TYPE (type
)));
1233 fputs (";0;", asmfile
);
1234 CHARS (12); /* The number is probably incorrect here. */
1238 /* Output a complex integer type as a structure,
1239 pending some other way to do it. */
1240 fputc ('s', asmfile
);
1241 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1243 fprintf (asmfile
, "real:");
1245 dbxout_type (TREE_TYPE (type
), 0);
1246 fprintf (asmfile
, ",%d,%d;",
1247 0, TYPE_PRECISION (TREE_TYPE (type
)));
1249 fprintf (asmfile
, "imag:");
1251 dbxout_type (TREE_TYPE (type
), 0);
1252 fprintf (asmfile
, ",%d,%d;;",
1253 TYPE_PRECISION (TREE_TYPE (type
)),
1254 TYPE_PRECISION (TREE_TYPE (type
)));
1260 if (use_gnu_debug_info_extensions
)
1262 have_used_extensions
= 1;
1263 fputs ("@s", asmfile
);
1264 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1265 BITS_PER_UNIT
* int_size_in_bytes (type
));
1266 fputc (';', asmfile
);
1267 /* Check if a bitstring type, which in Chill is
1268 different from a [power]set. */
1269 if (TYPE_STRING_FLAG (type
))
1270 fprintf (asmfile
, "@S;");
1272 putc ('S', asmfile
);
1274 dbxout_type (TYPE_DOMAIN (type
), 0);
1278 /* Make arrays of packed bits look like bitstrings for chill. */
1279 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
1281 have_used_extensions
= 1;
1282 fputs ("@s", asmfile
);
1283 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1284 BITS_PER_UNIT
* int_size_in_bytes (type
));
1285 fputc (';', asmfile
);
1286 fprintf (asmfile
, "@S;");
1287 putc ('S', asmfile
);
1289 dbxout_type (TYPE_DOMAIN (type
), 0);
1292 /* Output "a" followed by a range type definition
1293 for the index type of the array
1294 followed by a reference to the target-type.
1295 ar1;0;N;M for a C array of type M and size N+1. */
1296 /* Check if a character string type, which in Chill is
1297 different from an array of characters. */
1298 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
1300 have_used_extensions
= 1;
1301 fprintf (asmfile
, "@S;");
1303 tem
= TYPE_DOMAIN (type
);
1306 fprintf (asmfile
, "ar");
1307 dbxout_type_index (integer_type_node
);
1308 fprintf (asmfile
, ";0;-1;");
1312 fprintf (asmfile
, "a");
1313 dbxout_range_type (tem
);
1316 dbxout_type (TREE_TYPE (type
), 0);
1321 case QUAL_UNION_TYPE
:
1323 int i
, n_baseclasses
= 0;
1325 if (TYPE_BINFO (type
) != 0
1326 && TREE_CODE (TYPE_BINFO (type
)) == TREE_VEC
1327 && TYPE_BINFO_BASETYPES (type
) != 0)
1328 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
1330 /* Output a structure type. We must use the same test here as we
1331 use in the DBX_NO_XREFS case above. */
1332 if ((TYPE_NAME (type
) != 0
1333 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1334 && DECL_IGNORED_P (TYPE_NAME (type
)))
1336 || !COMPLETE_TYPE_P (type
)
1337 /* No way in DBX fmt to describe a variable size. */
1338 || ! host_integerp (TYPE_SIZE (type
), 1))
1340 /* If the type is just a cross reference, output one
1341 and mark the type as partially described.
1342 If it later becomes defined, we will output
1343 its real definition.
1344 If the type has a name, don't nest its definition within
1345 another type's definition; instead, output an xref
1346 and let the definition come when the name is defined. */
1347 fputs ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu", asmfile
);
1349 #if 0 /* This assertion is legitimately false in C++. */
1350 /* We shouldn't be outputting a reference to a type before its
1351 definition unless the type has a tag name.
1352 A typedef name without a tag name should be impossible. */
1353 if (TREE_CODE (TYPE_NAME (type
)) != IDENTIFIER_NODE
)
1356 if (TYPE_NAME (type
) != 0)
1357 dbxout_type_name (type
);
1359 fprintf (asmfile
, "$$%d", anonymous_type_number
++);
1360 fprintf (asmfile
, ":");
1361 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1365 /* Identify record or union, and print its size. */
1366 fputc (((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u'), asmfile
);
1367 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1368 int_size_in_bytes (type
));
1370 if (use_gnu_debug_info_extensions
)
1374 have_used_extensions
= 1;
1375 fprintf (asmfile
, "!%d,", n_baseclasses
);
1379 for (i
= 0; i
< n_baseclasses
; i
++)
1381 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)), i
);
1383 if (use_gnu_debug_info_extensions
)
1385 have_used_extensions
= 1;
1386 putc (TREE_VIA_VIRTUAL (child
) ? '1' : '0', asmfile
);
1387 putc (TREE_VIA_PUBLIC (child
) ? '2' : '0', asmfile
);
1388 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1389 (tree_low_cst (BINFO_OFFSET (child
), 0)
1391 fputc (',', asmfile
);
1393 dbxout_type (BINFO_TYPE (child
), 0);
1394 putc (';', asmfile
);
1398 /* Print out the base class information with fields
1399 which have the same names at the types they hold. */
1400 dbxout_type_name (BINFO_TYPE (child
));
1401 putc (':', asmfile
);
1402 dbxout_type (BINFO_TYPE (child
), full
);
1403 fputc (',', asmfile
);
1404 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1405 tree_low_cst (BINFO_OFFSET (child
), 0)
1407 fputc (',', asmfile
);
1408 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1409 (tree_low_cst (DECL_SIZE (TYPE_NAME
1410 (BINFO_TYPE (child
))), 0)
1412 fputc (';', asmfile
);
1420 /* Write out the field declarations. */
1421 dbxout_type_fields (type
);
1422 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1424 have_used_extensions
= 1;
1425 dbxout_type_methods (type
);
1428 putc (';', asmfile
);
1430 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1431 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1432 && TYPE_VFIELD (type
))
1434 have_used_extensions
= 1;
1436 /* Tell GDB+ that it may keep reading. */
1437 putc ('~', asmfile
);
1439 /* We need to write out info about what field this class
1440 uses as its "main" vtable pointer field, because if this
1441 field is inherited from a base class, GDB cannot necessarily
1442 figure out which field it's using in time. */
1443 if (TYPE_VFIELD (type
))
1445 putc ('%', asmfile
);
1446 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0);
1448 putc (';', asmfile
);
1454 /* We must use the same test here as we use in the DBX_NO_XREFS case
1455 above. We simplify it a bit since an enum will never have a variable
1457 if ((TYPE_NAME (type
) != 0
1458 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1459 && DECL_IGNORED_P (TYPE_NAME (type
)))
1461 || !COMPLETE_TYPE_P (type
))
1463 fprintf (asmfile
, "xe");
1465 dbxout_type_name (type
);
1466 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1467 fprintf (asmfile
, ":");
1470 #ifdef DBX_OUTPUT_ENUM
1471 DBX_OUTPUT_ENUM (asmfile
, type
);
1473 if (use_gnu_debug_info_extensions
1474 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1475 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1476 putc ('e', asmfile
);
1478 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1480 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)));
1481 if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == 0)
1482 fprintf (asmfile
, HOST_WIDE_INT_PRINT_UNSIGNED
,
1483 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1484 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == -1
1485 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (TREE_VALUE (tem
)) < 0)
1486 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1487 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1489 print_int_cst_octal (TREE_VALUE (tem
));
1490 fprintf (asmfile
, ",");
1491 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)));
1492 if (TREE_CHAIN (tem
) != 0)
1497 putc (';', asmfile
);
1503 putc ('*', asmfile
);
1505 dbxout_type (TREE_TYPE (type
), 0);
1509 if (use_gnu_debug_info_extensions
)
1511 have_used_extensions
= 1;
1512 putc ('#', asmfile
);
1515 /* Write the argument types out longhand. */
1516 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0);
1517 putc (',', asmfile
);
1519 dbxout_type (TREE_TYPE (type
), 0);
1520 dbxout_args (TYPE_ARG_TYPES (type
));
1521 putc (';', asmfile
);
1526 /* Treat it as a function type. */
1527 dbxout_type (TREE_TYPE (type
), 0);
1532 if (use_gnu_debug_info_extensions
)
1534 have_used_extensions
= 1;
1535 putc ('@', asmfile
);
1537 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0);
1538 putc (',', asmfile
);
1540 dbxout_type (TREE_TYPE (type
), 0);
1544 /* Should print as an int, because it is really
1546 dbxout_type (integer_type_node
, 0);
1550 case REFERENCE_TYPE
:
1551 if (use_gnu_debug_info_extensions
)
1552 have_used_extensions
= 1;
1553 putc (use_gnu_debug_info_extensions
? '&' : '*', asmfile
);
1555 dbxout_type (TREE_TYPE (type
), 0);
1559 putc ('f', asmfile
);
1561 dbxout_type (TREE_TYPE (type
), 0);
1569 /* Print the value of integer constant C, in octal,
1570 handling double precision. */
1573 print_int_cst_octal (c
)
1576 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (c
);
1577 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (c
);
1578 int excess
= (3 - (HOST_BITS_PER_WIDE_INT
% 3));
1579 unsigned int width
= TYPE_PRECISION (TREE_TYPE (c
));
1581 /* GDB wants constants with no extra leading "1" bits, so
1582 we need to remove any sign-extension that might be
1584 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
1586 else if (width
> HOST_BITS_PER_WIDE_INT
)
1587 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
1588 else if (width
== HOST_BITS_PER_WIDE_INT
)
1591 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
1593 fprintf (asmfile
, "0");
1597 print_octal (high
, HOST_BITS_PER_WIDE_INT
/ 3);
1598 print_octal (low
, HOST_BITS_PER_WIDE_INT
/ 3);
1602 unsigned HOST_WIDE_INT beg
= high
>> excess
;
1603 unsigned HOST_WIDE_INT middle
1604 = ((high
& (((HOST_WIDE_INT
) 1 << excess
) - 1)) << (3 - excess
)
1605 | (low
>> (HOST_BITS_PER_WIDE_INT
/ 3 * 3)));
1606 unsigned HOST_WIDE_INT end
1607 = low
& (((unsigned HOST_WIDE_INT
) 1
1608 << (HOST_BITS_PER_WIDE_INT
/ 3 * 3))
1611 fprintf (asmfile
, "%o%01o", (int) beg
, (int) middle
);
1612 print_octal (end
, HOST_BITS_PER_WIDE_INT
/ 3);
1617 print_octal (value
, digits
)
1618 unsigned HOST_WIDE_INT value
;
1623 for (i
= digits
- 1; i
>= 0; i
--)
1624 fprintf (asmfile
, "%01o", (int) ((value
>> (3 * i
)) & 7));
1627 /* Output the name of type TYPE, with no punctuation.
1628 Such names can be set up either by typedef declarations
1629 or by struct, enum and union tags. */
1632 dbxout_type_name (type
)
1636 if (TYPE_NAME (type
) == 0)
1638 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
1640 t
= TYPE_NAME (type
);
1642 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1644 t
= DECL_NAME (TYPE_NAME (type
));
1649 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
1650 CHARS (IDENTIFIER_LENGTH (t
));
1653 /* Output a .stabs for the symbol defined by DECL,
1654 which must be a ..._DECL node in the normal namespace.
1655 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1656 LOCAL is nonzero if the scope is less than the entire file.
1657 Return 1 if a stabs might have been emitted. */
1660 dbxout_symbol (decl
, local
)
1662 int local ATTRIBUTE_UNUSED
;
1664 tree type
= TREE_TYPE (decl
);
1665 tree context
= NULL_TREE
;
1668 /* Cast avoids warning in old compilers. */
1669 current_sym_code
= (STAB_CODE_TYPE
) 0;
1670 current_sym_value
= 0;
1671 current_sym_addr
= 0;
1673 /* Ignore nameless syms, but don't ignore type tags. */
1675 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
1676 || DECL_IGNORED_P (decl
))
1679 dbxout_prepare_symbol (decl
);
1681 /* The output will always start with the symbol name,
1682 so always count that in the length-output-so-far. */
1684 if (DECL_NAME (decl
) != 0)
1685 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
1687 switch (TREE_CODE (decl
))
1690 /* Enum values are defined by defining the enum type. */
1694 if (DECL_RTL (decl
) == 0)
1696 if (DECL_EXTERNAL (decl
))
1698 /* Don't mention a nested function under its parent. */
1699 context
= decl_function_context (decl
);
1700 if (context
== current_function_decl
)
1702 if (GET_CODE (DECL_RTL (decl
)) != MEM
1703 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
1707 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
1708 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1709 TREE_PUBLIC (decl
) ? 'F' : 'f');
1712 current_sym_code
= N_FUN
;
1713 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1715 if (TREE_TYPE (type
))
1716 dbxout_type (TREE_TYPE (type
), 0);
1718 dbxout_type (void_type_node
, 0);
1720 /* For a nested function, when that function is compiled,
1721 mention the containing function name
1722 as well as (since dbx wants it) our own assembler-name. */
1724 fprintf (asmfile
, ",%s,%s",
1725 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1726 IDENTIFIER_POINTER (DECL_NAME (context
)));
1728 dbxout_finish_symbol (decl
);
1733 /* This seems all wrong. Outputting most kinds of types gives no name
1734 at all. A true definition gives no name; a cross-ref for a
1735 structure can give the tag name, but not a type name.
1736 It seems that no typedef name is defined by outputting a type. */
1738 /* If this typedef name was defined by outputting the type,
1739 don't duplicate it. */
1740 if (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
== TYPE_DEFINED
1741 && TYPE_NAME (TREE_TYPE (decl
)) == decl
)
1744 /* Don't output the same typedef twice.
1745 And don't output what language-specific stuff doesn't want output. */
1746 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
1755 if (DECL_NAME (decl
))
1757 /* Nonzero means we must output a tag as well as a typedef. */
1760 /* Handle the case of a C++ structure or union
1761 where the TYPE_NAME is a TYPE_DECL
1762 which gives both a typedef name and a tag. */
1763 /* dbx requires the tag first and the typedef second. */
1764 if ((TREE_CODE (type
) == RECORD_TYPE
1765 || TREE_CODE (type
) == UNION_TYPE
1766 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1767 && TYPE_NAME (type
) == decl
1768 && !(use_gnu_debug_info_extensions
&& have_used_extensions
)
1769 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
1770 /* Distinguish the implicit typedefs of C++
1771 from explicit ones that might be found in C. */
1772 && DECL_ARTIFICIAL (decl
)
1773 /* Do not generate a tag for records of variable size,
1774 since this type can not be properly described in the
1775 DBX format, and it confuses some tools such as objdump. */
1776 && host_integerp (TYPE_SIZE (type
), 1))
1778 tree name
= TYPE_NAME (type
);
1779 if (TREE_CODE (name
) == TYPE_DECL
)
1780 name
= DECL_NAME (name
);
1782 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1783 current_sym_value
= 0;
1784 current_sym_addr
= 0;
1785 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1787 fprintf (asmfile
, "%s\"%s:T", ASM_STABS_OP
,
1788 IDENTIFIER_POINTER (name
));
1789 dbxout_type (type
, 1);
1790 dbxout_finish_symbol (NULL_TREE
);
1793 /* Output typedef name. */
1794 fprintf (asmfile
, "%s\"%s:", ASM_STABS_OP
,
1795 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1797 /* Short cut way to output a tag also. */
1798 if ((TREE_CODE (type
) == RECORD_TYPE
1799 || TREE_CODE (type
) == UNION_TYPE
1800 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1801 && TYPE_NAME (type
) == decl
1802 /* Distinguish the implicit typedefs of C++
1803 from explicit ones that might be found in C. */
1804 && DECL_ARTIFICIAL (decl
))
1806 if (use_gnu_debug_info_extensions
&& have_used_extensions
)
1808 putc ('T', asmfile
);
1809 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
1811 #if 0 /* Now we generate the tag for this case up above. */
1817 putc ('t', asmfile
);
1818 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1820 dbxout_type (type
, 1);
1821 dbxout_finish_symbol (decl
);
1825 /* Don't output a tag if this is an incomplete type. This prevents
1826 the sun4 Sun OS 4.x dbx from crashing. */
1828 if (tag_needed
&& TYPE_NAME (type
) != 0
1829 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
1830 || (DECL_NAME (TYPE_NAME (type
)) != 0))
1831 && COMPLETE_TYPE_P (type
)
1832 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1834 /* For a TYPE_DECL with no name, but the type has a name,
1836 This is what represents `struct foo' with no typedef. */
1837 /* In C++, the name of a type is the corresponding typedef.
1838 In C, it is an IDENTIFIER_NODE. */
1839 tree name
= TYPE_NAME (type
);
1840 if (TREE_CODE (name
) == TYPE_DECL
)
1841 name
= DECL_NAME (name
);
1843 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1844 current_sym_value
= 0;
1845 current_sym_addr
= 0;
1846 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1848 fprintf (asmfile
, "%s\"%s:T", ASM_STABS_OP
,
1849 IDENTIFIER_POINTER (name
));
1850 dbxout_type (type
, 1);
1851 dbxout_finish_symbol (NULL_TREE
);
1855 /* If an enum type has no name, it cannot be referred to,
1856 but we must output it anyway, since the enumeration constants
1857 can be referred to. */
1858 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
1860 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1861 current_sym_value
= 0;
1862 current_sym_addr
= 0;
1863 current_sym_nchars
= 2;
1865 /* Some debuggers fail when given NULL names, so give this a
1866 harmless name of ` '. */
1867 fprintf (asmfile
, "%s\" :T", ASM_STABS_OP
);
1868 dbxout_type (type
, 1);
1869 dbxout_finish_symbol (NULL_TREE
);
1872 /* Prevent duplicate output of a typedef. */
1873 TREE_ASM_WRITTEN (decl
) = 1;
1878 /* Parm decls go in their own separate chains
1879 and are output by dbxout_reg_parms and dbxout_parms. */
1883 /* Named return value, treat like a VAR_DECL. */
1885 if (! DECL_RTL_SET_P (decl
))
1887 /* Don't mention a variable that is external.
1888 Let the file that defines it describe it. */
1889 if (DECL_EXTERNAL (decl
))
1892 /* If the variable is really a constant
1893 and not written in memory, inform the debugger. */
1894 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
1895 && DECL_INITIAL (decl
) != 0
1896 && host_integerp (DECL_INITIAL (decl
), 0)
1897 && ! TREE_ASM_WRITTEN (decl
)
1898 && (DECL_CONTEXT (decl
) == NULL_TREE
1899 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
))
1901 if (TREE_PUBLIC (decl
) == 0)
1903 /* The sun4 assembler does not grok this. */
1904 const char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1906 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
1907 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
1909 HOST_WIDE_INT ival
= tree_low_cst (DECL_INITIAL (decl
), 0);
1910 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1911 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile
, name
, ival
);
1913 fprintf (asmfile
, "%s\"%s:c=i", ASM_STABS_OP
, name
);
1915 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, ival
);
1916 fprintf (asmfile
, "\",0x%x,0,0,0\n", N_LSYM
);
1920 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
1922 /* don't know how to do this yet. */
1926 /* else it is something we handle like a normal variable. */
1929 SET_DECL_RTL (decl
, eliminate_regs (DECL_RTL (decl
), 0, NULL_RTX
));
1930 #ifdef LEAF_REG_REMAP
1931 if (current_function_uses_only_leaf_regs
)
1932 leaf_renumber_regs_insn (DECL_RTL (decl
));
1935 result
= dbxout_symbol_location (decl
, type
, 0, DECL_RTL (decl
));
1944 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1945 Add SUFFIX to its name, if SUFFIX is not 0.
1946 Describe the variable as residing in HOME
1947 (usually HOME is DECL_RTL (DECL), but not always).
1948 Returns 1 if the stab was really emitted. */
1951 dbxout_symbol_location (decl
, type
, suffix
, home
)
1959 /* Don't mention a variable at all
1960 if it was completely optimized into nothingness.
1962 If the decl was from an inline function, then its rtl
1963 is not identically the rtl that was used in this
1964 particular compilation. */
1965 if (GET_CODE (home
) == REG
)
1967 regno
= REGNO (home
);
1968 if (regno
>= FIRST_PSEUDO_REGISTER
)
1971 else if (GET_CODE (home
) == SUBREG
)
1975 while (GET_CODE (value
) == SUBREG
)
1976 value
= SUBREG_REG (value
);
1977 if (GET_CODE (value
) == REG
)
1979 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
1982 regno
= REGNO (alter_subreg (home
));
1985 /* The kind-of-variable letter depends on where
1986 the variable is and on the scope of its name:
1987 G and N_GSYM for static storage and global scope,
1988 S for static storage and file scope,
1989 V for static storage and local scope,
1990 for those two, use N_LCSYM if data is in bss segment,
1991 N_STSYM if in data segment, N_FUN otherwise.
1992 (We used N_FUN originally, then changed to N_STSYM
1993 to please GDB. However, it seems that confused ld.
1994 Now GDB has been fixed to like N_FUN, says Kingdon.)
1995 no letter at all, and N_LSYM, for auto variable,
1996 r and N_RSYM for register variable. */
1998 if (GET_CODE (home
) == MEM
1999 && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2001 if (TREE_PUBLIC (decl
))
2004 current_sym_code
= N_GSYM
;
2008 current_sym_addr
= XEXP (home
, 0);
2010 letter
= decl_function_context (decl
) ? 'V' : 'S';
2012 /* This should be the same condition as in assemble_variable, but
2013 we don't have access to dont_output_data here. So, instead,
2014 we rely on the fact that error_mark_node initializers always
2015 end up in bss for C++ and never end up in bss for C. */
2016 if (DECL_INITIAL (decl
) == 0
2017 || (!strcmp (lang_identify (), "cplusplus")
2018 && DECL_INITIAL (decl
) == error_mark_node
))
2019 current_sym_code
= N_LCSYM
;
2020 else if (DECL_IN_TEXT_SECTION (decl
))
2021 /* This is not quite right, but it's the closest
2022 of all the codes that Unix defines. */
2023 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
2026 /* Ultrix `as' seems to need this. */
2027 #ifdef DBX_STATIC_STAB_DATA_SECTION
2030 current_sym_code
= N_STSYM
;
2034 else if (regno
>= 0)
2037 current_sym_code
= N_RSYM
;
2038 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
2040 else if (GET_CODE (home
) == MEM
2041 && (GET_CODE (XEXP (home
, 0)) == MEM
2042 || (GET_CODE (XEXP (home
, 0)) == REG
2043 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
2044 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
2045 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2046 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
2049 /* If the value is indirect by memory or by a register
2050 that isn't the frame pointer
2051 then it means the object is variable-sized and address through
2052 that register or stack slot. DBX has no way to represent this
2053 so all we can do is output the variable as a pointer.
2054 If it's not a parameter, ignore it.
2055 (VAR_DECLs like this can be made by integrate.c.) */
2057 if (GET_CODE (XEXP (home
, 0)) == REG
)
2060 current_sym_code
= N_RSYM
;
2061 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
2065 current_sym_code
= N_LSYM
;
2066 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2067 We want the value of that CONST_INT. */
2069 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
2072 /* Effectively do build_pointer_type, but don't cache this type,
2073 since it might be temporary whereas the type it points to
2074 might have been saved for inlining. */
2075 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2076 type
= make_node (POINTER_TYPE
);
2077 TREE_TYPE (type
) = TREE_TYPE (decl
);
2079 else if (GET_CODE (home
) == MEM
2080 && GET_CODE (XEXP (home
, 0)) == REG
)
2082 current_sym_code
= N_LSYM
;
2083 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2085 else if (GET_CODE (home
) == MEM
2086 && GET_CODE (XEXP (home
, 0)) == PLUS
2087 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
2089 current_sym_code
= N_LSYM
;
2090 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2091 We want the value of that CONST_INT. */
2092 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2094 else if (GET_CODE (home
) == MEM
2095 && GET_CODE (XEXP (home
, 0)) == CONST
)
2097 /* Handle an obscure case which can arise when optimizing and
2098 when there are few available registers. (This is *always*
2099 the case for i386/i486 targets). The RTL looks like
2100 (MEM (CONST ...)) even though this variable is a local `auto'
2101 or a local `register' variable. In effect, what has happened
2102 is that the reload pass has seen that all assignments and
2103 references for one such a local variable can be replaced by
2104 equivalent assignments and references to some static storage
2105 variable, thereby avoiding the need for a register. In such
2106 cases we're forced to lie to debuggers and tell them that
2107 this variable was itself `static'. */
2108 current_sym_code
= N_LCSYM
;
2110 current_sym_addr
= XEXP (XEXP (home
, 0), 0);
2112 else if (GET_CODE (home
) == CONCAT
)
2116 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
2117 for example), then there is no easy way to figure out
2118 what SUBTYPE should be. So, we give up. */
2119 if (TREE_CODE (type
) != COMPLEX_TYPE
)
2122 subtype
= TREE_TYPE (type
);
2124 /* If the variable's storage is in two parts,
2125 output each as a separate stab with a modified name. */
2126 if (WORDS_BIG_ENDIAN
)
2127 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
2129 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
2131 /* Cast avoids warning in old compilers. */
2132 current_sym_code
= (STAB_CODE_TYPE
) 0;
2133 current_sym_value
= 0;
2134 current_sym_addr
= 0;
2135 dbxout_prepare_symbol (decl
);
2137 if (WORDS_BIG_ENDIAN
)
2138 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
2140 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
2144 /* Address might be a MEM, when DECL is a variable-sized object.
2145 Or it might be const0_rtx, meaning previous passes
2146 want us to ignore this variable. */
2149 /* Ok, start a symtab entry and output the variable name. */
2152 #ifdef DBX_STATIC_BLOCK_START
2153 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
2156 dbxout_symbol_name (decl
, suffix
, letter
);
2157 dbxout_type (type
, 0);
2158 dbxout_finish_symbol (decl
);
2160 #ifdef DBX_STATIC_BLOCK_END
2161 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
2166 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2167 Then output LETTER to indicate the kind of location the symbol has. */
2170 dbxout_symbol_name (decl
, suffix
, letter
)
2177 if (DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
)))
2178 /* One slight hitch: if this is a VAR_DECL which is a static
2179 class member, we must put out the mangled name instead of the
2180 DECL_NAME. Note also that static member (variable) names DO NOT begin
2181 with underscores in .stabs directives. */
2182 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2184 /* ...but if we're function-local, we don't want to include the junk
2185 added by ASM_FORMAT_PRIVATE_NAME. */
2186 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
2190 fprintf (asmfile
, "%s\"%s%s:", ASM_STABS_OP
, name
,
2191 (suffix
? suffix
: ""));
2193 if (letter
) putc (letter
, asmfile
);
2197 dbxout_prepare_symbol (decl
)
2198 tree decl ATTRIBUTE_UNUSED
;
2201 const char *filename
= DECL_SOURCE_FILE (decl
);
2203 dbxout_source_file (asmfile
, filename
);
2208 dbxout_finish_symbol (sym
)
2211 #ifdef DBX_FINISH_SYMBOL
2212 DBX_FINISH_SYMBOL (sym
);
2215 if (use_gnu_debug_info_extensions
&& sym
!= 0)
2216 line
= DECL_SOURCE_LINE (sym
);
2218 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
2219 if (current_sym_addr
)
2220 output_addr_const (asmfile
, current_sym_addr
);
2222 fprintf (asmfile
, "%d", current_sym_value
);
2223 putc ('\n', asmfile
);
2227 /* Output definitions of all the decls in a chain. Return non-zero if
2228 anything was output */
2237 result
+= dbxout_symbol (syms
, 1);
2238 syms
= TREE_CHAIN (syms
);
2243 /* The following two functions output definitions of function parameters.
2244 Each parameter gets a definition locating it in the parameter list.
2245 Each parameter that is a register variable gets a second definition
2246 locating it in the register.
2248 Printing or argument lists in gdb uses the definitions that
2249 locate in the parameter list. But reference to the variable in
2250 expressions uses preferentially the definition as a register. */
2252 /* Output definitions, referring to storage in the parmlist,
2253 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2256 dbxout_parms (parms
)
2259 for (; parms
; parms
= TREE_CHAIN (parms
))
2260 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
2262 dbxout_prepare_symbol (parms
);
2264 /* Perform any necessary register eliminations on the parameter's rtl,
2265 so that the debugging output will be accurate. */
2266 DECL_INCOMING_RTL (parms
)
2267 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
2268 SET_DECL_RTL (parms
, eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
));
2269 #ifdef LEAF_REG_REMAP
2270 if (current_function_uses_only_leaf_regs
)
2272 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
2273 leaf_renumber_regs_insn (DECL_RTL (parms
));
2277 if (PARM_PASSED_IN_MEMORY (parms
))
2279 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
2281 /* ??? Here we assume that the parm address is indexed
2282 off the frame pointer or arg pointer.
2283 If that is not true, we produce meaningless results,
2284 but do not crash. */
2285 if (GET_CODE (addr
) == PLUS
2286 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
2287 current_sym_value
= INTVAL (XEXP (addr
, 1));
2289 current_sym_value
= 0;
2291 current_sym_code
= N_PSYM
;
2292 current_sym_addr
= 0;
2295 if (DECL_NAME (parms
))
2297 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2299 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2300 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2301 DBX_MEMPARM_STABS_LETTER
);
2305 current_sym_nchars
= 8;
2306 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2307 DBX_MEMPARM_STABS_LETTER
);
2310 /* It is quite tempting to use:
2312 dbxout_type (TREE_TYPE (parms), 0);
2314 as the next statement, rather than using DECL_ARG_TYPE(), so
2315 that gcc reports the actual type of the parameter, rather
2316 than the promoted type. This certainly makes GDB's life
2317 easier, at least for some ports. The change is a bad idea
2318 however, since GDB expects to be able access the type without
2319 performing any conversions. So for example, if we were
2320 passing a float to an unprototyped function, gcc will store a
2321 double on the stack, but if we emit a stab saying the type is a
2322 float, then gdb will only read in a single value, and this will
2323 produce an erropneous value. */
2324 dbxout_type (DECL_ARG_TYPE (parms
), 0);
2325 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
2326 dbxout_finish_symbol (parms
);
2328 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
2331 char regparm_letter
;
2333 /* Parm passed in registers and lives in registers or nowhere. */
2335 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2336 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2337 current_sym_addr
= 0;
2339 /* If parm lives in a register, use that register;
2340 pretend the parm was passed there. It would be more consistent
2341 to describe the register where the parm was passed,
2342 but in practice that register usually holds something else.
2344 If we use DECL_RTL, then we must use the declared type of
2345 the variable, not the type that it arrived in. */
2346 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2348 best_rtl
= DECL_RTL (parms
);
2349 parm_type
= TREE_TYPE (parms
);
2351 /* If the parm lives nowhere, use the register where it was
2352 passed. It is also better to use the declared type here. */
2355 best_rtl
= DECL_INCOMING_RTL (parms
);
2356 parm_type
= TREE_TYPE (parms
);
2358 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
2361 if (DECL_NAME (parms
))
2363 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2364 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2365 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2370 current_sym_nchars
= 8;
2371 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2375 dbxout_type (parm_type
, 0);
2376 dbxout_finish_symbol (parms
);
2378 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2379 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
2380 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
2381 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
2382 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2383 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
2387 /* Parm was passed via invisible reference.
2388 That is, its address was passed in a register.
2389 Output it as if it lived in that register.
2390 The debugger will know from the type
2391 that it was actually passed by invisible reference. */
2393 char regparm_letter
;
2394 /* Parm passed in registers and lives in registers or nowhere. */
2396 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2397 if (use_gnu_debug_info_extensions
)
2398 regparm_letter
= GDB_INV_REF_REGPARM_STABS_LETTER
;
2400 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2402 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2403 If it is an unallocated pseudo-reg, then use the register where
2404 it was passed instead. */
2405 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
2406 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
2408 current_sym_value
= REGNO (DECL_INCOMING_RTL (parms
));
2410 current_sym_addr
= 0;
2413 if (DECL_NAME (parms
))
2415 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2417 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2418 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2423 current_sym_nchars
= 8;
2424 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2428 dbxout_type (TREE_TYPE (parms
), 0);
2429 dbxout_finish_symbol (parms
);
2431 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2432 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
2434 /* Parm was passed via invisible reference, with the reference
2435 living on the stack. DECL_RTL looks like
2436 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
2437 could look like (MEM (MEM (REG))). */
2438 const char *decl_name
= (DECL_NAME (parms
)
2439 ? IDENTIFIER_POINTER (DECL_NAME (parms
))
2441 if (GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 0)) == REG
)
2442 current_sym_value
= 0;
2445 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
2446 current_sym_addr
= 0;
2449 fprintf (asmfile
, "%s\"%s:v", ASM_STABS_OP
, decl_name
);
2450 dbxout_type (TREE_TYPE (parms
), 0);
2451 dbxout_finish_symbol (parms
);
2453 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2454 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
2455 /* ??? A constant address for a parm can happen
2456 when the reg it lives in is equiv to a constant in memory.
2457 Should make this not happen, after 2.4. */
2458 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
2460 /* Parm was passed in registers but lives on the stack. */
2462 current_sym_code
= N_PSYM
;
2463 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2464 in which case we want the value of that CONST_INT,
2466 in which case we use a value of zero. */
2467 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
)
2468 current_sym_value
= 0;
2471 = INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
2473 current_sym_addr
= 0;
2475 /* Make a big endian correction if the mode of the type of the
2476 parameter is not the same as the mode of the rtl. */
2477 if (BYTES_BIG_ENDIAN
2478 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
2479 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
2481 current_sym_value
+=
2482 GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
2483 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
)));
2487 if (DECL_NAME (parms
))
2490 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2492 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2493 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2494 DBX_MEMPARM_STABS_LETTER
);
2498 current_sym_nchars
= 8;
2499 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2500 DBX_MEMPARM_STABS_LETTER
);
2504 = DEBUGGER_ARG_OFFSET (current_sym_value
,
2505 XEXP (DECL_RTL (parms
), 0));
2506 dbxout_type (TREE_TYPE (parms
), 0);
2507 dbxout_finish_symbol (parms
);
2512 /* Output definitions for the places where parms live during the function,
2513 when different from where they were passed, when the parms were passed
2516 It is not useful to do this for parms passed in registers
2517 that live during the function in different registers, because it is
2518 impossible to look in the passed register for the passed value,
2519 so we use the within-the-function register to begin with.
2521 PARMS is a chain of PARM_DECL nodes. */
2524 dbxout_reg_parms (parms
)
2527 for (; parms
; parms
= TREE_CHAIN (parms
))
2528 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
2530 dbxout_prepare_symbol (parms
);
2532 /* Report parms that live in registers during the function
2533 but were passed in memory. */
2534 if (GET_CODE (DECL_RTL (parms
)) == REG
2535 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2536 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2537 0, DECL_RTL (parms
));
2538 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
2539 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2540 0, DECL_RTL (parms
));
2541 /* Report parms that live in memory but not where they were passed. */
2542 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2543 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
2544 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2545 0, DECL_RTL (parms
));
2549 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2550 output definitions of those names, in raw form */
2558 putc (',', asmfile
);
2559 dbxout_type (TREE_VALUE (args
), 0);
2561 args
= TREE_CHAIN (args
);
2565 /* Given a chain of ..._TYPE nodes,
2566 find those which have typedef names and output those names.
2567 This is to ensure those types get output. */
2570 dbxout_types (types
)
2571 register tree types
;
2575 if (TYPE_NAME (types
)
2576 && TREE_CODE (TYPE_NAME (types
)) == TYPE_DECL
2577 && ! TREE_ASM_WRITTEN (TYPE_NAME (types
)))
2578 dbxout_symbol (TYPE_NAME (types
), 1);
2579 types
= TREE_CHAIN (types
);
2583 /* Output everything about a symbol block (a BLOCK node
2584 that represents a scope level),
2585 including recursive output of contained blocks.
2587 BLOCK is the BLOCK node.
2588 DEPTH is its depth within containing symbol blocks.
2589 ARGS is usually zero; but for the outermost block of the
2590 body of a function, it is a chain of PARM_DECLs for the function parameters.
2591 We output definitions of all the register parms
2592 as if they were local variables of that block.
2594 If -g1 was used, we count blocks just the same, but output nothing
2595 except for the outermost block.
2597 Actually, BLOCK may be several blocks chained together.
2598 We handle them all in sequence. */
2601 dbxout_block (block
, depth
, args
)
2602 register tree block
;
2608 #if DBX_BLOCKS_FUNCTION_RELATIVE
2609 const char *begin_label
;
2610 if (current_function_func_begin_label
!= NULL_TREE
)
2611 begin_label
= IDENTIFIER_POINTER (current_function_func_begin_label
);
2613 begin_label
= XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0);
2618 /* Ignore blocks never expanded or otherwise marked as real. */
2619 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
2623 #ifdef DBX_LBRAC_FIRST
2626 /* In dbx format, the syms of a block come before the N_LBRAC.
2627 If nothing is output, we don't need the N_LBRAC, either. */
2629 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2630 did_output
= dbxout_syms (BLOCK_VARS (block
));
2632 dbxout_reg_parms (args
);
2635 /* Now output an N_LBRAC symbol to represent the beginning of
2636 the block. Use the block's tree-walk order to generate
2637 the assembler symbols LBBn and LBEn
2638 that final will define around the code in this block. */
2639 if (depth
> 0 && did_output
)
2642 blocknum
= BLOCK_NUMBER (block
);
2643 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
2645 if (BLOCK_HANDLER_BLOCK (block
))
2647 /* A catch block. Must precede N_LBRAC. */
2648 tree decl
= BLOCK_VARS (block
);
2651 #ifdef DBX_OUTPUT_CATCH
2652 DBX_OUTPUT_CATCH (asmfile
, decl
, buf
);
2654 fprintf (asmfile
, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP
,
2655 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
2656 assemble_name (asmfile
, buf
);
2657 fprintf (asmfile
, "\n");
2659 decl
= TREE_CHAIN (decl
);
2663 #ifdef DBX_OUTPUT_LBRAC
2664 DBX_OUTPUT_LBRAC (asmfile
, buf
);
2666 fprintf (asmfile
, "%s%d,0,0,", ASM_STABN_OP
, N_LBRAC
);
2667 assemble_name (asmfile
, buf
);
2668 #if DBX_BLOCKS_FUNCTION_RELATIVE
2669 fputc ('-', asmfile
);
2670 assemble_name (asmfile
, begin_label
);
2672 fprintf (asmfile
, "\n");
2676 #ifdef DBX_LBRAC_FIRST
2677 /* On some weird machines, the syms of a block
2678 come after the N_LBRAC. */
2679 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2680 dbxout_syms (BLOCK_VARS (block
));
2682 dbxout_reg_parms (args
);
2685 /* Output the subblocks. */
2686 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
2688 /* Refer to the marker for the end of the block. */
2689 if (depth
> 0 && did_output
)
2692 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
2693 #ifdef DBX_OUTPUT_RBRAC
2694 DBX_OUTPUT_RBRAC (asmfile
, buf
);
2696 fprintf (asmfile
, "%s%d,0,0,", ASM_STABN_OP
, N_RBRAC
);
2697 assemble_name (asmfile
, buf
);
2698 #if DBX_BLOCKS_FUNCTION_RELATIVE
2699 fputc ('-', asmfile
);
2700 assemble_name (asmfile
, begin_label
);
2702 fprintf (asmfile
, "\n");
2706 block
= BLOCK_CHAIN (block
);
2710 /* Output the information about a function and its arguments and result.
2711 Usually this follows the function's code,
2712 but on some systems, it comes before. */
2715 dbxout_really_begin_function (decl
)
2718 dbxout_symbol (decl
, 0);
2719 dbxout_parms (DECL_ARGUMENTS (decl
));
2720 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
2721 dbxout_symbol (DECL_RESULT (decl
), 1);
2724 /* Called at beginning of output of function definition. */
2727 dbxout_begin_function (decl
)
2728 tree decl ATTRIBUTE_UNUSED
;
2730 #ifdef DBX_FUNCTION_FIRST
2731 dbxout_really_begin_function (decl
);
2735 /* Output dbx data for a function definition.
2736 This includes a definition of the function name itself (a symbol),
2737 definitions of the parameters (locating them in the parameter list)
2738 and then output the block that makes up the function's body
2739 (including all the auto variables of the function). */
2742 dbxout_function (decl
)
2745 #ifndef DBX_FUNCTION_FIRST
2746 dbxout_really_begin_function (decl
);
2748 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
2749 #ifdef DBX_OUTPUT_FUNCTION_END
2750 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
2752 #if defined(ASM_OUTPUT_SECTION_NAME)
2753 if (use_gnu_debug_info_extensions
2754 #if defined(NO_DBX_FUNCTION_END)
2755 && ! NO_DBX_FUNCTION_END
2758 dbxout_function_end ();
2761 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */