* config/i386/i386.h (TARGET_SUPPORTS_WIDE_INT): New define.
[official-gcc.git] / gcc / dbxout.c
blob758c1c439fabc5d4affc69723001d1a440a8a15e
1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987-2015 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
21 /* Output dbx-format symbol table data.
22 This consists of many symbol table entries, each of them
23 a .stabs assembler pseudo-op with four operands:
24 a "name" which is really a description of one symbol and its type,
25 a "code", which is a symbol defined in stab.h whose name starts with N_,
26 an unused operand always 0,
27 and a "value" which is an address or an offset.
28 The name is enclosed in doublequote characters.
30 Each function, variable, typedef, and structure tag
31 has a symbol table entry to define it.
32 The beginning and end of each level of name scoping within
33 a function are also marked by special symbol table entries.
35 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
36 and a data type number. The data type number may be followed by
37 "=" and a type definition; normally this will happen the first time
38 the type number is mentioned. The type definition may refer to
39 other types by number, and those type numbers may be followed
40 by "=" and nested definitions.
42 This can make the "name" quite long.
43 When a name is more than 80 characters, we split the .stabs pseudo-op
44 into two .stabs pseudo-ops, both sharing the same "code" and "value".
45 The first one is marked as continued with a double-backslash at the
46 end of its "name".
48 The kind-of-symbol letter distinguished function names from global
49 variables from file-scope variables from parameters from auto
50 variables in memory from typedef names from register variables.
51 See `dbxout_symbol'.
53 The "code" is mostly redundant with the kind-of-symbol letter
54 that goes in the "name", but not entirely: for symbols located
55 in static storage, the "code" says which segment the address is in,
56 which controls how it is relocated.
58 The "value" for a symbol in static storage
59 is the core address of the symbol (actually, the assembler
60 label for the symbol). For a symbol located in a stack slot
61 it is the stack offset; for one in a register, the register number.
62 For a typedef symbol, it is zero.
64 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
65 output while in the text section.
67 For more on data type definitions, see `dbxout_type'. */
69 #include "config.h"
70 #include "system.h"
71 #include "coretypes.h"
72 #include "tm.h"
73 #include "hash-set.h"
74 #include "machmode.h"
75 #include "vec.h"
76 #include "double-int.h"
77 #include "input.h"
78 #include "alias.h"
79 #include "symtab.h"
80 #include "wide-int.h"
81 #include "inchash.h"
82 #include "tree.h"
83 #include "fold-const.h"
84 #include "varasm.h"
85 #include "stor-layout.h"
86 #include "rtl.h"
87 #include "flags.h"
88 #include "regs.h"
89 #include "insn-config.h"
90 #include "reload.h"
91 #include "output.h"
92 #include "dbxout.h"
93 #include "diagnostic-core.h"
94 #include "toplev.h"
95 #include "tm_p.h"
96 #include "ggc.h"
97 #include "debug.h"
98 #include "hashtab.h"
99 #include "hard-reg-set.h"
100 #include "function.h"
101 #include "target.h"
102 #include "common/common-target.h"
103 #include "langhooks.h"
104 #include "obstack.h"
105 #include "statistics.h"
106 #include "real.h"
107 #include "fixed-value.h"
108 #include "expmed.h"
109 #include "dojump.h"
110 #include "explow.h"
111 #include "calls.h"
112 #include "emit-rtl.h"
113 #include "stmt.h"
114 #include "expr.h"
115 #include "hash-map.h"
116 #include "is-a.h"
117 #include "plugin-api.h"
118 #include "ipa-ref.h"
119 #include "cgraph.h"
120 #include "stringpool.h"
122 #ifdef XCOFF_DEBUGGING_INFO
123 #include "xcoffout.h"
124 #endif
126 #ifndef ASM_STABS_OP
127 # ifdef XCOFF_DEBUGGING_INFO
128 # define ASM_STABS_OP "\t.stabx\t"
129 # else
130 # define ASM_STABS_OP "\t.stabs\t"
131 # endif
132 #endif
134 #ifndef ASM_STABN_OP
135 #define ASM_STABN_OP "\t.stabn\t"
136 #endif
138 #ifndef ASM_STABD_OP
139 #define ASM_STABD_OP "\t.stabd\t"
140 #endif
142 #ifndef DBX_TYPE_DECL_STABS_CODE
143 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
144 #endif
146 #ifndef DBX_STATIC_CONST_VAR_CODE
147 #define DBX_STATIC_CONST_VAR_CODE N_FUN
148 #endif
150 #ifndef DBX_REGPARM_STABS_CODE
151 #define DBX_REGPARM_STABS_CODE N_RSYM
152 #endif
154 #ifndef DBX_REGPARM_STABS_LETTER
155 #define DBX_REGPARM_STABS_LETTER 'P'
156 #endif
158 #ifndef NO_DBX_FUNCTION_END
159 #define NO_DBX_FUNCTION_END 0
160 #endif
162 #ifndef NO_DBX_BNSYM_ENSYM
163 #define NO_DBX_BNSYM_ENSYM 0
164 #endif
166 #ifndef NO_DBX_MAIN_SOURCE_DIRECTORY
167 #define NO_DBX_MAIN_SOURCE_DIRECTORY 0
168 #endif
170 #ifndef DBX_BLOCKS_FUNCTION_RELATIVE
171 #define DBX_BLOCKS_FUNCTION_RELATIVE 0
172 #endif
174 #ifndef DBX_LINES_FUNCTION_RELATIVE
175 #define DBX_LINES_FUNCTION_RELATIVE 0
176 #endif
178 #ifndef DBX_CONTIN_LENGTH
179 #define DBX_CONTIN_LENGTH 80
180 #endif
182 #ifndef DBX_CONTIN_CHAR
183 #define DBX_CONTIN_CHAR '\\'
184 #endif
186 enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
188 /* Structure recording information about a C data type.
189 The status element says whether we have yet output
190 the definition of the type. TYPE_XREF says we have
191 output it as a cross-reference only.
192 The file_number and type_number elements are used if DBX_USE_BINCL
193 is defined. */
195 struct GTY(()) typeinfo {
196 enum typestatus status;
197 int file_number;
198 int type_number;
201 /* Vector recording information about C data types.
202 When we first notice a data type (a tree node),
203 we assign it a number using next_type_number.
204 That is its index in this vector. */
206 static GTY ((length ("typevec_len"))) struct typeinfo *typevec;
208 /* Number of elements of space allocated in `typevec'. */
210 static GTY(()) int typevec_len;
212 /* In dbx output, each type gets a unique number.
213 This is the number for the next type output.
214 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
216 static GTY(()) int next_type_number;
218 /* The C front end may call dbxout_symbol before dbxout_init runs.
219 We save all such decls in this list and output them when we get
220 to dbxout_init. */
222 static GTY(()) tree preinit_symbols;
224 enum binclstatus {BINCL_NOT_REQUIRED, BINCL_PENDING, BINCL_PROCESSED};
226 /* When using N_BINCL in dbx output, each type number is actually a
227 pair of the file number and the type number within the file.
228 This is a stack of input files. */
230 struct dbx_file
232 struct dbx_file *next;
233 int file_number;
234 int next_type_number;
235 enum binclstatus bincl_status; /* Keep track of lazy bincl. */
236 const char *pending_bincl_name; /* Name of bincl. */
237 struct dbx_file *prev; /* Chain to traverse all pending bincls. */
240 /* This is the top of the stack.
242 This is not saved for PCH, because restoring a PCH should not change it.
243 next_file_number does have to be saved, because the PCH may use some
244 file numbers; however, just before restoring a PCH, next_file_number
245 should always be 0 because we should not have needed any file numbers
246 yet. */
248 #if (defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)) \
249 && defined (DBX_USE_BINCL)
250 static struct dbx_file *current_file;
251 #endif
253 /* This is the next file number to use. */
255 static GTY(()) int next_file_number;
257 /* A counter for dbxout_function_end. */
259 static GTY(()) int scope_labelno;
261 /* A counter for dbxout_source_line. */
263 static GTY(()) int dbxout_source_line_counter;
265 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
266 for the N_SO filename stabs label. */
268 static GTY(()) int source_label_number = 1;
270 /* Last source file name mentioned in a NOTE insn. */
272 static GTY(()) const char *lastfile;
274 /* Used by PCH machinery to detect if 'lastfile' should be reset to
275 base_input_file. */
276 static GTY(()) int lastfile_is_base;
278 /* Typical USG systems don't have stab.h, and they also have
279 no use for DBX-format debugging info. */
281 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
283 #ifdef DBX_USE_BINCL
284 /* If zero then there is no pending BINCL. */
285 static int pending_bincls = 0;
286 #endif
288 /* The original input file name. */
289 static const char *base_input_file;
291 #ifdef DEBUG_SYMS_TEXT
292 #define FORCE_TEXT switch_to_section (current_function_section ())
293 #else
294 #define FORCE_TEXT
295 #endif
297 #include "gstab.h"
299 /* 1 if PARM is passed to this function in memory. */
301 #define PARM_PASSED_IN_MEMORY(PARM) \
302 (MEM_P (DECL_INCOMING_RTL (PARM)))
304 /* A C expression for the integer offset value of an automatic variable
305 (N_LSYM) having address X (an RTX). */
306 #ifndef DEBUGGER_AUTO_OFFSET
307 #define DEBUGGER_AUTO_OFFSET(X) \
308 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
309 #endif
311 /* A C expression for the integer offset value of an argument (N_PSYM)
312 having address X (an RTX). The nominal offset is OFFSET.
313 Note that we use OFFSET + 0 here to avoid the self-assign warning
314 when the macro is called in a context like
315 number = DEBUGGER_ARG_OFFSET(number, X) */
316 #ifndef DEBUGGER_ARG_OFFSET
317 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET + 0)
318 #endif
320 /* This obstack holds the stab string currently being constructed. We
321 build it up here, then write it out, so we can split long lines up
322 properly (see dbxout_finish_complex_stabs). */
323 static struct obstack stabstr_ob;
324 static size_t stabstr_last_contin_point;
326 #ifdef DBX_USE_BINCL
327 static void emit_bincl_stab (const char *c);
328 static void emit_pending_bincls (void);
329 #endif
330 static inline void emit_pending_bincls_if_required (void);
332 static void dbxout_init (const char *);
334 static void dbxout_finish (const char *);
335 static void dbxout_start_source_file (unsigned, const char *);
336 static void dbxout_end_source_file (unsigned);
337 static void dbxout_typedefs (tree);
338 static void dbxout_type_index (tree);
339 static void dbxout_args (tree);
340 static void dbxout_type_fields (tree);
341 static void dbxout_type_method_1 (tree);
342 static void dbxout_type_methods (tree);
343 static void dbxout_range_type (tree, tree, tree);
344 static void dbxout_type (tree, int);
345 static bool print_int_cst_bounds_in_octal_p (tree, tree, tree);
346 static bool is_fortran (void);
347 static void dbxout_type_name (tree);
348 static void dbxout_class_name_qualifiers (tree);
349 static int dbxout_symbol_location (tree, tree, const char *, rtx);
350 static void dbxout_symbol_name (tree, const char *, int);
351 static void dbxout_common_name (tree, const char *, stab_code_type);
352 static const char *dbxout_common_check (tree, int *);
353 static void dbxout_global_decl (tree);
354 static void dbxout_type_decl (tree, int);
355 static void dbxout_handle_pch (unsigned);
356 static void debug_free_queue (void);
358 /* The debug hooks structure. */
359 #if defined (DBX_DEBUGGING_INFO)
361 static void dbxout_source_line (unsigned int, const char *, int, bool);
362 static void dbxout_begin_prologue (unsigned int, const char *);
363 static void dbxout_source_file (const char *);
364 static void dbxout_function_end (tree);
365 static void dbxout_begin_function (tree);
366 static void dbxout_begin_block (unsigned, unsigned);
367 static void dbxout_end_block (unsigned, unsigned);
368 static void dbxout_function_decl (tree);
370 const struct gcc_debug_hooks dbx_debug_hooks =
372 dbxout_init,
373 dbxout_finish,
374 debug_nothing_void,
375 debug_nothing_int_charstar,
376 debug_nothing_int_charstar,
377 dbxout_start_source_file,
378 dbxout_end_source_file,
379 dbxout_begin_block,
380 dbxout_end_block,
381 debug_true_const_tree, /* ignore_block */
382 dbxout_source_line, /* source_line */
383 dbxout_begin_prologue, /* begin_prologue */
384 debug_nothing_int_charstar, /* end_prologue */
385 debug_nothing_int_charstar, /* begin_epilogue */
386 debug_nothing_int_charstar, /* end_epilogue */
387 #ifdef DBX_FUNCTION_FIRST
388 dbxout_begin_function,
389 #else
390 debug_nothing_tree, /* begin_function */
391 #endif
392 debug_nothing_int, /* end_function */
393 dbxout_function_decl,
394 dbxout_global_decl, /* global_decl */
395 dbxout_type_decl, /* type_decl */
396 debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */
397 debug_nothing_tree, /* deferred_inline_function */
398 debug_nothing_tree, /* outlining_inline_function */
399 debug_nothing_rtx_code_label, /* label */
400 dbxout_handle_pch, /* handle_pch */
401 debug_nothing_rtx_insn, /* var_location */
402 debug_nothing_void, /* switch_text_section */
403 debug_nothing_tree_tree, /* set_name */
404 0, /* start_end_main_source_file */
405 TYPE_SYMTAB_IS_ADDRESS /* tree_type_symtab_field */
407 #endif /* DBX_DEBUGGING_INFO */
409 #if defined (XCOFF_DEBUGGING_INFO)
410 const struct gcc_debug_hooks xcoff_debug_hooks =
412 dbxout_init,
413 dbxout_finish,
414 debug_nothing_void,
415 debug_nothing_int_charstar,
416 debug_nothing_int_charstar,
417 dbxout_start_source_file,
418 dbxout_end_source_file,
419 xcoffout_begin_block,
420 xcoffout_end_block,
421 debug_true_const_tree, /* ignore_block */
422 xcoffout_source_line,
423 xcoffout_begin_prologue, /* begin_prologue */
424 debug_nothing_int_charstar, /* end_prologue */
425 debug_nothing_int_charstar, /* begin_epilogue */
426 xcoffout_end_epilogue,
427 debug_nothing_tree, /* begin_function */
428 xcoffout_end_function,
429 debug_nothing_tree, /* function_decl */
430 dbxout_global_decl, /* global_decl */
431 dbxout_type_decl, /* type_decl */
432 debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */
433 debug_nothing_tree, /* deferred_inline_function */
434 debug_nothing_tree, /* outlining_inline_function */
435 debug_nothing_rtx_code_label, /* label */
436 dbxout_handle_pch, /* handle_pch */
437 debug_nothing_rtx_insn, /* var_location */
438 debug_nothing_void, /* switch_text_section */
439 debug_nothing_tree_tree, /* set_name */
440 0, /* start_end_main_source_file */
441 TYPE_SYMTAB_IS_ADDRESS /* tree_type_symtab_field */
443 #endif /* XCOFF_DEBUGGING_INFO */
445 /* Numeric formatting helper macro. Note that this does not handle
446 hexadecimal. */
447 #define NUMBER_FMT_LOOP(P, NUM, BASE) \
448 do \
450 int digit = NUM % BASE; \
451 NUM /= BASE; \
452 *--P = digit + '0'; \
454 while (NUM > 0)
456 /* Utility: write a decimal integer NUM to asm_out_file. */
457 void
458 dbxout_int (int num)
460 char buf[64];
461 char *p = buf + sizeof buf;
462 unsigned int unum;
464 if (num == 0)
466 putc ('0', asm_out_file);
467 return;
469 if (num < 0)
471 putc ('-', asm_out_file);
472 unum = -num;
474 else
475 unum = num;
477 NUMBER_FMT_LOOP (p, unum, 10);
479 while (p < buf + sizeof buf)
481 putc (*p, asm_out_file);
482 p++;
487 /* Primitives for emitting simple stabs directives. All other stabs
488 routines should use these functions instead of directly emitting
489 stabs. They are exported because machine-dependent code may need
490 to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
491 forwards to code in CPU.c. */
493 /* The following functions should all be called immediately after one
494 of the dbxout_begin_stab* functions (below). They write out
495 various things as the value of a stab. */
497 /* Write out a literal zero as the value of a stab. */
498 void
499 dbxout_stab_value_zero (void)
501 fputs ("0\n", asm_out_file);
504 /* Write out the label LABEL as the value of a stab. */
505 void
506 dbxout_stab_value_label (const char *label)
508 assemble_name (asm_out_file, label);
509 putc ('\n', asm_out_file);
512 /* Write out the difference of two labels, LABEL - BASE, as the value
513 of a stab. */
514 void
515 dbxout_stab_value_label_diff (const char *label, const char *base)
517 assemble_name (asm_out_file, label);
518 putc ('-', asm_out_file);
519 assemble_name (asm_out_file, base);
520 putc ('\n', asm_out_file);
523 /* Write out an internal label as the value of a stab, and immediately
524 emit that internal label. This should be used only when
525 dbxout_stabd will not work. STEM is the name stem of the label,
526 COUNTERP is a pointer to a counter variable which will be used to
527 guarantee label uniqueness. */
528 void
529 dbxout_stab_value_internal_label (const char *stem, int *counterp)
531 char label[100];
532 int counter = counterp ? (*counterp)++ : 0;
534 ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
535 dbxout_stab_value_label (label);
536 targetm.asm_out.internal_label (asm_out_file, stem, counter);
539 /* Write out the difference between BASE and an internal label as the
540 value of a stab, and immediately emit that internal label. STEM and
541 COUNTERP are as for dbxout_stab_value_internal_label. */
542 void
543 dbxout_stab_value_internal_label_diff (const char *stem, int *counterp,
544 const char *base)
546 char label[100];
547 int counter = counterp ? (*counterp)++ : 0;
549 ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
550 dbxout_stab_value_label_diff (label, base);
551 targetm.asm_out.internal_label (asm_out_file, stem, counter);
554 /* The following functions produce specific kinds of stab directives. */
556 /* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file. */
557 void
558 dbxout_stabd (int stype, int sdesc)
560 fputs (ASM_STABD_OP, asm_out_file);
561 dbxout_int (stype);
562 fputs (",0,", asm_out_file);
563 dbxout_int (sdesc);
564 putc ('\n', asm_out_file);
567 /* Write a .stabn directive with type STYPE. This function stops
568 short of emitting the value field, which is the responsibility of
569 the caller (normally it will be either a symbol or the difference
570 of two symbols). */
572 void
573 dbxout_begin_stabn (int stype)
575 fputs (ASM_STABN_OP, asm_out_file);
576 dbxout_int (stype);
577 fputs (",0,0,", asm_out_file);
580 /* Write a .stabn directive with type N_SLINE and desc LINE. As above,
581 the value field is the responsibility of the caller. */
582 void
583 dbxout_begin_stabn_sline (int lineno)
585 fputs (ASM_STABN_OP, asm_out_file);
586 dbxout_int (N_SLINE);
587 fputs (",0,", asm_out_file);
588 dbxout_int (lineno);
589 putc (',', asm_out_file);
592 /* Begin a .stabs directive with string "", type STYPE, and desc and
593 other fields 0. The value field is the responsibility of the
594 caller. This function cannot be used for .stabx directives. */
595 void
596 dbxout_begin_empty_stabs (int stype)
598 fputs (ASM_STABS_OP, asm_out_file);
599 fputs ("\"\",", asm_out_file);
600 dbxout_int (stype);
601 fputs (",0,0,", asm_out_file);
604 /* Begin a .stabs directive with string STR, type STYPE, and desc 0.
605 The value field is the responsibility of the caller. */
606 void
607 dbxout_begin_simple_stabs (const char *str, int stype)
609 fputs (ASM_STABS_OP, asm_out_file);
610 output_quoted_string (asm_out_file, str);
611 putc (',', asm_out_file);
612 dbxout_int (stype);
613 fputs (",0,0,", asm_out_file);
616 /* As above but use SDESC for the desc field. */
617 void
618 dbxout_begin_simple_stabs_desc (const char *str, int stype, int sdesc)
620 fputs (ASM_STABS_OP, asm_out_file);
621 output_quoted_string (asm_out_file, str);
622 putc (',', asm_out_file);
623 dbxout_int (stype);
624 fputs (",0,", asm_out_file);
625 dbxout_int (sdesc);
626 putc (',', asm_out_file);
629 /* The next set of functions are entirely concerned with production of
630 "complex" .stabs directives: that is, .stabs directives whose
631 strings have to be constructed piecemeal. dbxout_type,
632 dbxout_symbol, etc. use these routines heavily. The string is queued
633 up in an obstack, then written out by dbxout_finish_complex_stabs, which
634 is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
635 (You might think it would be more efficient to go straight to stdio
636 when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
637 out not to be the case, and anyway this needs fewer #ifdefs.) */
639 /* Begin a complex .stabs directive. If we can, write the initial
640 ASM_STABS_OP to the asm_out_file. */
642 static void
643 dbxout_begin_complex_stabs (void)
645 emit_pending_bincls_if_required ();
646 FORCE_TEXT;
647 fputs (ASM_STABS_OP, asm_out_file);
648 putc ('"', asm_out_file);
649 gcc_assert (stabstr_last_contin_point == 0);
652 /* As above, but do not force text or emit pending bincls. This is
653 used by dbxout_symbol_location, which needs to do something else. */
654 static void
655 dbxout_begin_complex_stabs_noforcetext (void)
657 fputs (ASM_STABS_OP, asm_out_file);
658 putc ('"', asm_out_file);
659 gcc_assert (stabstr_last_contin_point == 0);
662 /* Add CHR, a single character, to the string being built. */
663 #define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
665 /* Add STR, a normal C string, to the string being built. */
666 #define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen (str))
668 /* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */
669 #define stabstr_I(id) obstack_grow (&stabstr_ob, \
670 IDENTIFIER_POINTER (id), \
671 IDENTIFIER_LENGTH (id))
673 /* Add NUM, a signed decimal number, to the string being built. */
674 static void
675 stabstr_D (HOST_WIDE_INT num)
677 char buf[64];
678 char *p = buf + sizeof buf;
679 unsigned int unum;
681 if (num == 0)
683 stabstr_C ('0');
684 return;
686 if (num < 0)
688 stabstr_C ('-');
689 unum = -num;
691 else
692 unum = num;
694 NUMBER_FMT_LOOP (p, unum, 10);
696 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
699 /* Add NUM, an unsigned decimal number, to the string being built. */
700 static void
701 stabstr_U (unsigned HOST_WIDE_INT num)
703 char buf[64];
704 char *p = buf + sizeof buf;
705 if (num == 0)
707 stabstr_C ('0');
708 return;
710 NUMBER_FMT_LOOP (p, num, 10);
711 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
714 /* Add CST, an INTEGER_CST tree, to the string being built as an
715 unsigned octal number. This routine handles values which are
716 larger than a single HOST_WIDE_INT. */
717 static void
718 stabstr_O (tree cst)
720 int prec = TYPE_PRECISION (TREE_TYPE (cst));
721 int res_pres = prec % 3;
722 int i;
723 unsigned int digit;
725 /* Leading zero for base indicator. */
726 stabstr_C ('0');
728 /* If the value is zero, the base indicator will serve as the value
729 all by itself. */
730 if (wi::eq_p (cst, 0))
731 return;
733 /* GDB wants constants with no extra leading "1" bits, so
734 we need to remove any sign-extension that might be
735 present. */
736 if (res_pres == 1)
738 digit = wi::extract_uhwi (cst, prec - 1, 1);
739 stabstr_C ('0' + digit);
741 else if (res_pres == 2)
743 digit = wi::extract_uhwi (cst, prec - 2, 2);
744 stabstr_C ('0' + digit);
747 prec -= res_pres;
748 for (i = prec - 3; i >= 0; i = i - 3)
750 digit = wi::extract_uhwi (cst, i, 3);
751 stabstr_C ('0' + digit);
755 /* Called whenever it is safe to break a stabs string into multiple
756 .stabs directives. If the current string has exceeded the limit
757 set by DBX_CONTIN_LENGTH, mark the current position in the buffer
758 as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
759 it is a backslash) and a null character. */
760 static inline void
761 stabstr_continue (void)
763 if (DBX_CONTIN_LENGTH > 0
764 && obstack_object_size (&stabstr_ob) - stabstr_last_contin_point
765 > DBX_CONTIN_LENGTH)
767 if (DBX_CONTIN_CHAR == '\\')
768 obstack_1grow (&stabstr_ob, '\\');
769 obstack_1grow (&stabstr_ob, DBX_CONTIN_CHAR);
770 obstack_1grow (&stabstr_ob, '\0');
771 stabstr_last_contin_point = obstack_object_size (&stabstr_ob);
774 #define CONTIN stabstr_continue ()
776 /* Macro subroutine of dbxout_finish_complex_stabs, which emits
777 all of the arguments to the .stabs directive after the string.
778 Overridden by xcoffout.h. CODE is the stabs code for this symbol;
779 LINE is the source line to write into the desc field (in extended
780 mode); SYM is the symbol itself.
782 ADDR, LABEL, and NUMBER are three different ways to represent the
783 stabs value field. At most one of these should be nonzero.
785 ADDR is used most of the time; it represents the value as an
786 RTL address constant.
788 LABEL is used (currently) only for N_CATCH stabs; it represents
789 the value as a string suitable for assemble_name.
791 NUMBER is used when the value is an offset from an implicit base
792 pointer (e.g. for a stack variable), or an index (e.g. for a
793 register variable). It represents the value as a decimal integer. */
795 #ifndef DBX_FINISH_STABS
796 #define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER) \
797 do { \
798 int line_ = use_gnu_debug_info_extensions ? LINE : 0; \
800 dbxout_int (CODE); \
801 fputs (",0,", asm_out_file); \
802 dbxout_int (line_); \
803 putc (',', asm_out_file); \
804 if (ADDR) \
805 output_addr_const (asm_out_file, ADDR); \
806 else if (LABEL) \
807 assemble_name (asm_out_file, LABEL); \
808 else \
809 dbxout_int (NUMBER); \
810 putc ('\n', asm_out_file); \
811 } while (0)
812 #endif
814 /* Finish the emission of a complex .stabs directive. When DBX_CONTIN_LENGTH
815 is zero, this has only to emit the close quote and the remainder of
816 the arguments. When it is nonzero, the string has been marshalled in
817 stabstr_ob, and this routine is responsible for breaking it up into
818 DBX_CONTIN_LENGTH-sized chunks.
820 SYM is the DECL of the symbol under consideration; it is used only
821 for its DECL_SOURCE_LINE. The other arguments are all passed directly
822 to DBX_FINISH_STABS; see above for details. */
824 static void
825 dbxout_finish_complex_stabs (tree sym, stab_code_type code,
826 rtx addr, const char *label, int number)
828 int line ATTRIBUTE_UNUSED;
829 char *str;
830 size_t len;
832 line = sym ? DECL_SOURCE_LINE (sym) : 0;
833 if (DBX_CONTIN_LENGTH > 0)
835 char *chunk;
836 size_t chunklen;
838 /* Nul-terminate the growing string, then get its size and
839 address. */
840 obstack_1grow (&stabstr_ob, '\0');
842 len = obstack_object_size (&stabstr_ob);
843 chunk = str = XOBFINISH (&stabstr_ob, char *);
845 /* Within the buffer are a sequence of NUL-separated strings,
846 each of which is to be written out as a separate stab
847 directive. */
848 for (;;)
850 chunklen = strlen (chunk);
851 fwrite (chunk, 1, chunklen, asm_out_file);
852 fputs ("\",", asm_out_file);
854 /* Must add an extra byte to account for the NUL separator. */
855 chunk += chunklen + 1;
856 len -= chunklen + 1;
858 /* Only put a line number on the last stab in the sequence. */
859 DBX_FINISH_STABS (sym, code, len == 0 ? line : 0,
860 addr, label, number);
861 if (len == 0)
862 break;
864 fputs (ASM_STABS_OP, asm_out_file);
865 putc ('"', asm_out_file);
867 stabstr_last_contin_point = 0;
869 else
871 /* No continuations - we can put the whole string out at once.
872 It is faster to augment the string with the close quote and
873 comma than to do a two-character fputs. */
874 obstack_grow (&stabstr_ob, "\",", 2);
875 len = obstack_object_size (&stabstr_ob);
876 str = XOBFINISH (&stabstr_ob, char *);
878 fwrite (str, 1, len, asm_out_file);
879 DBX_FINISH_STABS (sym, code, line, addr, label, number);
881 obstack_free (&stabstr_ob, str);
884 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
886 /* When -gused is used, emit debug info for only used symbols. But in
887 addition to the standard intercepted debug_hooks there are some
888 direct calls into this file, i.e., dbxout_symbol, dbxout_parms, and
889 dbxout_reg_params. Those routines may also be called from a higher
890 level intercepted routine. So to prevent recording data for an inner
891 call to one of these for an intercept, we maintain an intercept
892 nesting counter (debug_nesting). We only save the intercepted
893 arguments if the nesting is 1. */
894 static int debug_nesting = 0;
896 static tree *symbol_queue;
897 static int symbol_queue_index = 0;
898 static int symbol_queue_size = 0;
900 #define DBXOUT_DECR_NESTING \
901 if (--debug_nesting == 0 && symbol_queue_index > 0) \
902 { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
904 #define DBXOUT_DECR_NESTING_AND_RETURN(x) \
905 do {--debug_nesting; return (x);} while (0)
907 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
909 #if defined (DBX_DEBUGGING_INFO)
911 static void
912 dbxout_function_end (tree decl ATTRIBUTE_UNUSED)
914 char lscope_label_name[100];
916 /* The Lscope label must be emitted even if we aren't doing anything
917 else; dbxout_block needs it. */
918 switch_to_section (function_section (current_function_decl));
920 /* Convert Lscope into the appropriate format for local labels in case
921 the system doesn't insert underscores in front of user generated
922 labels. */
923 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
924 targetm.asm_out.internal_label (asm_out_file, "Lscope", scope_labelno);
926 /* The N_FUN tag at the end of the function is a GNU extension,
927 which may be undesirable, and is unnecessary if we do not have
928 named sections. */
929 if (!use_gnu_debug_info_extensions
930 || NO_DBX_FUNCTION_END
931 || !targetm_common.have_named_sections)
932 return;
934 /* By convention, GCC will mark the end of a function with an N_FUN
935 symbol and an empty string. */
936 if (flag_reorder_blocks_and_partition)
938 dbxout_begin_empty_stabs (N_FUN);
939 dbxout_stab_value_label_diff (crtl->subsections.hot_section_end_label,
940 crtl->subsections.hot_section_label);
941 dbxout_begin_empty_stabs (N_FUN);
942 dbxout_stab_value_label_diff (crtl->subsections.cold_section_end_label,
943 crtl->subsections.cold_section_label);
945 else
947 char begin_label[20];
948 /* Reference current function start using LFBB. */
949 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
950 dbxout_begin_empty_stabs (N_FUN);
951 dbxout_stab_value_label_diff (lscope_label_name, begin_label);
954 if (!NO_DBX_BNSYM_ENSYM && !flag_debug_only_used_symbols)
955 dbxout_stabd (N_ENSYM, 0);
957 #endif /* DBX_DEBUGGING_INFO */
959 /* Get lang description for N_SO stab. */
960 static unsigned int ATTRIBUTE_UNUSED
961 get_lang_number (void)
963 const char *language_string = lang_hooks.name;
964 if (lang_GNU_C ())
965 return N_SO_C;
966 else if (lang_GNU_CXX ())
967 return N_SO_CC;
968 else if (strcmp (language_string, "GNU F77") == 0)
969 return N_SO_FORTRAN;
970 else if (lang_GNU_Fortran ())
971 return N_SO_FORTRAN90; /* CHECKME */
972 else if (strcmp (language_string, "GNU Pascal") == 0)
973 return N_SO_PASCAL;
974 else if (strcmp (language_string, "GNU Objective-C") == 0)
975 return N_SO_OBJC;
976 else if (strcmp (language_string, "GNU Objective-C++") == 0)
977 return N_SO_OBJCPLUS;
978 else
979 return 0;
983 static bool
984 is_fortran (void)
986 unsigned int lang = get_lang_number ();
988 return (lang == N_SO_FORTRAN) || (lang == N_SO_FORTRAN90);
991 /* At the beginning of compilation, start writing the symbol table.
992 Initialize `typevec' and output the standard data types of C. */
994 static void
995 dbxout_init (const char *input_file_name)
997 char ltext_label_name[100];
998 bool used_ltext_label_name = false;
999 tree syms = lang_hooks.decls.getdecls ();
1000 const char *mapped_name;
1002 typevec_len = 100;
1003 typevec = ggc_cleared_vec_alloc<typeinfo> (typevec_len);
1005 /* stabstr_ob contains one string, which will be just fine with
1006 1-byte alignment. */
1007 obstack_specify_allocation (&stabstr_ob, 0, 1, xmalloc, free);
1009 /* Convert Ltext into the appropriate format for local labels in case
1010 the system doesn't insert underscores in front of user generated
1011 labels. */
1012 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
1014 /* Put the current working directory in an N_SO symbol. */
1015 if (use_gnu_debug_info_extensions && !NO_DBX_MAIN_SOURCE_DIRECTORY)
1017 static const char *cwd;
1019 if (!cwd)
1021 cwd = get_src_pwd ();
1022 if (cwd[0] == '\0')
1023 cwd = "/";
1024 else if (!IS_DIR_SEPARATOR (cwd[strlen (cwd) - 1]))
1025 cwd = concat (cwd, "/", NULL);
1026 cwd = remap_debug_filename (cwd);
1028 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
1029 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file, cwd);
1030 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1031 dbxout_begin_simple_stabs_desc (cwd, N_SO, get_lang_number ());
1032 dbxout_stab_value_label (ltext_label_name);
1033 used_ltext_label_name = true;
1034 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1037 mapped_name = remap_debug_filename (input_file_name);
1038 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
1039 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file, mapped_name);
1040 #else
1041 dbxout_begin_simple_stabs_desc (mapped_name, N_SO, get_lang_number ());
1042 dbxout_stab_value_label (ltext_label_name);
1043 used_ltext_label_name = true;
1044 #endif
1046 if (used_ltext_label_name)
1048 switch_to_section (text_section);
1049 targetm.asm_out.internal_label (asm_out_file, "Ltext", 0);
1052 /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
1053 The string used is historical. */
1054 #ifndef NO_DBX_GCC_MARKER
1055 dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT);
1056 dbxout_stab_value_zero ();
1057 #endif
1059 base_input_file = lastfile = input_file_name;
1061 next_type_number = 1;
1063 #ifdef DBX_USE_BINCL
1064 current_file = XNEW (struct dbx_file);
1065 current_file->next = NULL;
1066 current_file->file_number = 0;
1067 current_file->next_type_number = 1;
1068 next_file_number = 1;
1069 current_file->prev = NULL;
1070 current_file->bincl_status = BINCL_NOT_REQUIRED;
1071 current_file->pending_bincl_name = NULL;
1072 #endif
1074 /* Get all permanent types that have typedef names, and output them
1075 all, except for those already output. Some language front ends
1076 put these declarations in the top-level scope; some do not;
1077 the latter are responsible for calling debug_hooks->type_decl from
1078 their record_builtin_type function. */
1079 dbxout_typedefs (syms);
1081 if (preinit_symbols)
1083 tree t;
1084 for (t = nreverse (preinit_symbols); t; t = TREE_CHAIN (t))
1085 dbxout_symbol (TREE_VALUE (t), 0);
1086 preinit_symbols = 0;
1090 /* Output any typedef names for types described by TYPE_DECLs in SYMS. */
1092 static void
1093 dbxout_typedefs (tree syms)
1095 for (; syms != NULL_TREE; syms = DECL_CHAIN (syms))
1097 if (TREE_CODE (syms) == TYPE_DECL)
1099 tree type = TREE_TYPE (syms);
1100 if (TYPE_NAME (type)
1101 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1102 && COMPLETE_OR_VOID_TYPE_P (type)
1103 && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
1104 dbxout_symbol (TYPE_NAME (type), 0);
1109 #ifdef DBX_USE_BINCL
1110 /* Emit BINCL stab using given name. */
1111 static void
1112 emit_bincl_stab (const char *name)
1114 dbxout_begin_simple_stabs (name, N_BINCL);
1115 dbxout_stab_value_zero ();
1118 /* If there are pending bincls then it is time to emit all of them. */
1120 static inline void
1121 emit_pending_bincls_if_required (void)
1123 if (pending_bincls)
1124 emit_pending_bincls ();
1127 /* Emit all pending bincls. */
1129 static void
1130 emit_pending_bincls (void)
1132 struct dbx_file *f = current_file;
1134 /* Find first pending bincl. */
1135 while (f->bincl_status == BINCL_PENDING)
1136 f = f->next;
1138 /* Now emit all bincls. */
1139 f = f->prev;
1141 while (f)
1143 if (f->bincl_status == BINCL_PENDING)
1145 emit_bincl_stab (f->pending_bincl_name);
1147 /* Update file number and status. */
1148 f->file_number = next_file_number++;
1149 f->bincl_status = BINCL_PROCESSED;
1151 if (f == current_file)
1152 break;
1153 f = f->prev;
1156 /* All pending bincls have been emitted. */
1157 pending_bincls = 0;
1160 #else
1162 static inline void
1163 emit_pending_bincls_if_required (void) {}
1164 #endif
1166 /* Change to reading from a new source file. Generate a N_BINCL stab. */
1168 static void
1169 dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED,
1170 const char *filename ATTRIBUTE_UNUSED)
1172 #ifdef DBX_USE_BINCL
1173 struct dbx_file *n = XNEW (struct dbx_file);
1175 n->next = current_file;
1176 n->next_type_number = 1;
1177 /* Do not assign file number now.
1178 Delay it until we actually emit BINCL. */
1179 n->file_number = 0;
1180 n->prev = NULL;
1181 current_file->prev = n;
1182 n->bincl_status = BINCL_PENDING;
1183 n->pending_bincl_name = remap_debug_filename (filename);
1184 pending_bincls = 1;
1185 current_file = n;
1186 #endif
1189 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
1191 static void
1192 dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED)
1194 #ifdef DBX_USE_BINCL
1195 /* Emit EINCL stab only if BINCL is not pending. */
1196 if (current_file->bincl_status == BINCL_PROCESSED)
1198 dbxout_begin_stabn (N_EINCL);
1199 dbxout_stab_value_zero ();
1201 current_file->bincl_status = BINCL_NOT_REQUIRED;
1202 current_file = current_file->next;
1203 #endif
1206 /* Handle a few odd cases that occur when trying to make PCH files work. */
1208 static void
1209 dbxout_handle_pch (unsigned at_end)
1211 if (! at_end)
1213 /* When using the PCH, this file will be included, so we need to output
1214 a BINCL. */
1215 dbxout_start_source_file (0, lastfile);
1217 /* The base file when using the PCH won't be the same as
1218 the base file when it's being generated. */
1219 lastfile = NULL;
1221 else
1223 /* ... and an EINCL. */
1224 dbxout_end_source_file (0);
1226 /* Deal with cases where 'lastfile' was never actually changed. */
1227 lastfile_is_base = lastfile == NULL;
1231 #if defined (DBX_DEBUGGING_INFO)
1233 static void dbxout_block (tree, int, tree);
1235 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
1237 static void
1238 dbxout_source_file (const char *filename)
1240 if (lastfile == 0 && lastfile_is_base)
1242 lastfile = base_input_file;
1243 lastfile_is_base = 0;
1246 if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
1248 /* Don't change section amid function. */
1249 if (current_function_decl == NULL_TREE)
1250 switch_to_section (text_section);
1252 dbxout_begin_simple_stabs (remap_debug_filename (filename), N_SOL);
1253 dbxout_stab_value_internal_label ("Ltext", &source_label_number);
1254 lastfile = filename;
1258 /* Output N_BNSYM, line number symbol entry, and local symbol at
1259 function scope */
1261 static void
1262 dbxout_begin_prologue (unsigned int lineno, const char *filename)
1264 if (use_gnu_debug_info_extensions
1265 && !NO_DBX_FUNCTION_END
1266 && !NO_DBX_BNSYM_ENSYM
1267 && !flag_debug_only_used_symbols)
1268 dbxout_stabd (N_BNSYM, 0);
1270 /* pre-increment the scope counter */
1271 scope_labelno++;
1273 dbxout_source_line (lineno, filename, 0, true);
1274 /* Output function begin block at function scope, referenced
1275 by dbxout_block, dbxout_source_line and dbxout_function_end. */
1276 emit_pending_bincls_if_required ();
1277 targetm.asm_out.internal_label (asm_out_file, "LFBB", scope_labelno);
1280 /* Output a line number symbol entry for source file FILENAME and line
1281 number LINENO. */
1283 static void
1284 dbxout_source_line (unsigned int lineno, const char *filename,
1285 int discriminator ATTRIBUTE_UNUSED,
1286 bool is_stmt ATTRIBUTE_UNUSED)
1288 dbxout_source_file (filename);
1290 #ifdef DBX_OUTPUT_SOURCE_LINE
1291 DBX_OUTPUT_SOURCE_LINE (asm_out_file, lineno, dbxout_source_line_counter);
1292 #else
1293 if (DBX_LINES_FUNCTION_RELATIVE)
1295 char begin_label[20];
1296 dbxout_begin_stabn_sline (lineno);
1297 /* Reference current function start using LFBB. */
1298 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
1299 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter,
1300 begin_label);
1302 else
1303 dbxout_stabd (N_SLINE, lineno);
1304 #endif
1307 /* Describe the beginning of an internal block within a function. */
1309 static void
1310 dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
1312 emit_pending_bincls_if_required ();
1313 targetm.asm_out.internal_label (asm_out_file, "LBB", n);
1316 /* Describe the end line-number of an internal block within a function. */
1318 static void
1319 dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
1321 emit_pending_bincls_if_required ();
1322 targetm.asm_out.internal_label (asm_out_file, "LBE", n);
1325 /* Output dbx data for a function definition.
1326 This includes a definition of the function name itself (a symbol),
1327 definitions of the parameters (locating them in the parameter list)
1328 and then output the block that makes up the function's body
1329 (including all the auto variables of the function). */
1331 static void
1332 dbxout_function_decl (tree decl)
1334 emit_pending_bincls_if_required ();
1335 #ifndef DBX_FUNCTION_FIRST
1336 dbxout_begin_function (decl);
1337 #endif
1338 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
1339 dbxout_function_end (decl);
1342 #endif /* DBX_DEBUGGING_INFO */
1344 /* Debug information for a global DECL. Called from toplev.c after
1345 compilation proper has finished. */
1346 static void
1347 dbxout_global_decl (tree decl)
1349 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
1351 int saved_tree_used = TREE_USED (decl);
1352 TREE_USED (decl) = 1;
1353 dbxout_symbol (decl, 0);
1354 TREE_USED (decl) = saved_tree_used;
1358 /* This is just a function-type adapter; dbxout_symbol does exactly
1359 what we want but returns an int. */
1360 static void
1361 dbxout_type_decl (tree decl, int local)
1363 dbxout_symbol (decl, local);
1366 /* At the end of compilation, finish writing the symbol table.
1367 The default is to call debug_free_queue but do nothing else. */
1369 static void
1370 dbxout_finish (const char *filename ATTRIBUTE_UNUSED)
1372 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1373 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file, filename);
1374 #elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
1376 switch_to_section (text_section);
1377 dbxout_begin_empty_stabs (N_SO);
1378 dbxout_stab_value_internal_label ("Letext", 0);
1380 #endif
1381 debug_free_queue ();
1384 /* Output the index of a type. */
1386 static void
1387 dbxout_type_index (tree type)
1389 #ifndef DBX_USE_BINCL
1390 stabstr_D (TYPE_SYMTAB_ADDRESS (type));
1391 #else
1392 struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
1393 stabstr_C ('(');
1394 stabstr_D (t->file_number);
1395 stabstr_C (',');
1396 stabstr_D (t->type_number);
1397 stabstr_C (')');
1398 #endif
1402 /* Generate the symbols for any queued up type symbols we encountered
1403 while generating the type info for some originally used symbol.
1404 This might generate additional entries in the queue. Only when
1405 the nesting depth goes to 0 is this routine called. */
1407 static void
1408 debug_flush_symbol_queue (void)
1410 int i;
1412 /* Make sure that additionally queued items are not flushed
1413 prematurely. */
1415 ++debug_nesting;
1417 for (i = 0; i < symbol_queue_index; ++i)
1419 /* If we pushed queued symbols then such symbols must be
1420 output no matter what anyone else says. Specifically,
1421 we need to make sure dbxout_symbol() thinks the symbol was
1422 used and also we need to override TYPE_DECL_SUPPRESS_DEBUG
1423 which may be set for outside reasons. */
1424 int saved_tree_used = TREE_USED (symbol_queue[i]);
1425 int saved_suppress_debug = TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]);
1426 TREE_USED (symbol_queue[i]) = 1;
1427 TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]) = 0;
1429 #ifdef DBX_DEBUGGING_INFO
1430 dbxout_symbol (symbol_queue[i], 0);
1431 #endif
1433 TREE_USED (symbol_queue[i]) = saved_tree_used;
1434 TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]) = saved_suppress_debug;
1437 symbol_queue_index = 0;
1438 --debug_nesting;
1441 /* Queue a type symbol needed as part of the definition of a decl
1442 symbol. These symbols are generated when debug_flush_symbol_queue()
1443 is called. */
1445 static void
1446 debug_queue_symbol (tree decl)
1448 if (symbol_queue_index >= symbol_queue_size)
1450 symbol_queue_size += 10;
1451 symbol_queue = XRESIZEVEC (tree, symbol_queue, symbol_queue_size);
1454 symbol_queue[symbol_queue_index++] = decl;
1457 /* Free symbol queue. */
1458 static void
1459 debug_free_queue (void)
1461 if (symbol_queue)
1463 free (symbol_queue);
1464 symbol_queue = NULL;
1465 symbol_queue_size = 0;
1469 /* Used in several places: evaluates to '0' for a private decl,
1470 '1' for a protected decl, '2' for a public decl. */
1471 #define DECL_ACCESSIBILITY_CHAR(DECL) \
1472 (TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
1474 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
1475 This must be a separate function because anonymous unions require
1476 recursive calls. */
1478 static void
1479 dbxout_type_fields (tree type)
1481 tree tem;
1483 /* Output the name, type, position (in bits), size (in bits) of each
1484 field that we can support. */
1485 for (tem = TYPE_FIELDS (type); tem; tem = DECL_CHAIN (tem))
1487 /* If one of the nodes is an error_mark or its type is then
1488 return early. */
1489 if (error_operand_p (tem))
1490 return;
1492 /* Omit here local type decls until we know how to support them. */
1493 if (TREE_CODE (tem) == TYPE_DECL
1494 /* Omit here the nameless fields that are used to skip bits. */
1495 || DECL_IGNORED_P (tem)
1496 /* Omit fields whose position or size are variable or too large to
1497 represent. */
1498 || (TREE_CODE (tem) == FIELD_DECL
1499 && (! tree_fits_shwi_p (bit_position (tem))
1500 || ! DECL_SIZE (tem)
1501 || ! tree_fits_uhwi_p (DECL_SIZE (tem)))))
1502 continue;
1504 else if (TREE_CODE (tem) != CONST_DECL)
1506 /* Continue the line if necessary,
1507 but not before the first field. */
1508 if (tem != TYPE_FIELDS (type))
1509 CONTIN;
1511 if (DECL_NAME (tem))
1512 stabstr_I (DECL_NAME (tem));
1513 stabstr_C (':');
1515 if (use_gnu_debug_info_extensions
1516 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
1517 || TREE_CODE (tem) != FIELD_DECL))
1519 stabstr_C ('/');
1520 stabstr_C (DECL_ACCESSIBILITY_CHAR (tem));
1523 dbxout_type ((TREE_CODE (tem) == FIELD_DECL
1524 && DECL_BIT_FIELD_TYPE (tem))
1525 ? DECL_BIT_FIELD_TYPE (tem) : TREE_TYPE (tem), 0);
1527 if (TREE_CODE (tem) == VAR_DECL)
1529 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
1531 tree name = DECL_ASSEMBLER_NAME (tem);
1533 stabstr_C (':');
1534 stabstr_I (name);
1535 stabstr_C (';');
1537 else
1538 /* If TEM is non-static, GDB won't understand it. */
1539 stabstr_S (",0,0;");
1541 else
1543 stabstr_C (',');
1544 stabstr_D (int_bit_position (tem));
1545 stabstr_C (',');
1546 stabstr_D (tree_to_uhwi (DECL_SIZE (tem)));
1547 stabstr_C (';');
1553 /* Subroutine of `dbxout_type_methods'. Output debug info about the
1554 method described DECL. */
1556 static void
1557 dbxout_type_method_1 (tree decl)
1559 char c1 = 'A', c2;
1561 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
1562 c2 = '?';
1563 else /* it's a METHOD_TYPE. */
1565 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
1566 /* A for normal functions.
1567 B for `const' member functions.
1568 C for `volatile' member functions.
1569 D for `const volatile' member functions. */
1570 if (TYPE_READONLY (TREE_TYPE (firstarg)))
1571 c1 += 1;
1572 if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
1573 c1 += 2;
1575 if (DECL_VINDEX (decl))
1576 c2 = '*';
1577 else
1578 c2 = '.';
1581 /* ??? Output the mangled name, which contains an encoding of the
1582 method's type signature. May not be necessary anymore. */
1583 stabstr_C (':');
1584 stabstr_I (DECL_ASSEMBLER_NAME (decl));
1585 stabstr_C (';');
1586 stabstr_C (DECL_ACCESSIBILITY_CHAR (decl));
1587 stabstr_C (c1);
1588 stabstr_C (c2);
1590 if (DECL_VINDEX (decl) && tree_fits_shwi_p (DECL_VINDEX (decl)))
1592 stabstr_D (tree_to_shwi (DECL_VINDEX (decl)));
1593 stabstr_C (';');
1594 dbxout_type (DECL_CONTEXT (decl), 0);
1595 stabstr_C (';');
1599 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
1600 in TYPE. */
1602 static void
1603 dbxout_type_methods (tree type)
1605 /* C++: put out the method names and their parameter lists */
1606 tree methods = TYPE_METHODS (type);
1607 tree fndecl;
1608 tree last;
1610 if (methods == NULL_TREE)
1611 return;
1613 if (TREE_CODE (methods) != TREE_VEC)
1614 fndecl = methods;
1615 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
1616 fndecl = TREE_VEC_ELT (methods, 0);
1617 else
1618 fndecl = TREE_VEC_ELT (methods, 1);
1620 while (fndecl)
1622 int need_prefix = 1;
1624 /* Group together all the methods for the same operation.
1625 These differ in the types of the arguments. */
1626 for (last = NULL_TREE;
1627 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
1628 fndecl = DECL_CHAIN (fndecl))
1629 /* Output the name of the field (after overloading), as
1630 well as the name of the field before overloading, along
1631 with its parameter list */
1633 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
1634 include TEMPLATE_DECLs.) The debugger doesn't know what
1635 to do with such entities anyhow. */
1636 if (TREE_CODE (fndecl) != FUNCTION_DECL)
1637 continue;
1639 CONTIN;
1641 last = fndecl;
1643 /* Also ignore abstract methods; those are only interesting to
1644 the DWARF backends. */
1645 if (DECL_IGNORED_P (fndecl) || DECL_ABSTRACT_P (fndecl))
1646 continue;
1648 /* Redundantly output the plain name, since that's what gdb
1649 expects. */
1650 if (need_prefix)
1652 stabstr_I (DECL_NAME (fndecl));
1653 stabstr_S ("::");
1654 need_prefix = 0;
1657 dbxout_type (TREE_TYPE (fndecl), 0);
1658 dbxout_type_method_1 (fndecl);
1660 if (!need_prefix)
1661 stabstr_C (';');
1665 /* Emit a "range" type specification, which has the form:
1666 "r<index type>;<lower bound>;<upper bound>;".
1667 TYPE is an INTEGER_TYPE, LOW and HIGH are the bounds. */
1669 static void
1670 dbxout_range_type (tree type, tree low, tree high)
1672 stabstr_C ('r');
1673 if (TREE_TYPE (type))
1674 dbxout_type (TREE_TYPE (type), 0);
1675 else if (TREE_CODE (type) != INTEGER_TYPE)
1676 dbxout_type (type, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1677 else
1679 /* Traditionally, we made sure 'int' was type 1, and builtin types
1680 were defined to be sub-ranges of int. Unfortunately, this
1681 does not allow us to distinguish true sub-ranges from integer
1682 types. So, instead we define integer (non-sub-range) types as
1683 sub-ranges of themselves. This matters for Chill. If this isn't
1684 a subrange type, then we want to define it in terms of itself.
1685 However, in C, this may be an anonymous integer type, and we don't
1686 want to emit debug info referring to it. Just calling
1687 dbxout_type_index won't work anyways, because the type hasn't been
1688 defined yet. We make this work for both cases by checked to see
1689 whether this is a defined type, referring to it if it is, and using
1690 'int' otherwise. */
1691 if (TYPE_SYMTAB_ADDRESS (type) != 0)
1692 dbxout_type_index (type);
1693 else
1694 dbxout_type_index (integer_type_node);
1697 stabstr_C (';');
1698 if (low && tree_fits_shwi_p (low))
1700 if (print_int_cst_bounds_in_octal_p (type, low, high))
1701 stabstr_O (low);
1702 else
1703 stabstr_D (tree_to_shwi (low));
1705 else
1706 stabstr_C ('0');
1708 stabstr_C (';');
1709 if (high && tree_fits_shwi_p (high))
1711 if (print_int_cst_bounds_in_octal_p (type, low, high))
1712 stabstr_O (high);
1713 else
1714 stabstr_D (tree_to_shwi (high));
1715 stabstr_C (';');
1717 else
1718 stabstr_S ("-1;");
1722 /* Output a reference to a type. If the type has not yet been
1723 described in the dbx output, output its definition now.
1724 For a type already defined, just refer to its definition
1725 using the type number.
1727 If FULL is nonzero, and the type has been described only with
1728 a forward-reference, output the definition now.
1729 If FULL is zero in this case, just refer to the forward-reference
1730 using the number previously allocated. */
1732 static void
1733 dbxout_type (tree type, int full)
1735 static int anonymous_type_number = 0;
1736 tree tem, main_variant, low, high;
1738 if (TREE_CODE (type) == INTEGER_TYPE)
1740 if (TREE_TYPE (type) == 0)
1742 low = TYPE_MIN_VALUE (type);
1743 high = TYPE_MAX_VALUE (type);
1746 else if (subrange_type_for_debug_p (type, &low, &high))
1749 /* If this is a subtype that should not be emitted as a subrange type,
1750 use the base type. */
1751 else
1753 type = TREE_TYPE (type);
1754 low = TYPE_MIN_VALUE (type);
1755 high = TYPE_MAX_VALUE (type);
1759 /* If there was an input error and we don't really have a type,
1760 avoid crashing and write something that is at least valid
1761 by assuming `int'. */
1762 if (type == error_mark_node)
1763 type = integer_type_node;
1764 else
1766 if (TYPE_NAME (type)
1767 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1768 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
1769 full = 0;
1772 /* Try to find the "main variant" with the same name. */
1773 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1774 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1775 main_variant = TREE_TYPE (TYPE_NAME (type));
1776 else
1777 main_variant = TYPE_MAIN_VARIANT (type);
1779 /* If we are not using extensions, stabs does not distinguish const and
1780 volatile, so there is no need to make them separate types. */
1781 if (!use_gnu_debug_info_extensions)
1782 type = main_variant;
1784 if (TYPE_SYMTAB_ADDRESS (type) == 0)
1786 /* Type has no dbx number assigned. Assign next available number. */
1787 TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
1789 /* Make sure type vector is long enough to record about this type. */
1791 if (next_type_number == typevec_len)
1793 typevec = GGC_RESIZEVEC (struct typeinfo, typevec, typevec_len * 2);
1794 memset (typevec + typevec_len, 0, typevec_len * sizeof typevec[0]);
1795 typevec_len *= 2;
1798 #ifdef DBX_USE_BINCL
1799 emit_pending_bincls_if_required ();
1800 typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
1801 = current_file->file_number;
1802 typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
1803 = current_file->next_type_number++;
1804 #endif
1807 if (flag_debug_only_used_symbols)
1809 if ((TREE_CODE (type) == RECORD_TYPE
1810 || TREE_CODE (type) == UNION_TYPE
1811 || TREE_CODE (type) == QUAL_UNION_TYPE
1812 || TREE_CODE (type) == ENUMERAL_TYPE)
1813 && TYPE_STUB_DECL (type)
1814 && DECL_P (TYPE_STUB_DECL (type))
1815 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
1816 debug_queue_symbol (TYPE_STUB_DECL (type));
1817 else if (TYPE_NAME (type)
1818 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1819 debug_queue_symbol (TYPE_NAME (type));
1822 /* Output the number of this type, to refer to it. */
1823 dbxout_type_index (type);
1825 #ifdef DBX_TYPE_DEFINED
1826 if (DBX_TYPE_DEFINED (type))
1827 return;
1828 #endif
1830 /* If this type's definition has been output or is now being output,
1831 that is all. */
1833 switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
1835 case TYPE_UNSEEN:
1836 break;
1837 case TYPE_XREF:
1838 /* If we have already had a cross reference,
1839 and either that's all we want or that's the best we could do,
1840 don't repeat the cross reference.
1841 Sun dbx crashes if we do. */
1842 if (! full || !COMPLETE_TYPE_P (type)
1843 /* No way in DBX fmt to describe a variable size. */
1844 || ! tree_fits_uhwi_p (TYPE_SIZE (type)))
1845 return;
1846 break;
1847 case TYPE_DEFINED:
1848 return;
1851 #ifdef DBX_NO_XREFS
1852 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1853 leave the type-number completely undefined rather than output
1854 a cross-reference. If we have already used GNU debug info extensions,
1855 then it is OK to output a cross reference. This is necessary to get
1856 proper C++ debug output. */
1857 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
1858 || TREE_CODE (type) == QUAL_UNION_TYPE
1859 || TREE_CODE (type) == ENUMERAL_TYPE)
1860 && ! use_gnu_debug_info_extensions)
1861 /* We must use the same test here as we use twice below when deciding
1862 whether to emit a cross-reference. */
1863 if ((TYPE_NAME (type) != 0
1864 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1865 && DECL_IGNORED_P (TYPE_NAME (type)))
1866 && !full)
1867 || !COMPLETE_TYPE_P (type)
1868 /* No way in DBX fmt to describe a variable size. */
1869 || ! tree_fits_uhwi_p (TYPE_SIZE (type)))
1871 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1872 return;
1874 #endif
1876 /* Output a definition now. */
1877 stabstr_C ('=');
1879 /* Mark it as defined, so that if it is self-referent
1880 we will not get into an infinite recursion of definitions. */
1882 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
1884 /* If this type is a variant of some other, hand off. Types with
1885 different names are usefully distinguished. We only distinguish
1886 cv-qualified types if we're using extensions. */
1887 if (TYPE_READONLY (type) > TYPE_READONLY (main_variant))
1889 stabstr_C ('k');
1890 dbxout_type (build_type_variant (type, 0, TYPE_VOLATILE (type)), 0);
1891 return;
1893 else if (TYPE_VOLATILE (type) > TYPE_VOLATILE (main_variant))
1895 stabstr_C ('B');
1896 dbxout_type (build_type_variant (type, TYPE_READONLY (type), 0), 0);
1897 return;
1899 else if (main_variant != TYPE_MAIN_VARIANT (type))
1901 if (flag_debug_only_used_symbols)
1903 tree orig_type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
1905 if ((TREE_CODE (orig_type) == RECORD_TYPE
1906 || TREE_CODE (orig_type) == UNION_TYPE
1907 || TREE_CODE (orig_type) == QUAL_UNION_TYPE
1908 || TREE_CODE (orig_type) == ENUMERAL_TYPE)
1909 && TYPE_STUB_DECL (orig_type)
1910 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type)))
1911 debug_queue_symbol (TYPE_STUB_DECL (orig_type));
1913 /* 'type' is a typedef; output the type it refers to. */
1914 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0);
1915 return;
1917 /* else continue. */
1919 switch (TREE_CODE (type))
1921 case VOID_TYPE:
1922 case NULLPTR_TYPE:
1923 case LANG_TYPE:
1924 /* For a void type, just define it as itself; i.e., "5=5".
1925 This makes us consider it defined
1926 without saying what it is. The debugger will make it
1927 a void type when the reference is seen, and nothing will
1928 ever override that default. */
1929 dbxout_type_index (type);
1930 break;
1932 case INTEGER_TYPE:
1933 if (type == char_type_node && ! TYPE_UNSIGNED (type))
1935 /* Output the type `char' as a subrange of itself!
1936 I don't understand this definition, just copied it
1937 from the output of pcc.
1938 This used to use `r2' explicitly and we used to
1939 take care to make sure that `char' was type number 2. */
1940 stabstr_C ('r');
1941 dbxout_type_index (type);
1942 stabstr_S (";0;127;");
1945 /* If this is a subtype of another integer type, always prefer to
1946 write it as a subtype. */
1947 else if (TREE_TYPE (type) != 0
1948 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
1950 /* If the size is non-standard, say what it is if we can use
1951 GDB extensions. */
1953 if (use_gnu_debug_info_extensions
1954 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1956 stabstr_S ("@s");
1957 stabstr_D (TYPE_PRECISION (type));
1958 stabstr_C (';');
1961 dbxout_range_type (type, low, high);
1964 else
1966 /* If the size is non-standard, say what it is if we can use
1967 GDB extensions. */
1969 if (use_gnu_debug_info_extensions
1970 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1972 stabstr_S ("@s");
1973 stabstr_D (TYPE_PRECISION (type));
1974 stabstr_C (';');
1977 if (print_int_cst_bounds_in_octal_p (type, low, high))
1979 stabstr_C ('r');
1981 /* If this type derives from another type, output type index of
1982 parent type. This is particularly important when parent type
1983 is an enumerated type, because not generating the parent type
1984 index would transform the definition of this enumerated type
1985 into a plain unsigned type. */
1986 if (TREE_TYPE (type) != 0)
1987 dbxout_type_index (TREE_TYPE (type));
1988 else
1989 dbxout_type_index (type);
1991 stabstr_C (';');
1992 stabstr_O (low);
1993 stabstr_C (';');
1994 stabstr_O (high);
1995 stabstr_C (';');
1998 else
1999 /* Output other integer types as subranges of `int'. */
2000 dbxout_range_type (type, low, high);
2003 break;
2005 case REAL_TYPE:
2006 case FIXED_POINT_TYPE:
2007 /* This used to say `r1' and we used to take care
2008 to make sure that `int' was type number 1. */
2009 stabstr_C ('r');
2010 dbxout_type_index (integer_type_node);
2011 stabstr_C (';');
2012 stabstr_D (int_size_in_bytes (type));
2013 stabstr_S (";0;");
2014 break;
2016 case BOOLEAN_TYPE:
2017 if (use_gnu_debug_info_extensions)
2019 stabstr_S ("@s");
2020 stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
2021 stabstr_S (";-16;");
2023 else /* Define as enumeral type (False, True) */
2024 stabstr_S ("eFalse:0,True:1,;");
2025 break;
2027 case COMPLEX_TYPE:
2028 /* Differs from the REAL_TYPE by its new data type number.
2029 R3 is NF_COMPLEX. We don't try to use any of the other NF_*
2030 codes since gdb doesn't care anyway. */
2032 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
2034 stabstr_S ("R3;");
2035 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type)));
2036 stabstr_S (";0;");
2038 else
2040 /* Output a complex integer type as a structure,
2041 pending some other way to do it. */
2042 stabstr_C ('s');
2043 stabstr_D (int_size_in_bytes (type));
2045 stabstr_S ("real:");
2046 dbxout_type (TREE_TYPE (type), 0);
2047 stabstr_S (",0,");
2048 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
2050 stabstr_S (";imag:");
2051 dbxout_type (TREE_TYPE (type), 0);
2052 stabstr_C (',');
2053 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
2054 stabstr_C (',');
2055 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
2056 stabstr_S (";;");
2058 break;
2060 case ARRAY_TYPE:
2061 /* Make arrays of packed bits look like bitstrings for chill. */
2062 if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
2064 stabstr_S ("@s");
2065 stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
2066 stabstr_S (";@S;S");
2067 dbxout_type (TYPE_DOMAIN (type), 0);
2068 break;
2071 /* Output "a" followed by a range type definition
2072 for the index type of the array
2073 followed by a reference to the target-type.
2074 ar1;0;N;M for a C array of type M and size N+1. */
2075 /* Check if a character string type, which in Chill is
2076 different from an array of characters. */
2077 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
2079 stabstr_S ("@S;");
2081 tem = TYPE_DOMAIN (type);
2082 if (tem == NULL)
2084 stabstr_S ("ar");
2085 dbxout_type_index (integer_type_node);
2086 stabstr_S (";0;-1;");
2088 else
2090 stabstr_C ('a');
2091 dbxout_range_type (tem, TYPE_MIN_VALUE (tem), TYPE_MAX_VALUE (tem));
2094 dbxout_type (TREE_TYPE (type), 0);
2095 break;
2097 case VECTOR_TYPE:
2098 /* Make vectors look like an array. */
2099 if (use_gnu_debug_info_extensions)
2100 stabstr_S ("@V;");
2102 /* Output "a" followed by a range type definition
2103 for the index type of the array
2104 followed by a reference to the target-type.
2105 ar1;0;N;M for a C array of type M and size N+1. */
2106 stabstr_C ('a');
2107 dbxout_range_type (integer_type_node, size_zero_node,
2108 size_int (TYPE_VECTOR_SUBPARTS (type) - 1));
2110 dbxout_type (TREE_TYPE (type), 0);
2111 break;
2113 case RECORD_TYPE:
2114 case UNION_TYPE:
2115 case QUAL_UNION_TYPE:
2117 tree binfo = TYPE_BINFO (type);
2119 /* Output a structure type. We must use the same test here as we
2120 use in the DBX_NO_XREFS case above. */
2121 if ((TYPE_NAME (type) != 0
2122 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
2123 && DECL_IGNORED_P (TYPE_NAME (type)))
2124 && !full)
2125 || !COMPLETE_TYPE_P (type)
2126 /* No way in DBX fmt to describe a variable size. */
2127 || ! tree_fits_uhwi_p (TYPE_SIZE (type)))
2129 /* If the type is just a cross reference, output one
2130 and mark the type as partially described.
2131 If it later becomes defined, we will output
2132 its real definition.
2133 If the type has a name, don't nest its definition within
2134 another type's definition; instead, output an xref
2135 and let the definition come when the name is defined. */
2136 stabstr_S ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
2137 if (TYPE_IDENTIFIER (type))
2139 /* Note that the C frontend creates for anonymous variable
2140 length records/unions TYPE_NAME with DECL_NAME NULL. */
2141 dbxout_type_name (type);
2143 else
2145 stabstr_S ("$$");
2146 stabstr_D (anonymous_type_number++);
2149 stabstr_C (':');
2150 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
2151 break;
2154 /* Identify record or union, and print its size. */
2155 stabstr_C ((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u');
2156 stabstr_D (int_size_in_bytes (type));
2158 if (binfo)
2160 int i;
2161 tree child;
2162 vec<tree, va_gc> *accesses = BINFO_BASE_ACCESSES (binfo);
2164 if (use_gnu_debug_info_extensions)
2166 if (BINFO_N_BASE_BINFOS (binfo))
2168 stabstr_C ('!');
2169 stabstr_U (BINFO_N_BASE_BINFOS (binfo));
2170 stabstr_C (',');
2173 for (i = 0; BINFO_BASE_ITERATE (binfo, i, child); i++)
2175 tree access = (accesses ? (*accesses)[i] : access_public_node);
2177 if (use_gnu_debug_info_extensions)
2179 stabstr_C (BINFO_VIRTUAL_P (child) ? '1' : '0');
2180 stabstr_C (access == access_public_node ? '2' :
2181 access == access_protected_node
2182 ? '1' :'0');
2183 if (BINFO_VIRTUAL_P (child)
2184 && (lang_GNU_CXX ()
2185 || strcmp (lang_hooks.name, "GNU Objective-C++") == 0))
2186 /* For a virtual base, print the (negative)
2187 offset within the vtable where we must look
2188 to find the necessary adjustment. */
2189 stabstr_D
2190 (tree_to_shwi (BINFO_VPTR_FIELD (child))
2191 * BITS_PER_UNIT);
2192 else
2193 stabstr_D (tree_to_shwi (BINFO_OFFSET (child))
2194 * BITS_PER_UNIT);
2195 stabstr_C (',');
2196 dbxout_type (BINFO_TYPE (child), 0);
2197 stabstr_C (';');
2199 else
2201 /* Print out the base class information with
2202 fields which have the same names at the types
2203 they hold. */
2204 dbxout_type_name (BINFO_TYPE (child));
2205 stabstr_C (':');
2206 dbxout_type (BINFO_TYPE (child), full);
2207 stabstr_C (',');
2208 stabstr_D (tree_to_shwi (BINFO_OFFSET (child))
2209 * BITS_PER_UNIT);
2210 stabstr_C (',');
2211 stabstr_D
2212 (tree_to_shwi (TYPE_SIZE (BINFO_TYPE (child)))
2213 * BITS_PER_UNIT);
2214 stabstr_C (';');
2220 /* Write out the field declarations. */
2221 dbxout_type_fields (type);
2222 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
2224 dbxout_type_methods (type);
2227 stabstr_C (';');
2229 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
2230 /* Avoid the ~ if we don't really need it--it confuses dbx. */
2231 && TYPE_VFIELD (type))
2234 /* We need to write out info about what field this class
2235 uses as its "main" vtable pointer field, because if this
2236 field is inherited from a base class, GDB cannot necessarily
2237 figure out which field it's using in time. */
2238 stabstr_S ("~%");
2239 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
2240 stabstr_C (';');
2242 break;
2244 case ENUMERAL_TYPE:
2245 /* We must use the same test here as we use in the DBX_NO_XREFS case
2246 above. We simplify it a bit since an enum will never have a variable
2247 size. */
2248 if ((TYPE_NAME (type) != 0
2249 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
2250 && DECL_IGNORED_P (TYPE_NAME (type)))
2251 && !full)
2252 || !COMPLETE_TYPE_P (type))
2254 stabstr_S ("xe");
2255 dbxout_type_name (type);
2256 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
2257 stabstr_C (':');
2258 return;
2260 if (use_gnu_debug_info_extensions
2261 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
2263 stabstr_S ("@s");
2264 stabstr_D (TYPE_PRECISION (type));
2265 stabstr_C (';');
2268 stabstr_C ('e');
2269 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
2271 tree value = TREE_VALUE (tem);
2273 stabstr_I (TREE_PURPOSE (tem));
2274 stabstr_C (':');
2276 if (TREE_CODE (value) == CONST_DECL)
2277 value = DECL_INITIAL (value);
2279 if (cst_and_fits_in_hwi (value))
2280 stabstr_D (TREE_INT_CST_LOW (value));
2281 else
2282 stabstr_O (value);
2284 stabstr_C (',');
2285 if (TREE_CHAIN (tem) != 0)
2286 CONTIN;
2289 stabstr_C (';');
2290 break;
2292 case POINTER_TYPE:
2293 stabstr_C ('*');
2294 dbxout_type (TREE_TYPE (type), 0);
2295 break;
2297 case METHOD_TYPE:
2298 if (use_gnu_debug_info_extensions)
2300 stabstr_C ('#');
2302 /* Write the argument types out longhand. */
2303 dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
2304 stabstr_C (',');
2305 dbxout_type (TREE_TYPE (type), 0);
2306 dbxout_args (TYPE_ARG_TYPES (type));
2307 stabstr_C (';');
2309 else
2310 /* Treat it as a function type. */
2311 dbxout_type (TREE_TYPE (type), 0);
2312 break;
2314 case OFFSET_TYPE:
2315 if (use_gnu_debug_info_extensions)
2317 stabstr_C ('@');
2318 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
2319 stabstr_C (',');
2320 dbxout_type (TREE_TYPE (type), 0);
2322 else
2323 /* Should print as an int, because it is really just an offset. */
2324 dbxout_type (integer_type_node, 0);
2325 break;
2327 case REFERENCE_TYPE:
2328 if (use_gnu_debug_info_extensions)
2330 stabstr_C ('&');
2332 else
2333 stabstr_C ('*');
2334 dbxout_type (TREE_TYPE (type), 0);
2335 break;
2337 case FUNCTION_TYPE:
2338 stabstr_C ('f');
2339 dbxout_type (TREE_TYPE (type), 0);
2340 break;
2342 case POINTER_BOUNDS_TYPE:
2343 /* No debug info for pointer bounds type supported yet. */
2344 break;
2346 default:
2347 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
2348 named 'auto' in its type.
2349 No debug info for TEMPLATE_TYPE_PARM type supported yet. */
2350 if (lang_GNU_CXX ())
2352 tree name = TYPE_IDENTIFIER (type);
2353 if (name == get_identifier ("auto")
2354 || name == get_identifier ("decltype(auto)"))
2355 break;
2358 gcc_unreachable ();
2362 /* Return nonzero if the given type represents an integer whose bounds
2363 should be printed in octal format. */
2365 static bool
2366 print_int_cst_bounds_in_octal_p (tree type, tree low, tree high)
2368 /* If we can use GDB extensions and the size is wider than a long
2369 (the size used by GDB to read them) or we may have trouble writing
2370 the bounds the usual way, write them in octal. Note the test is for
2371 the *target's* size of "long", not that of the host. The host test
2372 is just to make sure we can write it out in case the host wide int
2373 is narrower than the target "long".
2375 For unsigned types, we use octal if they are the same size or larger.
2376 This is because we print the bounds as signed decimal, and hence they
2377 can't span same size unsigned types. */
2379 if (use_gnu_debug_info_extensions
2380 && low && TREE_CODE (low) == INTEGER_CST
2381 && high && TREE_CODE (high) == INTEGER_CST
2382 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
2383 || ((TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2384 && TYPE_UNSIGNED (type))
2385 || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
2386 || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
2387 && TYPE_UNSIGNED (type))))
2388 return TRUE;
2389 else
2390 return FALSE;
2393 /* Output the name of type TYPE, with no punctuation.
2394 Such names can be set up either by typedef declarations
2395 or by struct, enum and union tags. */
2397 static void
2398 dbxout_type_name (tree type)
2400 tree t = TYPE_NAME (type);
2402 gcc_assert (t);
2403 switch (TREE_CODE (t))
2405 case IDENTIFIER_NODE:
2406 break;
2407 case TYPE_DECL:
2408 t = DECL_NAME (t);
2409 break;
2410 default:
2411 gcc_unreachable ();
2414 stabstr_I (t);
2417 /* Output leading leading struct or class names needed for qualifying
2418 type whose scope is limited to a struct or class. */
2420 static void
2421 dbxout_class_name_qualifiers (tree decl)
2423 tree context = decl_type_context (decl);
2425 if (context != NULL_TREE
2426 && TREE_CODE (context) == RECORD_TYPE
2427 && TYPE_NAME (context) != 0
2428 && (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE
2429 || (DECL_NAME (TYPE_NAME (context)) != 0)))
2431 tree name = TYPE_NAME (context);
2433 if (TREE_CODE (name) == TYPE_DECL)
2435 dbxout_class_name_qualifiers (name);
2436 name = DECL_NAME (name);
2438 stabstr_I (name);
2439 stabstr_S ("::");
2443 /* This is a specialized subset of expand_expr for use by dbxout_symbol in
2444 evaluating DECL_VALUE_EXPR. In particular, we stop if we find decls that
2445 haven't been expanded, or if the expression is getting so complex we won't
2446 be able to represent it in stabs anyway. Returns NULL on failure. */
2448 static rtx
2449 dbxout_expand_expr (tree expr)
2451 switch (TREE_CODE (expr))
2453 case VAR_DECL:
2454 /* We can't handle emulated tls variables, because the address is an
2455 offset to the return value of __emutls_get_address, and there is no
2456 way to express that in stabs. Also, there are name mangling issues
2457 here. We end up with references to undefined symbols if we don't
2458 disable debug info for these variables. */
2459 if (!targetm.have_tls && DECL_THREAD_LOCAL_P (expr))
2460 return NULL;
2461 if (TREE_STATIC (expr)
2462 && !TREE_ASM_WRITTEN (expr)
2463 && !DECL_HAS_VALUE_EXPR_P (expr)
2464 && !TREE_PUBLIC (expr)
2465 && DECL_RTL_SET_P (expr)
2466 && MEM_P (DECL_RTL (expr)))
2468 /* If this is a var that might not be actually output,
2469 return NULL, otherwise stabs might reference an undefined
2470 symbol. */
2471 varpool_node *node = varpool_node::get (expr);
2472 if (!node || !node->definition)
2473 return NULL;
2475 /* FALLTHRU */
2477 case PARM_DECL:
2478 case RESULT_DECL:
2479 if (DECL_HAS_VALUE_EXPR_P (expr))
2480 return dbxout_expand_expr (DECL_VALUE_EXPR (expr));
2481 /* FALLTHRU */
2483 case CONST_DECL:
2484 return DECL_RTL_IF_SET (expr);
2486 case INTEGER_CST:
2487 return expand_expr (expr, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
2489 case COMPONENT_REF:
2490 case ARRAY_REF:
2491 case ARRAY_RANGE_REF:
2492 case BIT_FIELD_REF:
2494 machine_mode mode;
2495 HOST_WIDE_INT bitsize, bitpos;
2496 tree offset, tem;
2497 int volatilep = 0, unsignedp = 0;
2498 rtx x;
2500 tem = get_inner_reference (expr, &bitsize, &bitpos, &offset,
2501 &mode, &unsignedp, &volatilep, true);
2503 x = dbxout_expand_expr (tem);
2504 if (x == NULL || !MEM_P (x))
2505 return NULL;
2506 if (offset != NULL)
2508 if (!tree_fits_shwi_p (offset))
2509 return NULL;
2510 x = adjust_address_nv (x, mode, tree_to_shwi (offset));
2512 if (bitpos != 0)
2513 x = adjust_address_nv (x, mode, bitpos / BITS_PER_UNIT);
2515 return x;
2518 default:
2519 return NULL;
2523 /* Helper function for output_used_types. Queue one entry from the
2524 used types hash to be output. */
2526 bool
2527 output_used_types_helper (tree const &type, vec<tree> *types_p)
2529 if ((TREE_CODE (type) == RECORD_TYPE
2530 || TREE_CODE (type) == UNION_TYPE
2531 || TREE_CODE (type) == QUAL_UNION_TYPE
2532 || TREE_CODE (type) == ENUMERAL_TYPE)
2533 && TYPE_STUB_DECL (type)
2534 && DECL_P (TYPE_STUB_DECL (type))
2535 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
2536 types_p->quick_push (TYPE_STUB_DECL (type));
2537 else if (TYPE_NAME (type)
2538 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2539 types_p->quick_push (TYPE_NAME (type));
2541 return true;
2544 /* This is a qsort callback which sorts types and declarations into a
2545 predictable order (types, then declarations, sorted by UID
2546 within). */
2548 static int
2549 output_types_sort (const void *pa, const void *pb)
2551 const tree lhs = *((const tree *)pa);
2552 const tree rhs = *((const tree *)pb);
2554 if (TYPE_P (lhs))
2556 if (TYPE_P (rhs))
2557 return TYPE_UID (lhs) - TYPE_UID (rhs);
2558 else
2559 return 1;
2561 else
2563 if (TYPE_P (rhs))
2564 return -1;
2565 else
2566 return DECL_UID (lhs) - DECL_UID (rhs);
2571 /* Force all types used by this function to be output in debug
2572 information. */
2574 static void
2575 output_used_types (void)
2577 if (cfun && cfun->used_types_hash)
2579 vec<tree> types;
2580 int i;
2581 tree type;
2583 types.create (cfun->used_types_hash->elements ());
2584 cfun->used_types_hash->traverse<vec<tree> *, output_used_types_helper>
2585 (&types);
2587 /* Sort by UID to prevent dependence on hash table ordering. */
2588 types.qsort (output_types_sort);
2590 FOR_EACH_VEC_ELT (types, i, type)
2591 debug_queue_symbol (type);
2593 types.release ();
2597 /* Output a .stabs for the symbol defined by DECL,
2598 which must be a ..._DECL node in the normal namespace.
2599 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2600 LOCAL is nonzero if the scope is less than the entire file.
2601 Return 1 if a stabs might have been emitted. */
2604 dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
2606 tree type = TREE_TYPE (decl);
2607 tree context = NULL_TREE;
2608 int result = 0;
2609 rtx decl_rtl;
2611 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
2612 ++debug_nesting;
2614 /* Ignore nameless syms, but don't ignore type tags. */
2616 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
2617 || DECL_IGNORED_P (decl))
2618 DBXOUT_DECR_NESTING_AND_RETURN (0);
2620 /* If we are to generate only the symbols actually used then such
2621 symbol nodes are flagged with TREE_USED. Ignore any that
2622 aren't flagged as TREE_USED. */
2624 if (flag_debug_only_used_symbols
2625 && (!TREE_USED (decl)
2626 && (TREE_CODE (decl) != VAR_DECL || !DECL_INITIAL (decl))))
2627 DBXOUT_DECR_NESTING_AND_RETURN (0);
2629 /* If dbxout_init has not yet run, queue this symbol for later. */
2630 if (!typevec)
2632 preinit_symbols = tree_cons (0, decl, preinit_symbols);
2633 DBXOUT_DECR_NESTING_AND_RETURN (0);
2636 if (flag_debug_only_used_symbols)
2638 tree t;
2640 /* We now have a used symbol. We need to generate the info for
2641 the symbol's type in addition to the symbol itself. These
2642 type symbols are queued to be generated after were done with
2643 the symbol itself (otherwise they would fight over the
2644 stabstr obstack).
2646 Note, because the TREE_TYPE(type) might be something like a
2647 pointer to a named type we need to look for the first name
2648 we see following the TREE_TYPE chain. */
2650 t = type;
2651 while (POINTER_TYPE_P (t))
2652 t = TREE_TYPE (t);
2654 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2655 need special treatment. The TYPE_STUB_DECL field in these
2656 types generally represents the tag name type we want to
2657 output. In addition there could be a typedef type with
2658 a different name. In that case we also want to output
2659 that. */
2661 if (TREE_CODE (t) == RECORD_TYPE
2662 || TREE_CODE (t) == UNION_TYPE
2663 || TREE_CODE (t) == QUAL_UNION_TYPE
2664 || TREE_CODE (t) == ENUMERAL_TYPE)
2666 if (TYPE_STUB_DECL (t)
2667 && TYPE_STUB_DECL (t) != decl
2668 && DECL_P (TYPE_STUB_DECL (t))
2669 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t)))
2671 debug_queue_symbol (TYPE_STUB_DECL (t));
2672 if (TYPE_NAME (t)
2673 && TYPE_NAME (t) != TYPE_STUB_DECL (t)
2674 && TYPE_NAME (t) != decl
2675 && DECL_P (TYPE_NAME (t)))
2676 debug_queue_symbol (TYPE_NAME (t));
2679 else if (TYPE_NAME (t)
2680 && TYPE_NAME (t) != decl
2681 && DECL_P (TYPE_NAME (t)))
2682 debug_queue_symbol (TYPE_NAME (t));
2685 emit_pending_bincls_if_required ();
2687 switch (TREE_CODE (decl))
2689 case CONST_DECL:
2690 /* Enum values are defined by defining the enum type. */
2691 break;
2693 case FUNCTION_DECL:
2694 decl_rtl = DECL_RTL_IF_SET (decl);
2695 if (!decl_rtl)
2696 DBXOUT_DECR_NESTING_AND_RETURN (0);
2697 if (DECL_EXTERNAL (decl))
2698 break;
2699 /* Don't mention a nested function under its parent. */
2700 context = decl_function_context (decl);
2701 if (context == current_function_decl)
2702 break;
2703 /* Don't mention an inline instance of a nested function. */
2704 if (context && DECL_FROM_INLINE (decl))
2705 break;
2706 if (!MEM_P (decl_rtl)
2707 || GET_CODE (XEXP (decl_rtl, 0)) != SYMBOL_REF)
2708 break;
2710 if (flag_debug_only_used_symbols)
2711 output_used_types ();
2713 dbxout_begin_complex_stabs ();
2714 stabstr_I (DECL_ASSEMBLER_NAME (decl));
2715 stabstr_S (TREE_PUBLIC (decl) ? ":F" : ":f");
2716 result = 1;
2718 if (TREE_TYPE (type))
2719 dbxout_type (TREE_TYPE (type), 0);
2720 else
2721 dbxout_type (void_type_node, 0);
2723 /* For a nested function, when that function is compiled,
2724 mention the containing function name
2725 as well as (since dbx wants it) our own assembler-name. */
2726 if (context != 0)
2728 stabstr_C (',');
2729 stabstr_I (DECL_ASSEMBLER_NAME (decl));
2730 stabstr_C (',');
2731 stabstr_I (DECL_NAME (context));
2734 dbxout_finish_complex_stabs (decl, N_FUN, XEXP (decl_rtl, 0), 0, 0);
2735 break;
2737 case TYPE_DECL:
2738 /* Don't output the same typedef twice.
2739 And don't output what language-specific stuff doesn't want output. */
2740 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
2741 DBXOUT_DECR_NESTING_AND_RETURN (0);
2743 /* Don't output typedefs for types with magic type numbers (XCOFF). */
2744 #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2746 int fundamental_type_number =
2747 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl);
2749 if (fundamental_type_number != 0)
2751 TREE_ASM_WRITTEN (decl) = 1;
2752 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = fundamental_type_number;
2753 DBXOUT_DECR_NESTING_AND_RETURN (0);
2756 #endif
2757 FORCE_TEXT;
2758 result = 1;
2760 int tag_needed = 1;
2761 int did_output = 0;
2763 if (DECL_NAME (decl))
2765 /* Nonzero means we must output a tag as well as a typedef. */
2766 tag_needed = 0;
2768 /* Handle the case of a C++ structure or union
2769 where the TYPE_NAME is a TYPE_DECL
2770 which gives both a typedef name and a tag. */
2771 /* dbx requires the tag first and the typedef second. */
2772 if ((TREE_CODE (type) == RECORD_TYPE
2773 || TREE_CODE (type) == UNION_TYPE
2774 || TREE_CODE (type) == QUAL_UNION_TYPE)
2775 && TYPE_NAME (type) == decl
2776 && !use_gnu_debug_info_extensions
2777 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
2778 /* Distinguish the implicit typedefs of C++
2779 from explicit ones that might be found in C. */
2780 && DECL_ARTIFICIAL (decl)
2781 /* Do not generate a tag for incomplete records. */
2782 && COMPLETE_TYPE_P (type)
2783 /* Do not generate a tag for records of variable size,
2784 since this type can not be properly described in the
2785 DBX format, and it confuses some tools such as objdump. */
2786 && tree_fits_uhwi_p (TYPE_SIZE (type)))
2788 tree name = TYPE_IDENTIFIER (type);
2790 dbxout_begin_complex_stabs ();
2791 stabstr_I (name);
2792 stabstr_S (":T");
2793 dbxout_type (type, 1);
2794 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE,
2795 0, 0, 0);
2798 dbxout_begin_complex_stabs ();
2800 /* Output leading class/struct qualifiers. */
2801 if (use_gnu_debug_info_extensions)
2802 dbxout_class_name_qualifiers (decl);
2804 /* Output typedef name. */
2805 stabstr_I (DECL_NAME (decl));
2806 stabstr_C (':');
2808 /* Short cut way to output a tag also. */
2809 if ((TREE_CODE (type) == RECORD_TYPE
2810 || TREE_CODE (type) == UNION_TYPE
2811 || TREE_CODE (type) == QUAL_UNION_TYPE)
2812 && TYPE_NAME (type) == decl
2813 /* Distinguish the implicit typedefs of C++
2814 from explicit ones that might be found in C. */
2815 && DECL_ARTIFICIAL (decl))
2817 if (use_gnu_debug_info_extensions)
2819 stabstr_C ('T');
2820 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
2824 stabstr_C ('t');
2825 dbxout_type (type, 1);
2826 dbxout_finish_complex_stabs (decl, DBX_TYPE_DECL_STABS_CODE,
2827 0, 0, 0);
2828 did_output = 1;
2831 /* Don't output a tag if this is an incomplete type. This prevents
2832 the sun4 Sun OS 4.x dbx from crashing. */
2834 if (tag_needed && TYPE_NAME (type) != 0
2835 && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
2836 || (DECL_NAME (TYPE_NAME (type)) != 0))
2837 && COMPLETE_TYPE_P (type)
2838 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
2840 /* For a TYPE_DECL with no name, but the type has a name,
2841 output a tag.
2842 This is what represents `struct foo' with no typedef. */
2843 /* In C++, the name of a type is the corresponding typedef.
2844 In C, it is an IDENTIFIER_NODE. */
2845 tree name = TYPE_IDENTIFIER (type);
2847 dbxout_begin_complex_stabs ();
2848 stabstr_I (name);
2849 stabstr_S (":T");
2850 dbxout_type (type, 1);
2851 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
2852 did_output = 1;
2855 /* If an enum type has no name, it cannot be referred to, but
2856 we must output it anyway, to record the enumeration
2857 constants. */
2859 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
2861 dbxout_begin_complex_stabs ();
2862 /* Some debuggers fail when given NULL names, so give this a
2863 harmless name of " " (Why not "(anon)"?). */
2864 stabstr_S (" :T");
2865 dbxout_type (type, 1);
2866 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
2869 /* Prevent duplicate output of a typedef. */
2870 TREE_ASM_WRITTEN (decl) = 1;
2871 break;
2874 case PARM_DECL:
2875 if (DECL_HAS_VALUE_EXPR_P (decl))
2876 decl = DECL_VALUE_EXPR (decl);
2878 /* PARM_DECLs go in their own separate chain and are output by
2879 dbxout_reg_parms and dbxout_parms, except for those that are
2880 disguised VAR_DECLs like Out parameters in Ada. */
2881 gcc_assert (TREE_CODE (decl) == VAR_DECL);
2883 /* ... fall through ... */
2885 case RESULT_DECL:
2886 case VAR_DECL:
2887 /* Don't mention a variable that is external.
2888 Let the file that defines it describe it. */
2889 if (DECL_EXTERNAL (decl))
2890 break;
2892 /* If the variable is really a constant
2893 and not written in memory, inform the debugger.
2895 ??? Why do we skip emitting the type and location in this case? */
2896 if (TREE_STATIC (decl) && TREE_READONLY (decl)
2897 && DECL_INITIAL (decl) != 0
2898 && tree_fits_shwi_p (DECL_INITIAL (decl))
2899 && ! TREE_ASM_WRITTEN (decl)
2900 && (DECL_FILE_SCOPE_P (decl)
2901 || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK
2902 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
2903 && TREE_PUBLIC (decl) == 0)
2905 /* The sun4 assembler does not grok this. */
2907 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
2908 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
2910 HOST_WIDE_INT ival = tree_to_shwi (DECL_INITIAL (decl));
2912 dbxout_begin_complex_stabs ();
2913 dbxout_symbol_name (decl, NULL, 'c');
2914 stabstr_S ("=i");
2915 stabstr_D (ival);
2916 dbxout_finish_complex_stabs (0, N_LSYM, 0, 0, 0);
2917 DBXOUT_DECR_NESTING;
2918 return 1;
2920 else
2921 break;
2923 /* else it is something we handle like a normal variable. */
2925 decl_rtl = dbxout_expand_expr (decl);
2926 if (!decl_rtl)
2927 DBXOUT_DECR_NESTING_AND_RETURN (0);
2929 if (!is_global_var (decl))
2930 decl_rtl = eliminate_regs (decl_rtl, VOIDmode, NULL_RTX);
2931 #ifdef LEAF_REG_REMAP
2932 if (crtl->uses_only_leaf_regs)
2933 leaf_renumber_regs_insn (decl_rtl);
2934 #endif
2936 result = dbxout_symbol_location (decl, type, 0, decl_rtl);
2937 break;
2939 default:
2940 break;
2942 DBXOUT_DECR_NESTING;
2943 return result;
2946 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2947 Add SUFFIX to its name, if SUFFIX is not 0.
2948 Describe the variable as residing in HOME
2949 (usually HOME is DECL_RTL (DECL), but not always).
2950 Returns 1 if the stab was really emitted. */
2952 static int
2953 dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
2955 int letter = 0;
2956 stab_code_type code;
2957 rtx addr = 0;
2958 int number = 0;
2959 int regno = -1;
2961 /* Don't mention a variable at all
2962 if it was completely optimized into nothingness.
2964 If the decl was from an inline function, then its rtl
2965 is not identically the rtl that was used in this
2966 particular compilation. */
2967 if (GET_CODE (home) == SUBREG)
2969 rtx value = home;
2971 while (GET_CODE (value) == SUBREG)
2972 value = SUBREG_REG (value);
2973 if (REG_P (value))
2975 if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
2976 return 0;
2978 home = alter_subreg (&home, true);
2980 if (REG_P (home))
2982 regno = REGNO (home);
2983 if (regno >= FIRST_PSEUDO_REGISTER)
2984 return 0;
2987 /* The kind-of-variable letter depends on where
2988 the variable is and on the scope of its name:
2989 G and N_GSYM for static storage and global scope,
2990 S for static storage and file scope,
2991 V for static storage and local scope,
2992 for those two, use N_LCSYM if data is in bss segment,
2993 N_STSYM if in data segment, N_FUN otherwise.
2994 (We used N_FUN originally, then changed to N_STSYM
2995 to please GDB. However, it seems that confused ld.
2996 Now GDB has been fixed to like N_FUN, says Kingdon.)
2997 no letter at all, and N_LSYM, for auto variable,
2998 r and N_RSYM for register variable. */
3000 if (MEM_P (home) && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
3002 if (TREE_PUBLIC (decl))
3004 int offs;
3005 letter = 'G';
3006 code = N_GSYM;
3007 if (NULL != dbxout_common_check (decl, &offs))
3009 letter = 'V';
3010 addr = 0;
3011 number = offs;
3014 else
3016 addr = XEXP (home, 0);
3018 letter = decl_function_context (decl) ? 'V' : 'S';
3020 /* Some ports can transform a symbol ref into a label ref,
3021 because the symbol ref is too far away and has to be
3022 dumped into a constant pool. Alternatively, the symbol
3023 in the constant pool might be referenced by a different
3024 symbol. */
3025 if (GET_CODE (addr) == SYMBOL_REF
3026 && CONSTANT_POOL_ADDRESS_P (addr))
3028 bool marked;
3029 rtx tmp = get_pool_constant_mark (addr, &marked);
3031 if (GET_CODE (tmp) == SYMBOL_REF)
3033 addr = tmp;
3034 if (CONSTANT_POOL_ADDRESS_P (addr))
3035 get_pool_constant_mark (addr, &marked);
3036 else
3037 marked = true;
3039 else if (GET_CODE (tmp) == LABEL_REF)
3041 addr = tmp;
3042 marked = true;
3045 /* If all references to the constant pool were optimized
3046 out, we just ignore the symbol. */
3047 if (!marked)
3048 return 0;
3051 /* This should be the same condition as in assemble_variable, but
3052 we don't have access to dont_output_data here. So, instead,
3053 we rely on the fact that error_mark_node initializers always
3054 end up in bss for C++ and never end up in bss for C. */
3055 if (DECL_INITIAL (decl) == 0
3056 || (lang_GNU_CXX ()
3057 && DECL_INITIAL (decl) == error_mark_node))
3059 int offs;
3060 code = N_LCSYM;
3061 if (NULL != dbxout_common_check (decl, &offs))
3063 addr = 0;
3064 number = offs;
3065 letter = 'V';
3066 code = N_GSYM;
3069 else if (DECL_IN_TEXT_SECTION (decl))
3070 /* This is not quite right, but it's the closest
3071 of all the codes that Unix defines. */
3072 code = DBX_STATIC_CONST_VAR_CODE;
3073 else
3075 /* Ultrix `as' seems to need this. */
3076 #ifdef DBX_STATIC_STAB_DATA_SECTION
3077 switch_to_section (data_section);
3078 #endif
3079 code = N_STSYM;
3083 else if (regno >= 0)
3085 letter = 'r';
3086 code = N_RSYM;
3087 number = DBX_REGISTER_NUMBER (regno);
3089 else if (MEM_P (home)
3090 && (MEM_P (XEXP (home, 0))
3091 || (REG_P (XEXP (home, 0))
3092 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
3093 && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
3094 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
3095 && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
3096 #endif
3098 /* If the value is indirect by memory or by a register
3099 that isn't the frame pointer
3100 then it means the object is variable-sized and address through
3101 that register or stack slot. DBX has no way to represent this
3102 so all we can do is output the variable as a pointer.
3103 If it's not a parameter, ignore it. */
3105 if (REG_P (XEXP (home, 0)))
3107 letter = 'r';
3108 code = N_RSYM;
3109 if (REGNO (XEXP (home, 0)) >= FIRST_PSEUDO_REGISTER)
3110 return 0;
3111 number = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
3113 else
3115 code = N_LSYM;
3116 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
3117 We want the value of that CONST_INT. */
3118 number = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
3121 /* Effectively do build_pointer_type, but don't cache this type,
3122 since it might be temporary whereas the type it points to
3123 might have been saved for inlining. */
3124 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
3125 type = make_node (POINTER_TYPE);
3126 TREE_TYPE (type) = TREE_TYPE (decl);
3128 else if (MEM_P (home)
3129 && REG_P (XEXP (home, 0)))
3131 code = N_LSYM;
3132 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
3134 else if (MEM_P (home)
3135 && GET_CODE (XEXP (home, 0)) == PLUS
3136 && CONST_INT_P (XEXP (XEXP (home, 0), 1)))
3138 code = N_LSYM;
3139 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
3140 We want the value of that CONST_INT. */
3141 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
3143 else if (MEM_P (home)
3144 && GET_CODE (XEXP (home, 0)) == CONST)
3146 /* Handle an obscure case which can arise when optimizing and
3147 when there are few available registers. (This is *always*
3148 the case for i386/i486 targets). The RTL looks like
3149 (MEM (CONST ...)) even though this variable is a local `auto'
3150 or a local `register' variable. In effect, what has happened
3151 is that the reload pass has seen that all assignments and
3152 references for one such a local variable can be replaced by
3153 equivalent assignments and references to some static storage
3154 variable, thereby avoiding the need for a register. In such
3155 cases we're forced to lie to debuggers and tell them that
3156 this variable was itself `static'. */
3157 int offs;
3158 code = N_LCSYM;
3159 letter = 'V';
3160 if (NULL == dbxout_common_check (decl, &offs))
3161 addr = XEXP (XEXP (home, 0), 0);
3162 else
3164 addr = 0;
3165 number = offs;
3166 code = N_GSYM;
3169 else if (GET_CODE (home) == CONCAT)
3171 tree subtype;
3173 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
3174 for example), then there is no easy way to figure out
3175 what SUBTYPE should be. So, we give up. */
3176 if (TREE_CODE (type) != COMPLEX_TYPE)
3177 return 0;
3179 subtype = TREE_TYPE (type);
3181 /* If the variable's storage is in two parts,
3182 output each as a separate stab with a modified name. */
3183 if (WORDS_BIG_ENDIAN)
3184 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
3185 else
3186 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
3188 if (WORDS_BIG_ENDIAN)
3189 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
3190 else
3191 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
3192 return 1;
3194 else
3195 /* Address might be a MEM, when DECL is a variable-sized object.
3196 Or it might be const0_rtx, meaning previous passes
3197 want us to ignore this variable. */
3198 return 0;
3200 /* Ok, start a symtab entry and output the variable name. */
3201 emit_pending_bincls_if_required ();
3202 FORCE_TEXT;
3204 #ifdef DBX_STATIC_BLOCK_START
3205 DBX_STATIC_BLOCK_START (asm_out_file, code);
3206 #endif
3208 dbxout_begin_complex_stabs_noforcetext ();
3209 dbxout_symbol_name (decl, suffix, letter);
3210 dbxout_type (type, 0);
3211 dbxout_finish_complex_stabs (decl, code, addr, 0, number);
3213 #ifdef DBX_STATIC_BLOCK_END
3214 DBX_STATIC_BLOCK_END (asm_out_file, code);
3215 #endif
3216 return 1;
3219 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
3220 Then output LETTER to indicate the kind of location the symbol has. */
3222 static void
3223 dbxout_symbol_name (tree decl, const char *suffix, int letter)
3225 tree name;
3227 if (DECL_CONTEXT (decl)
3228 && (TYPE_P (DECL_CONTEXT (decl))
3229 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL))
3230 /* One slight hitch: if this is a VAR_DECL which is a class member
3231 or a namespace member, we must put out the mangled name instead of the
3232 DECL_NAME. Note also that static member (variable) names DO NOT begin
3233 with underscores in .stabs directives. */
3234 name = DECL_ASSEMBLER_NAME (decl);
3235 else
3236 /* ...but if we're function-local, we don't want to include the junk
3237 added by ASM_FORMAT_PRIVATE_NAME. */
3238 name = DECL_NAME (decl);
3240 if (name)
3241 stabstr_I (name);
3242 else
3243 stabstr_S ("(anon)");
3245 if (suffix)
3246 stabstr_S (suffix);
3247 stabstr_C (':');
3248 if (letter)
3249 stabstr_C (letter);
3253 /* Output the common block name for DECL in a stabs.
3255 Symbols in global common (.comm) get wrapped with an N_BCOMM/N_ECOMM pair
3256 around each group of symbols in the same .comm area. The N_GSYM stabs
3257 that are emitted only contain the offset in the common area. This routine
3258 emits the N_BCOMM and N_ECOMM stabs. */
3260 static void
3261 dbxout_common_name (tree decl, const char *name, stab_code_type op)
3263 dbxout_begin_complex_stabs ();
3264 stabstr_S (name);
3265 dbxout_finish_complex_stabs (decl, op, NULL_RTX, NULL, 0);
3268 /* Check decl to determine whether it is a VAR_DECL destined for storage in a
3269 common area. If it is, the return value will be a non-null string giving
3270 the name of the common storage block it will go into. If non-null, the
3271 value is the offset into the common block for that symbol's storage. */
3273 static const char *
3274 dbxout_common_check (tree decl, int *value)
3276 rtx home;
3277 rtx sym_addr;
3278 const char *name = NULL;
3280 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
3281 it does not have a value (the offset into the common area), or if it
3282 is thread local (as opposed to global) then it isn't common, and shouldn't
3283 be handled as such.
3285 ??? DECL_THREAD_LOCAL_P check prevents problems with improper .stabs
3286 for thread-local symbols. Can be handled via same mechanism as used
3287 in dwarf2out.c. */
3288 if (TREE_CODE (decl) != VAR_DECL
3289 || !TREE_STATIC (decl)
3290 || !DECL_HAS_VALUE_EXPR_P (decl)
3291 || DECL_THREAD_LOCAL_P (decl)
3292 || !is_fortran ())
3293 return NULL;
3295 home = DECL_RTL (decl);
3296 if (home == NULL_RTX || GET_CODE (home) != MEM)
3297 return NULL;
3299 sym_addr = dbxout_expand_expr (DECL_VALUE_EXPR (decl));
3300 if (sym_addr == NULL_RTX || GET_CODE (sym_addr) != MEM)
3301 return NULL;
3303 sym_addr = XEXP (sym_addr, 0);
3304 if (GET_CODE (sym_addr) == CONST)
3305 sym_addr = XEXP (sym_addr, 0);
3306 if ((GET_CODE (sym_addr) == SYMBOL_REF || GET_CODE (sym_addr) == PLUS)
3307 && DECL_INITIAL (decl) == 0)
3310 /* We have a sym that will go into a common area, meaning that it
3311 will get storage reserved with a .comm/.lcomm assembler pseudo-op.
3313 Determine name of common area this symbol will be an offset into,
3314 and offset into that area. Also retrieve the decl for the area
3315 that the symbol is offset into. */
3316 tree cdecl = NULL;
3318 switch (GET_CODE (sym_addr))
3320 case PLUS:
3321 if (CONST_INT_P (XEXP (sym_addr, 0)))
3323 name =
3324 targetm.strip_name_encoding (XSTR (XEXP (sym_addr, 1), 0));
3325 *value = INTVAL (XEXP (sym_addr, 0));
3326 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 1));
3328 else
3330 name =
3331 targetm.strip_name_encoding (XSTR (XEXP (sym_addr, 0), 0));
3332 *value = INTVAL (XEXP (sym_addr, 1));
3333 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 0));
3335 break;
3337 case SYMBOL_REF:
3338 name = targetm.strip_name_encoding (XSTR (sym_addr, 0));
3339 *value = 0;
3340 cdecl = SYMBOL_REF_DECL (sym_addr);
3341 break;
3343 default:
3344 error ("common symbol debug info is not structured as "
3345 "symbol+offset");
3348 /* Check area common symbol is offset into. If this is not public, then
3349 it is not a symbol in a common block. It must be a .lcomm symbol, not
3350 a .comm symbol. */
3351 if (cdecl == NULL || !TREE_PUBLIC (cdecl))
3352 name = NULL;
3354 else
3355 name = NULL;
3357 return name;
3360 /* Output definitions of all the decls in a chain. Return nonzero if
3361 anything was output */
3364 dbxout_syms (tree syms)
3366 int result = 0;
3367 const char *comm_prev = NULL;
3368 tree syms_prev = NULL;
3370 while (syms)
3372 int temp, copen, cclos;
3373 const char *comm_new;
3375 /* Check for common symbol, and then progression into a new/different
3376 block of common symbols. Emit closing/opening common bracket if
3377 necessary. */
3378 comm_new = dbxout_common_check (syms, &temp);
3379 copen = comm_new != NULL
3380 && (comm_prev == NULL || strcmp (comm_new, comm_prev));
3381 cclos = comm_prev != NULL
3382 && (comm_new == NULL || strcmp (comm_new, comm_prev));
3383 if (cclos)
3384 dbxout_common_name (syms_prev, comm_prev, N_ECOMM);
3385 if (copen)
3387 dbxout_common_name (syms, comm_new, N_BCOMM);
3388 syms_prev = syms;
3390 comm_prev = comm_new;
3392 result += dbxout_symbol (syms, 1);
3393 syms = DECL_CHAIN (syms);
3396 if (comm_prev != NULL)
3397 dbxout_common_name (syms_prev, comm_prev, N_ECOMM);
3399 return result;
3402 /* The following two functions output definitions of function parameters.
3403 Each parameter gets a definition locating it in the parameter list.
3404 Each parameter that is a register variable gets a second definition
3405 locating it in the register.
3407 Printing or argument lists in gdb uses the definitions that
3408 locate in the parameter list. But reference to the variable in
3409 expressions uses preferentially the definition as a register. */
3411 /* Output definitions, referring to storage in the parmlist,
3412 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
3414 void
3415 dbxout_parms (tree parms)
3417 ++debug_nesting;
3418 emit_pending_bincls_if_required ();
3420 for (; parms; parms = DECL_CHAIN (parms))
3421 if (DECL_NAME (parms)
3422 && TREE_TYPE (parms) != error_mark_node
3423 && DECL_RTL_SET_P (parms)
3424 && DECL_INCOMING_RTL (parms))
3426 tree eff_type;
3427 char letter;
3428 stab_code_type code;
3429 int number;
3431 /* Perform any necessary register eliminations on the parameter's rtl,
3432 so that the debugging output will be accurate. */
3433 DECL_INCOMING_RTL (parms)
3434 = eliminate_regs (DECL_INCOMING_RTL (parms), VOIDmode, NULL_RTX);
3435 SET_DECL_RTL (parms,
3436 eliminate_regs (DECL_RTL (parms), VOIDmode, NULL_RTX));
3437 #ifdef LEAF_REG_REMAP
3438 if (crtl->uses_only_leaf_regs)
3440 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
3441 leaf_renumber_regs_insn (DECL_RTL (parms));
3443 #endif
3445 if (PARM_PASSED_IN_MEMORY (parms))
3447 rtx inrtl = XEXP (DECL_INCOMING_RTL (parms), 0);
3449 /* ??? Here we assume that the parm address is indexed
3450 off the frame pointer or arg pointer.
3451 If that is not true, we produce meaningless results,
3452 but do not crash. */
3453 if (GET_CODE (inrtl) == PLUS
3454 && CONST_INT_P (XEXP (inrtl, 1)))
3455 number = INTVAL (XEXP (inrtl, 1));
3456 else
3457 number = 0;
3459 code = N_PSYM;
3460 number = DEBUGGER_ARG_OFFSET (number, inrtl);
3461 letter = 'p';
3463 /* It is quite tempting to use TREE_TYPE (parms) instead
3464 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
3465 reports the actual type of the parameter, rather than
3466 the promoted type. This certainly makes GDB's life
3467 easier, at least for some ports. The change is a bad
3468 idea however, since GDB expects to be able access the
3469 type without performing any conversions. So for
3470 example, if we were passing a float to an unprototyped
3471 function, gcc will store a double on the stack, but if
3472 we emit a stab saying the type is a float, then gdb
3473 will only read in a single value, and this will produce
3474 an erroneous value. */
3475 eff_type = DECL_ARG_TYPE (parms);
3477 else if (REG_P (DECL_RTL (parms)))
3479 rtx best_rtl;
3481 /* Parm passed in registers and lives in registers or nowhere. */
3482 code = DBX_REGPARM_STABS_CODE;
3483 letter = DBX_REGPARM_STABS_LETTER;
3485 /* For parms passed in registers, it is better to use the
3486 declared type of the variable, not the type it arrived in. */
3487 eff_type = TREE_TYPE (parms);
3489 /* If parm lives in a register, use that register; pretend
3490 the parm was passed there. It would be more consistent
3491 to describe the register where the parm was passed, but
3492 in practice that register usually holds something else.
3493 If the parm lives nowhere, use the register where it
3494 was passed. */
3495 if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
3496 best_rtl = DECL_RTL (parms);
3497 else if (GET_CODE (DECL_INCOMING_RTL (parms)) == PARALLEL)
3498 best_rtl = XEXP (XVECEXP (DECL_INCOMING_RTL (parms), 0, 0), 0);
3499 else
3500 best_rtl = DECL_INCOMING_RTL (parms);
3502 number = DBX_REGISTER_NUMBER (REGNO (best_rtl));
3504 else if (MEM_P (DECL_RTL (parms))
3505 && REG_P (XEXP (DECL_RTL (parms), 0))
3506 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
3507 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
3508 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
3509 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
3510 #endif
3513 /* Parm was passed via invisible reference.
3514 That is, its address was passed in a register.
3515 Output it as if it lived in that register.
3516 The debugger will know from the type
3517 that it was actually passed by invisible reference. */
3519 code = DBX_REGPARM_STABS_CODE;
3521 /* GDB likes this marked with a special letter. */
3522 letter = (use_gnu_debug_info_extensions
3523 ? 'a' : DBX_REGPARM_STABS_LETTER);
3524 eff_type = TREE_TYPE (parms);
3526 /* DECL_RTL looks like (MEM (REG...). Get the register number.
3527 If it is an unallocated pseudo-reg, then use the register where
3528 it was passed instead.
3529 ??? Why is DBX_REGISTER_NUMBER not used here? */
3531 if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
3532 number = REGNO (XEXP (DECL_RTL (parms), 0));
3533 else
3534 number = REGNO (DECL_INCOMING_RTL (parms));
3536 else if (MEM_P (DECL_RTL (parms))
3537 && MEM_P (XEXP (DECL_RTL (parms), 0)))
3539 /* Parm was passed via invisible reference, with the reference
3540 living on the stack. DECL_RTL looks like
3541 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3542 could look like (MEM (MEM (REG))). */
3544 code = N_PSYM;
3545 letter = 'v';
3546 eff_type = TREE_TYPE (parms);
3548 if (!REG_P (XEXP (XEXP (DECL_RTL (parms), 0), 0)))
3549 number = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
3550 else
3551 number = 0;
3553 number = DEBUGGER_ARG_OFFSET (number,
3554 XEXP (XEXP (DECL_RTL (parms), 0), 0));
3556 else if (MEM_P (DECL_RTL (parms))
3557 && XEXP (DECL_RTL (parms), 0) != const0_rtx
3558 /* ??? A constant address for a parm can happen
3559 when the reg it lives in is equiv to a constant in memory.
3560 Should make this not happen, after 2.4. */
3561 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
3563 /* Parm was passed in registers but lives on the stack. */
3565 code = N_PSYM;
3566 letter = 'p';
3567 eff_type = TREE_TYPE (parms);
3569 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3570 in which case we want the value of that CONST_INT,
3571 or (MEM (REG ...)),
3572 in which case we use a value of zero. */
3573 if (!REG_P (XEXP (DECL_RTL (parms), 0)))
3574 number = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
3575 else
3576 number = 0;
3578 /* Make a big endian correction if the mode of the type of the
3579 parameter is not the same as the mode of the rtl. */
3580 if (BYTES_BIG_ENDIAN
3581 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
3582 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
3583 number += (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
3584 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))));
3586 else
3587 /* ??? We don't know how to represent this argument. */
3588 continue;
3590 dbxout_begin_complex_stabs ();
3592 if (DECL_NAME (parms))
3594 stabstr_I (DECL_NAME (parms));
3595 stabstr_C (':');
3597 else
3598 stabstr_S ("(anon):");
3599 stabstr_C (letter);
3600 dbxout_type (eff_type, 0);
3601 dbxout_finish_complex_stabs (parms, code, 0, 0, number);
3603 DBXOUT_DECR_NESTING;
3606 /* Output definitions for the places where parms live during the function,
3607 when different from where they were passed, when the parms were passed
3608 in memory.
3610 It is not useful to do this for parms passed in registers
3611 that live during the function in different registers, because it is
3612 impossible to look in the passed register for the passed value,
3613 so we use the within-the-function register to begin with.
3615 PARMS is a chain of PARM_DECL nodes. */
3617 void
3618 dbxout_reg_parms (tree parms)
3620 ++debug_nesting;
3622 for (; parms; parms = DECL_CHAIN (parms))
3623 if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
3625 /* Report parms that live in registers during the function
3626 but were passed in memory. */
3627 if (REG_P (DECL_RTL (parms))
3628 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
3629 dbxout_symbol_location (parms, TREE_TYPE (parms),
3630 0, DECL_RTL (parms));
3631 else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
3632 dbxout_symbol_location (parms, TREE_TYPE (parms),
3633 0, DECL_RTL (parms));
3634 /* Report parms that live in memory but not where they were passed. */
3635 else if (MEM_P (DECL_RTL (parms))
3636 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
3637 dbxout_symbol_location (parms, TREE_TYPE (parms),
3638 0, DECL_RTL (parms));
3640 DBXOUT_DECR_NESTING;
3643 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
3644 output definitions of those names, in raw form */
3646 static void
3647 dbxout_args (tree args)
3649 while (args)
3651 stabstr_C (',');
3652 dbxout_type (TREE_VALUE (args), 0);
3653 args = TREE_CHAIN (args);
3657 #if defined (DBX_DEBUGGING_INFO)
3659 /* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
3660 BEGIN_LABEL is the name of the beginning of the function, which may
3661 be required. */
3662 static void
3663 dbx_output_lbrac (const char *label,
3664 const char *begin_label ATTRIBUTE_UNUSED)
3666 dbxout_begin_stabn (N_LBRAC);
3667 if (DBX_BLOCKS_FUNCTION_RELATIVE)
3668 dbxout_stab_value_label_diff (label, begin_label);
3669 else
3670 dbxout_stab_value_label (label);
3673 /* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
3674 BEGIN_LABEL is the name of the beginning of the function, which may
3675 be required. */
3676 static void
3677 dbx_output_rbrac (const char *label,
3678 const char *begin_label ATTRIBUTE_UNUSED)
3680 dbxout_begin_stabn (N_RBRAC);
3681 if (DBX_BLOCKS_FUNCTION_RELATIVE)
3682 dbxout_stab_value_label_diff (label, begin_label);
3683 else
3684 dbxout_stab_value_label (label);
3687 /* Output everything about a symbol block (a BLOCK node
3688 that represents a scope level),
3689 including recursive output of contained blocks.
3691 BLOCK is the BLOCK node.
3692 DEPTH is its depth within containing symbol blocks.
3693 ARGS is usually zero; but for the outermost block of the
3694 body of a function, it is a chain of PARM_DECLs for the function parameters.
3695 We output definitions of all the register parms
3696 as if they were local variables of that block.
3698 If -g1 was used, we count blocks just the same, but output nothing
3699 except for the outermost block.
3701 Actually, BLOCK may be several blocks chained together.
3702 We handle them all in sequence. */
3704 static void
3705 dbxout_block (tree block, int depth, tree args)
3707 char begin_label[20];
3708 /* Reference current function start using LFBB. */
3709 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
3711 while (block)
3713 /* Ignore blocks never expanded or otherwise marked as real. */
3714 if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
3716 int did_output;
3717 int blocknum = BLOCK_NUMBER (block);
3719 /* In dbx format, the syms of a block come before the N_LBRAC.
3720 If nothing is output, we don't need the N_LBRAC, either. */
3721 did_output = 0;
3722 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
3723 did_output = dbxout_syms (BLOCK_VARS (block));
3724 if (args)
3725 dbxout_reg_parms (args);
3727 /* Now output an N_LBRAC symbol to represent the beginning of
3728 the block. Use the block's tree-walk order to generate
3729 the assembler symbols LBBn and LBEn
3730 that final will define around the code in this block. */
3731 if (did_output)
3733 char buf[20];
3734 const char *scope_start;
3736 if (depth == 0)
3737 /* The outermost block doesn't get LBB labels; use
3738 the LFBB local symbol emitted by dbxout_begin_prologue. */
3739 scope_start = begin_label;
3740 else
3742 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
3743 scope_start = buf;
3746 dbx_output_lbrac (scope_start, begin_label);
3749 /* Output the subblocks. */
3750 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
3752 /* Refer to the marker for the end of the block. */
3753 if (did_output)
3755 char buf[100];
3756 if (depth == 0)
3757 /* The outermost block doesn't get LBE labels;
3758 use the "scope" label which will be emitted
3759 by dbxout_function_end. */
3760 ASM_GENERATE_INTERNAL_LABEL (buf, "Lscope", scope_labelno);
3761 else
3762 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
3764 dbx_output_rbrac (buf, begin_label);
3767 block = BLOCK_CHAIN (block);
3771 /* Output the information about a function and its arguments and result.
3772 Usually this follows the function's code,
3773 but on some systems, it comes before. */
3775 static void
3776 dbxout_begin_function (tree decl)
3778 int saved_tree_used1;
3780 saved_tree_used1 = TREE_USED (decl);
3781 TREE_USED (decl) = 1;
3782 if (DECL_NAME (DECL_RESULT (decl)) != 0)
3784 int saved_tree_used2 = TREE_USED (DECL_RESULT (decl));
3785 TREE_USED (DECL_RESULT (decl)) = 1;
3786 dbxout_symbol (decl, 0);
3787 TREE_USED (DECL_RESULT (decl)) = saved_tree_used2;
3789 else
3790 dbxout_symbol (decl, 0);
3791 TREE_USED (decl) = saved_tree_used1;
3793 dbxout_parms (DECL_ARGUMENTS (decl));
3794 if (DECL_NAME (DECL_RESULT (decl)) != 0)
3795 dbxout_symbol (DECL_RESULT (decl), 1);
3797 #endif /* DBX_DEBUGGING_INFO */
3799 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3801 /* Record an element in the table of global destructors. SYMBOL is
3802 a SYMBOL_REF of the function to be called; PRIORITY is a number
3803 between 0 and MAX_INIT_PRIORITY. */
3805 void
3806 default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED,
3807 int priority ATTRIBUTE_UNUSED)
3809 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
3810 /* Tell GNU LD that this is part of the static destructor set.
3811 This will work for any system that uses stabs, most usefully
3812 aout systems. */
3813 dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
3814 dbxout_stab_value_label (XSTR (symbol, 0));
3815 #else
3816 sorry ("global destructors not supported on this target");
3817 #endif
3820 /* Likewise for global constructors. */
3822 void
3823 default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED,
3824 int priority ATTRIBUTE_UNUSED)
3826 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
3827 /* Tell GNU LD that this is part of the static destructor set.
3828 This will work for any system that uses stabs, most usefully
3829 aout systems. */
3830 dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
3831 dbxout_stab_value_label (XSTR (symbol, 0));
3832 #else
3833 sorry ("global constructors not supported on this target");
3834 #endif
3837 #include "gt-dbxout.h"