[AArch64][14/14] Reuse target_option_current_node when passing pragma string to targe...
[official-gcc.git] / gcc / dbxout.c
bloba55d1025f9c9a35ae97c7b0e31f28bbe5ce6ca41
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 "alias.h"
74 #include "tree.h"
75 #include "fold-const.h"
76 #include "varasm.h"
77 #include "stor-layout.h"
78 #include "rtl.h"
79 #include "flags.h"
80 #include "regs.h"
81 #include "insn-config.h"
82 #include "reload.h"
83 #include "output.h"
84 #include "dbxout.h"
85 #include "diagnostic-core.h"
86 #include "toplev.h"
87 #include "tm_p.h"
88 #include "debug.h"
89 #include "function.h"
90 #include "target.h"
91 #include "common/common-target.h"
92 #include "langhooks.h"
93 #include "obstack.h"
94 #include "expmed.h"
95 #include "dojump.h"
96 #include "explow.h"
97 #include "calls.h"
98 #include "emit-rtl.h"
99 #include "stmt.h"
100 #include "expr.h"
101 #include "cgraph.h"
102 #include "stringpool.h"
104 #ifdef XCOFF_DEBUGGING_INFO
105 #include "xcoffout.h"
106 #endif
108 #ifndef ASM_STABS_OP
109 # ifdef XCOFF_DEBUGGING_INFO
110 # define ASM_STABS_OP "\t.stabx\t"
111 # else
112 # define ASM_STABS_OP "\t.stabs\t"
113 # endif
114 #endif
116 #ifndef ASM_STABN_OP
117 #define ASM_STABN_OP "\t.stabn\t"
118 #endif
120 #ifndef ASM_STABD_OP
121 #define ASM_STABD_OP "\t.stabd\t"
122 #endif
124 #ifndef DBX_TYPE_DECL_STABS_CODE
125 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
126 #endif
128 #ifndef DBX_STATIC_CONST_VAR_CODE
129 #define DBX_STATIC_CONST_VAR_CODE N_FUN
130 #endif
132 #ifndef DBX_REGPARM_STABS_CODE
133 #define DBX_REGPARM_STABS_CODE N_RSYM
134 #endif
136 #ifndef DBX_REGPARM_STABS_LETTER
137 #define DBX_REGPARM_STABS_LETTER 'P'
138 #endif
140 #ifndef NO_DBX_FUNCTION_END
141 #define NO_DBX_FUNCTION_END 0
142 #endif
144 #ifndef NO_DBX_BNSYM_ENSYM
145 #define NO_DBX_BNSYM_ENSYM 0
146 #endif
148 #ifndef NO_DBX_MAIN_SOURCE_DIRECTORY
149 #define NO_DBX_MAIN_SOURCE_DIRECTORY 0
150 #endif
152 #ifndef DBX_BLOCKS_FUNCTION_RELATIVE
153 #define DBX_BLOCKS_FUNCTION_RELATIVE 0
154 #endif
156 #ifndef DBX_LINES_FUNCTION_RELATIVE
157 #define DBX_LINES_FUNCTION_RELATIVE 0
158 #endif
160 #ifndef DBX_CONTIN_LENGTH
161 #define DBX_CONTIN_LENGTH 80
162 #endif
164 #ifndef DBX_CONTIN_CHAR
165 #define DBX_CONTIN_CHAR '\\'
166 #endif
168 enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
170 /* Structure recording information about a C data type.
171 The status element says whether we have yet output
172 the definition of the type. TYPE_XREF says we have
173 output it as a cross-reference only.
174 The file_number and type_number elements are used if DBX_USE_BINCL
175 is defined. */
177 struct GTY(()) typeinfo {
178 enum typestatus status;
179 int file_number;
180 int type_number;
183 /* Vector recording information about C data types.
184 When we first notice a data type (a tree node),
185 we assign it a number using next_type_number.
186 That is its index in this vector. */
188 static GTY ((length ("typevec_len"))) struct typeinfo *typevec;
190 /* Number of elements of space allocated in `typevec'. */
192 static GTY(()) int typevec_len;
194 /* In dbx output, each type gets a unique number.
195 This is the number for the next type output.
196 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
198 static GTY(()) int next_type_number;
200 /* The C front end may call dbxout_symbol before dbxout_init runs.
201 We save all such decls in this list and output them when we get
202 to dbxout_init. */
204 static GTY(()) tree preinit_symbols;
206 enum binclstatus {BINCL_NOT_REQUIRED, BINCL_PENDING, BINCL_PROCESSED};
208 /* When using N_BINCL in dbx output, each type number is actually a
209 pair of the file number and the type number within the file.
210 This is a stack of input files. */
212 struct dbx_file
214 struct dbx_file *next;
215 int file_number;
216 int next_type_number;
217 enum binclstatus bincl_status; /* Keep track of lazy bincl. */
218 const char *pending_bincl_name; /* Name of bincl. */
219 struct dbx_file *prev; /* Chain to traverse all pending bincls. */
222 /* This is the top of the stack.
224 This is not saved for PCH, because restoring a PCH should not change it.
225 next_file_number does have to be saved, because the PCH may use some
226 file numbers; however, just before restoring a PCH, next_file_number
227 should always be 0 because we should not have needed any file numbers
228 yet. */
230 #if (defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)) \
231 && defined (DBX_USE_BINCL)
232 static struct dbx_file *current_file;
233 #endif
235 /* This is the next file number to use. */
237 static GTY(()) int next_file_number;
239 /* A counter for dbxout_function_end. */
241 static GTY(()) int scope_labelno;
243 /* A counter for dbxout_source_line. */
245 static GTY(()) int dbxout_source_line_counter;
247 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
248 for the N_SO filename stabs label. */
250 static GTY(()) int source_label_number = 1;
252 /* Last source file name mentioned in a NOTE insn. */
254 static GTY(()) const char *lastfile;
256 /* Used by PCH machinery to detect if 'lastfile' should be reset to
257 base_input_file. */
258 static GTY(()) int lastfile_is_base;
260 /* Typical USG systems don't have stab.h, and they also have
261 no use for DBX-format debugging info. */
263 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
265 #ifdef DBX_USE_BINCL
266 /* If zero then there is no pending BINCL. */
267 static int pending_bincls = 0;
268 #endif
270 /* The original input file name. */
271 static const char *base_input_file;
273 #ifdef DEBUG_SYMS_TEXT
274 #define FORCE_TEXT switch_to_section (current_function_section ())
275 #else
276 #define FORCE_TEXT
277 #endif
279 #include "gstab.h"
281 /* 1 if PARM is passed to this function in memory. */
283 #define PARM_PASSED_IN_MEMORY(PARM) \
284 (MEM_P (DECL_INCOMING_RTL (PARM)))
286 /* A C expression for the integer offset value of an automatic variable
287 (N_LSYM) having address X (an RTX). */
288 #ifndef DEBUGGER_AUTO_OFFSET
289 #define DEBUGGER_AUTO_OFFSET(X) \
290 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
291 #endif
293 /* A C expression for the integer offset value of an argument (N_PSYM)
294 having address X (an RTX). The nominal offset is OFFSET.
295 Note that we use OFFSET + 0 here to avoid the self-assign warning
296 when the macro is called in a context like
297 number = DEBUGGER_ARG_OFFSET(number, X) */
298 #ifndef DEBUGGER_ARG_OFFSET
299 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET + 0)
300 #endif
302 /* This obstack holds the stab string currently being constructed. We
303 build it up here, then write it out, so we can split long lines up
304 properly (see dbxout_finish_complex_stabs). */
305 static struct obstack stabstr_ob;
306 static size_t stabstr_last_contin_point;
308 #ifdef DBX_USE_BINCL
309 static void emit_bincl_stab (const char *c);
310 static void emit_pending_bincls (void);
311 #endif
312 static inline void emit_pending_bincls_if_required (void);
314 static void dbxout_init (const char *);
316 static void dbxout_finish (const char *);
317 static void dbxout_start_source_file (unsigned, const char *);
318 static void dbxout_end_source_file (unsigned);
319 static void dbxout_typedefs (tree);
320 static void dbxout_type_index (tree);
321 static void dbxout_args (tree);
322 static void dbxout_type_fields (tree);
323 static void dbxout_type_method_1 (tree);
324 static void dbxout_type_methods (tree);
325 static void dbxout_range_type (tree, tree, tree);
326 static void dbxout_type (tree, int);
327 static bool print_int_cst_bounds_in_octal_p (tree, tree, tree);
328 static bool is_fortran (void);
329 static void dbxout_type_name (tree);
330 static void dbxout_class_name_qualifiers (tree);
331 static int dbxout_symbol_location (tree, tree, const char *, rtx);
332 static void dbxout_symbol_name (tree, const char *, int);
333 static void dbxout_common_name (tree, const char *, stab_code_type);
334 static const char *dbxout_common_check (tree, int *);
335 static void dbxout_early_global_decl (tree);
336 static void dbxout_late_global_decl (tree);
337 static void dbxout_type_decl (tree, int);
338 static void dbxout_handle_pch (unsigned);
339 static void debug_free_queue (void);
341 /* The debug hooks structure. */
342 #if defined (DBX_DEBUGGING_INFO)
344 static void dbxout_source_line (unsigned int, const char *, int, bool);
345 static void dbxout_begin_prologue (unsigned int, const char *);
346 static void dbxout_source_file (const char *);
347 static void dbxout_function_end (tree);
348 static void dbxout_begin_function (tree);
349 static void dbxout_begin_block (unsigned, unsigned);
350 static void dbxout_end_block (unsigned, unsigned);
351 static void dbxout_function_decl (tree);
353 const struct gcc_debug_hooks dbx_debug_hooks =
355 dbxout_init,
356 dbxout_finish,
357 debug_nothing_void,
358 debug_nothing_void,
359 debug_nothing_int_charstar,
360 debug_nothing_int_charstar,
361 dbxout_start_source_file,
362 dbxout_end_source_file,
363 dbxout_begin_block,
364 dbxout_end_block,
365 debug_true_const_tree, /* ignore_block */
366 dbxout_source_line, /* source_line */
367 dbxout_begin_prologue, /* begin_prologue */
368 debug_nothing_int_charstar, /* end_prologue */
369 debug_nothing_int_charstar, /* begin_epilogue */
370 debug_nothing_int_charstar, /* end_epilogue */
371 #ifdef DBX_FUNCTION_FIRST
372 dbxout_begin_function,
373 #else
374 debug_nothing_tree, /* begin_function */
375 #endif
376 debug_nothing_int, /* end_function */
377 debug_nothing_tree, /* register_main_translation_unit */
378 dbxout_function_decl,
379 dbxout_early_global_decl, /* early_global_decl */
380 dbxout_late_global_decl, /* late_global_decl */
381 dbxout_type_decl, /* type_decl */
382 debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */
383 debug_nothing_tree, /* deferred_inline_function */
384 debug_nothing_tree, /* outlining_inline_function */
385 debug_nothing_rtx_code_label, /* label */
386 dbxout_handle_pch, /* handle_pch */
387 debug_nothing_rtx_insn, /* var_location */
388 debug_nothing_void, /* switch_text_section */
389 debug_nothing_tree_tree, /* set_name */
390 0, /* start_end_main_source_file */
391 TYPE_SYMTAB_IS_ADDRESS /* tree_type_symtab_field */
393 #endif /* DBX_DEBUGGING_INFO */
395 #if defined (XCOFF_DEBUGGING_INFO)
396 const struct gcc_debug_hooks xcoff_debug_hooks =
398 dbxout_init,
399 dbxout_finish,
400 debug_nothing_void,
401 debug_nothing_void,
402 debug_nothing_int_charstar,
403 debug_nothing_int_charstar,
404 dbxout_start_source_file,
405 dbxout_end_source_file,
406 xcoffout_begin_block,
407 xcoffout_end_block,
408 debug_true_const_tree, /* ignore_block */
409 xcoffout_source_line,
410 xcoffout_begin_prologue, /* begin_prologue */
411 debug_nothing_int_charstar, /* end_prologue */
412 debug_nothing_int_charstar, /* begin_epilogue */
413 xcoffout_end_epilogue,
414 debug_nothing_tree, /* begin_function */
415 xcoffout_end_function,
416 debug_nothing_tree, /* register_main_translation_unit */
417 debug_nothing_tree, /* function_decl */
418 dbxout_early_global_decl, /* early_global_decl */
419 dbxout_late_global_decl, /* late_global_decl */
420 dbxout_type_decl, /* type_decl */
421 debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */
422 debug_nothing_tree, /* deferred_inline_function */
423 debug_nothing_tree, /* outlining_inline_function */
424 debug_nothing_rtx_code_label, /* label */
425 dbxout_handle_pch, /* handle_pch */
426 debug_nothing_rtx_insn, /* var_location */
427 debug_nothing_void, /* switch_text_section */
428 debug_nothing_tree_tree, /* set_name */
429 0, /* start_end_main_source_file */
430 TYPE_SYMTAB_IS_ADDRESS /* tree_type_symtab_field */
432 #endif /* XCOFF_DEBUGGING_INFO */
434 /* Numeric formatting helper macro. Note that this does not handle
435 hexadecimal. */
436 #define NUMBER_FMT_LOOP(P, NUM, BASE) \
437 do \
439 int digit = NUM % BASE; \
440 NUM /= BASE; \
441 *--P = digit + '0'; \
443 while (NUM > 0)
445 /* Utility: write a decimal integer NUM to asm_out_file. */
446 void
447 dbxout_int (int num)
449 char buf[64];
450 char *p = buf + sizeof buf;
451 unsigned int unum;
453 if (num == 0)
455 putc ('0', asm_out_file);
456 return;
458 if (num < 0)
460 putc ('-', asm_out_file);
461 unum = -num;
463 else
464 unum = num;
466 NUMBER_FMT_LOOP (p, unum, 10);
468 while (p < buf + sizeof buf)
470 putc (*p, asm_out_file);
471 p++;
476 /* Primitives for emitting simple stabs directives. All other stabs
477 routines should use these functions instead of directly emitting
478 stabs. They are exported because machine-dependent code may need
479 to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
480 forwards to code in CPU.c. */
482 /* The following functions should all be called immediately after one
483 of the dbxout_begin_stab* functions (below). They write out
484 various things as the value of a stab. */
486 /* Write out a literal zero as the value of a stab. */
487 void
488 dbxout_stab_value_zero (void)
490 fputs ("0\n", asm_out_file);
493 /* Write out the label LABEL as the value of a stab. */
494 void
495 dbxout_stab_value_label (const char *label)
497 assemble_name (asm_out_file, label);
498 putc ('\n', asm_out_file);
501 /* Write out the difference of two labels, LABEL - BASE, as the value
502 of a stab. */
503 void
504 dbxout_stab_value_label_diff (const char *label, const char *base)
506 assemble_name (asm_out_file, label);
507 putc ('-', asm_out_file);
508 assemble_name (asm_out_file, base);
509 putc ('\n', asm_out_file);
512 /* Write out an internal label as the value of a stab, and immediately
513 emit that internal label. This should be used only when
514 dbxout_stabd will not work. STEM is the name stem of the label,
515 COUNTERP is a pointer to a counter variable which will be used to
516 guarantee label uniqueness. */
517 void
518 dbxout_stab_value_internal_label (const char *stem, int *counterp)
520 char label[100];
521 int counter = counterp ? (*counterp)++ : 0;
523 ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
524 dbxout_stab_value_label (label);
525 targetm.asm_out.internal_label (asm_out_file, stem, counter);
528 /* Write out the difference between BASE and an internal label as the
529 value of a stab, and immediately emit that internal label. STEM and
530 COUNTERP are as for dbxout_stab_value_internal_label. */
531 void
532 dbxout_stab_value_internal_label_diff (const char *stem, int *counterp,
533 const char *base)
535 char label[100];
536 int counter = counterp ? (*counterp)++ : 0;
538 ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
539 dbxout_stab_value_label_diff (label, base);
540 targetm.asm_out.internal_label (asm_out_file, stem, counter);
543 /* The following functions produce specific kinds of stab directives. */
545 /* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file. */
546 void
547 dbxout_stabd (int stype, int sdesc)
549 fputs (ASM_STABD_OP, asm_out_file);
550 dbxout_int (stype);
551 fputs (",0,", asm_out_file);
552 dbxout_int (sdesc);
553 putc ('\n', asm_out_file);
556 /* Write a .stabn directive with type STYPE. This function stops
557 short of emitting the value field, which is the responsibility of
558 the caller (normally it will be either a symbol or the difference
559 of two symbols). */
561 void
562 dbxout_begin_stabn (int stype)
564 fputs (ASM_STABN_OP, asm_out_file);
565 dbxout_int (stype);
566 fputs (",0,0,", asm_out_file);
569 /* Write a .stabn directive with type N_SLINE and desc LINE. As above,
570 the value field is the responsibility of the caller. */
571 void
572 dbxout_begin_stabn_sline (int lineno)
574 fputs (ASM_STABN_OP, asm_out_file);
575 dbxout_int (N_SLINE);
576 fputs (",0,", asm_out_file);
577 dbxout_int (lineno);
578 putc (',', asm_out_file);
581 /* Begin a .stabs directive with string "", type STYPE, and desc and
582 other fields 0. The value field is the responsibility of the
583 caller. This function cannot be used for .stabx directives. */
584 void
585 dbxout_begin_empty_stabs (int stype)
587 fputs (ASM_STABS_OP, asm_out_file);
588 fputs ("\"\",", asm_out_file);
589 dbxout_int (stype);
590 fputs (",0,0,", asm_out_file);
593 /* Begin a .stabs directive with string STR, type STYPE, and desc 0.
594 The value field is the responsibility of the caller. */
595 void
596 dbxout_begin_simple_stabs (const char *str, int stype)
598 fputs (ASM_STABS_OP, asm_out_file);
599 output_quoted_string (asm_out_file, str);
600 putc (',', asm_out_file);
601 dbxout_int (stype);
602 fputs (",0,0,", asm_out_file);
605 /* As above but use SDESC for the desc field. */
606 void
607 dbxout_begin_simple_stabs_desc (const char *str, int stype, int sdesc)
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,", asm_out_file);
614 dbxout_int (sdesc);
615 putc (',', asm_out_file);
618 /* The next set of functions are entirely concerned with production of
619 "complex" .stabs directives: that is, .stabs directives whose
620 strings have to be constructed piecemeal. dbxout_type,
621 dbxout_symbol, etc. use these routines heavily. The string is queued
622 up in an obstack, then written out by dbxout_finish_complex_stabs, which
623 is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
624 (You might think it would be more efficient to go straight to stdio
625 when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
626 out not to be the case, and anyway this needs fewer #ifdefs.) */
628 /* Begin a complex .stabs directive. If we can, write the initial
629 ASM_STABS_OP to the asm_out_file. */
631 static void
632 dbxout_begin_complex_stabs (void)
634 emit_pending_bincls_if_required ();
635 FORCE_TEXT;
636 fputs (ASM_STABS_OP, asm_out_file);
637 putc ('"', asm_out_file);
638 gcc_assert (stabstr_last_contin_point == 0);
641 /* As above, but do not force text or emit pending bincls. This is
642 used by dbxout_symbol_location, which needs to do something else. */
643 static void
644 dbxout_begin_complex_stabs_noforcetext (void)
646 fputs (ASM_STABS_OP, asm_out_file);
647 putc ('"', asm_out_file);
648 gcc_assert (stabstr_last_contin_point == 0);
651 /* Add CHR, a single character, to the string being built. */
652 #define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
654 /* Add STR, a normal C string, to the string being built. */
655 #define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen (str))
657 /* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */
658 #define stabstr_I(id) obstack_grow (&stabstr_ob, \
659 IDENTIFIER_POINTER (id), \
660 IDENTIFIER_LENGTH (id))
662 /* Add NUM, a signed decimal number, to the string being built. */
663 static void
664 stabstr_D (HOST_WIDE_INT num)
666 char buf[64];
667 char *p = buf + sizeof buf;
668 unsigned int unum;
670 if (num == 0)
672 stabstr_C ('0');
673 return;
675 if (num < 0)
677 stabstr_C ('-');
678 unum = -num;
680 else
681 unum = num;
683 NUMBER_FMT_LOOP (p, unum, 10);
685 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
688 /* Add NUM, an unsigned decimal number, to the string being built. */
689 static void
690 stabstr_U (unsigned HOST_WIDE_INT num)
692 char buf[64];
693 char *p = buf + sizeof buf;
694 if (num == 0)
696 stabstr_C ('0');
697 return;
699 NUMBER_FMT_LOOP (p, num, 10);
700 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
703 /* Add CST, an INTEGER_CST tree, to the string being built as an
704 unsigned octal number. This routine handles values which are
705 larger than a single HOST_WIDE_INT. */
706 static void
707 stabstr_O (tree cst)
709 int prec = TYPE_PRECISION (TREE_TYPE (cst));
710 int res_pres = prec % 3;
711 int i;
712 unsigned int digit;
714 /* Leading zero for base indicator. */
715 stabstr_C ('0');
717 /* If the value is zero, the base indicator will serve as the value
718 all by itself. */
719 if (wi::eq_p (cst, 0))
720 return;
722 /* GDB wants constants with no extra leading "1" bits, so
723 we need to remove any sign-extension that might be
724 present. */
725 if (res_pres == 1)
727 digit = wi::extract_uhwi (cst, prec - 1, 1);
728 stabstr_C ('0' + digit);
730 else if (res_pres == 2)
732 digit = wi::extract_uhwi (cst, prec - 2, 2);
733 stabstr_C ('0' + digit);
736 prec -= res_pres;
737 for (i = prec - 3; i >= 0; i = i - 3)
739 digit = wi::extract_uhwi (cst, i, 3);
740 stabstr_C ('0' + digit);
744 /* Called whenever it is safe to break a stabs string into multiple
745 .stabs directives. If the current string has exceeded the limit
746 set by DBX_CONTIN_LENGTH, mark the current position in the buffer
747 as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
748 it is a backslash) and a null character. */
749 static inline void
750 stabstr_continue (void)
752 if (DBX_CONTIN_LENGTH > 0
753 && obstack_object_size (&stabstr_ob) - stabstr_last_contin_point
754 > DBX_CONTIN_LENGTH)
756 if (DBX_CONTIN_CHAR == '\\')
757 obstack_1grow (&stabstr_ob, '\\');
758 obstack_1grow (&stabstr_ob, DBX_CONTIN_CHAR);
759 obstack_1grow (&stabstr_ob, '\0');
760 stabstr_last_contin_point = obstack_object_size (&stabstr_ob);
763 #define CONTIN stabstr_continue ()
765 /* Macro subroutine of dbxout_finish_complex_stabs, which emits
766 all of the arguments to the .stabs directive after the string.
767 Overridden by xcoffout.h. CODE is the stabs code for this symbol;
768 LINE is the source line to write into the desc field (in extended
769 mode); SYM is the symbol itself.
771 ADDR, LABEL, and NUMBER are three different ways to represent the
772 stabs value field. At most one of these should be nonzero.
774 ADDR is used most of the time; it represents the value as an
775 RTL address constant.
777 LABEL is used (currently) only for N_CATCH stabs; it represents
778 the value as a string suitable for assemble_name.
780 NUMBER is used when the value is an offset from an implicit base
781 pointer (e.g. for a stack variable), or an index (e.g. for a
782 register variable). It represents the value as a decimal integer. */
784 #ifndef DBX_FINISH_STABS
785 #define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER) \
786 do { \
787 int line_ = use_gnu_debug_info_extensions ? LINE : 0; \
789 dbxout_int (CODE); \
790 fputs (",0,", asm_out_file); \
791 dbxout_int (line_); \
792 putc (',', asm_out_file); \
793 if (ADDR) \
794 output_addr_const (asm_out_file, ADDR); \
795 else if (LABEL) \
796 assemble_name (asm_out_file, LABEL); \
797 else \
798 dbxout_int (NUMBER); \
799 putc ('\n', asm_out_file); \
800 } while (0)
801 #endif
803 /* Finish the emission of a complex .stabs directive. When DBX_CONTIN_LENGTH
804 is zero, this has only to emit the close quote and the remainder of
805 the arguments. When it is nonzero, the string has been marshalled in
806 stabstr_ob, and this routine is responsible for breaking it up into
807 DBX_CONTIN_LENGTH-sized chunks.
809 SYM is the DECL of the symbol under consideration; it is used only
810 for its DECL_SOURCE_LINE. The other arguments are all passed directly
811 to DBX_FINISH_STABS; see above for details. */
813 static void
814 dbxout_finish_complex_stabs (tree sym, stab_code_type code,
815 rtx addr, const char *label, int number)
817 int line ATTRIBUTE_UNUSED;
818 char *str;
819 size_t len;
821 line = sym ? DECL_SOURCE_LINE (sym) : 0;
822 if (DBX_CONTIN_LENGTH > 0)
824 char *chunk;
825 size_t chunklen;
827 /* Nul-terminate the growing string, then get its size and
828 address. */
829 obstack_1grow (&stabstr_ob, '\0');
831 len = obstack_object_size (&stabstr_ob);
832 chunk = str = XOBFINISH (&stabstr_ob, char *);
834 /* Within the buffer are a sequence of NUL-separated strings,
835 each of which is to be written out as a separate stab
836 directive. */
837 for (;;)
839 chunklen = strlen (chunk);
840 fwrite (chunk, 1, chunklen, asm_out_file);
841 fputs ("\",", asm_out_file);
843 /* Must add an extra byte to account for the NUL separator. */
844 chunk += chunklen + 1;
845 len -= chunklen + 1;
847 /* Only put a line number on the last stab in the sequence. */
848 DBX_FINISH_STABS (sym, code, len == 0 ? line : 0,
849 addr, label, number);
850 if (len == 0)
851 break;
853 fputs (ASM_STABS_OP, asm_out_file);
854 putc ('"', asm_out_file);
856 stabstr_last_contin_point = 0;
858 else
860 /* No continuations - we can put the whole string out at once.
861 It is faster to augment the string with the close quote and
862 comma than to do a two-character fputs. */
863 obstack_grow (&stabstr_ob, "\",", 2);
864 len = obstack_object_size (&stabstr_ob);
865 str = XOBFINISH (&stabstr_ob, char *);
867 fwrite (str, 1, len, asm_out_file);
868 DBX_FINISH_STABS (sym, code, line, addr, label, number);
870 obstack_free (&stabstr_ob, str);
873 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
875 /* When -gused is used, emit debug info for only used symbols. But in
876 addition to the standard intercepted debug_hooks there are some
877 direct calls into this file, i.e., dbxout_symbol, dbxout_parms, and
878 dbxout_reg_params. Those routines may also be called from a higher
879 level intercepted routine. So to prevent recording data for an inner
880 call to one of these for an intercept, we maintain an intercept
881 nesting counter (debug_nesting). We only save the intercepted
882 arguments if the nesting is 1. */
883 static int debug_nesting = 0;
885 static tree *symbol_queue;
886 static int symbol_queue_index = 0;
887 static int symbol_queue_size = 0;
889 #define DBXOUT_DECR_NESTING \
890 if (--debug_nesting == 0 && symbol_queue_index > 0) \
891 { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
893 #define DBXOUT_DECR_NESTING_AND_RETURN(x) \
894 do {--debug_nesting; return (x);} while (0)
896 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
898 #if defined (DBX_DEBUGGING_INFO)
900 static void
901 dbxout_function_end (tree decl ATTRIBUTE_UNUSED)
903 char lscope_label_name[100];
905 /* The Lscope label must be emitted even if we aren't doing anything
906 else; dbxout_block needs it. */
907 switch_to_section (function_section (current_function_decl));
909 /* Convert Lscope into the appropriate format for local labels in case
910 the system doesn't insert underscores in front of user generated
911 labels. */
912 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
913 targetm.asm_out.internal_label (asm_out_file, "Lscope", scope_labelno);
915 /* The N_FUN tag at the end of the function is a GNU extension,
916 which may be undesirable, and is unnecessary if we do not have
917 named sections. */
918 if (!use_gnu_debug_info_extensions
919 || NO_DBX_FUNCTION_END
920 || !targetm_common.have_named_sections)
921 return;
923 /* By convention, GCC will mark the end of a function with an N_FUN
924 symbol and an empty string. */
925 if (flag_reorder_blocks_and_partition)
927 dbxout_begin_empty_stabs (N_FUN);
928 dbxout_stab_value_label_diff (crtl->subsections.hot_section_end_label,
929 crtl->subsections.hot_section_label);
930 dbxout_begin_empty_stabs (N_FUN);
931 dbxout_stab_value_label_diff (crtl->subsections.cold_section_end_label,
932 crtl->subsections.cold_section_label);
934 else
936 char begin_label[20];
937 /* Reference current function start using LFBB. */
938 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
939 dbxout_begin_empty_stabs (N_FUN);
940 dbxout_stab_value_label_diff (lscope_label_name, begin_label);
943 if (!NO_DBX_BNSYM_ENSYM && !flag_debug_only_used_symbols)
944 dbxout_stabd (N_ENSYM, 0);
946 #endif /* DBX_DEBUGGING_INFO */
948 /* Get lang description for N_SO stab. */
949 static unsigned int ATTRIBUTE_UNUSED
950 get_lang_number (void)
952 const char *language_string = lang_hooks.name;
953 if (lang_GNU_C ())
954 return N_SO_C;
955 else if (lang_GNU_CXX ())
956 return N_SO_CC;
957 else if (strcmp (language_string, "GNU F77") == 0)
958 return N_SO_FORTRAN;
959 else if (lang_GNU_Fortran ())
960 return N_SO_FORTRAN90; /* CHECKME */
961 else if (strcmp (language_string, "GNU Pascal") == 0)
962 return N_SO_PASCAL;
963 else if (strcmp (language_string, "GNU Objective-C") == 0)
964 return N_SO_OBJC;
965 else if (strcmp (language_string, "GNU Objective-C++") == 0)
966 return N_SO_OBJCPLUS;
967 else
968 return 0;
972 static bool
973 is_fortran (void)
975 unsigned int lang = get_lang_number ();
977 return (lang == N_SO_FORTRAN) || (lang == N_SO_FORTRAN90);
980 /* At the beginning of compilation, start writing the symbol table.
981 Initialize `typevec' and output the standard data types of C. */
983 static void
984 dbxout_init (const char *input_file_name)
986 char ltext_label_name[100];
987 bool used_ltext_label_name = false;
988 tree syms = lang_hooks.decls.getdecls ();
989 const char *mapped_name;
991 typevec_len = 100;
992 typevec = ggc_cleared_vec_alloc<typeinfo> (typevec_len);
994 /* stabstr_ob contains one string, which will be just fine with
995 1-byte alignment. */
996 obstack_specify_allocation (&stabstr_ob, 0, 1, xmalloc, free);
998 /* Convert Ltext into the appropriate format for local labels in case
999 the system doesn't insert underscores in front of user generated
1000 labels. */
1001 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
1003 /* Put the current working directory in an N_SO symbol. */
1004 if (use_gnu_debug_info_extensions && !NO_DBX_MAIN_SOURCE_DIRECTORY)
1006 static const char *cwd;
1008 if (!cwd)
1010 cwd = get_src_pwd ();
1011 if (cwd[0] == '\0')
1012 cwd = "/";
1013 else if (!IS_DIR_SEPARATOR (cwd[strlen (cwd) - 1]))
1014 cwd = concat (cwd, "/", NULL);
1015 cwd = remap_debug_filename (cwd);
1017 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
1018 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file, cwd);
1019 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1020 dbxout_begin_simple_stabs_desc (cwd, N_SO, get_lang_number ());
1021 dbxout_stab_value_label (ltext_label_name);
1022 used_ltext_label_name = true;
1023 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1026 mapped_name = remap_debug_filename (input_file_name);
1027 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
1028 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file, mapped_name);
1029 #else
1030 dbxout_begin_simple_stabs_desc (mapped_name, N_SO, get_lang_number ());
1031 dbxout_stab_value_label (ltext_label_name);
1032 used_ltext_label_name = true;
1033 #endif
1035 if (used_ltext_label_name)
1037 switch_to_section (text_section);
1038 targetm.asm_out.internal_label (asm_out_file, "Ltext", 0);
1041 /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
1042 The string used is historical. */
1043 #ifndef NO_DBX_GCC_MARKER
1044 dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT);
1045 dbxout_stab_value_zero ();
1046 #endif
1048 base_input_file = lastfile = input_file_name;
1050 next_type_number = 1;
1052 #ifdef DBX_USE_BINCL
1053 current_file = XNEW (struct dbx_file);
1054 current_file->next = NULL;
1055 current_file->file_number = 0;
1056 current_file->next_type_number = 1;
1057 next_file_number = 1;
1058 current_file->prev = NULL;
1059 current_file->bincl_status = BINCL_NOT_REQUIRED;
1060 current_file->pending_bincl_name = NULL;
1061 #endif
1063 /* Get all permanent types that have typedef names, and output them
1064 all, except for those already output. Some language front ends
1065 put these declarations in the top-level scope; some do not;
1066 the latter are responsible for calling debug_hooks->type_decl from
1067 their record_builtin_type function. */
1068 dbxout_typedefs (syms);
1070 if (preinit_symbols)
1072 tree t;
1073 for (t = nreverse (preinit_symbols); t; t = TREE_CHAIN (t))
1074 dbxout_symbol (TREE_VALUE (t), 0);
1075 preinit_symbols = 0;
1079 /* Output any typedef names for types described by TYPE_DECLs in SYMS. */
1081 static void
1082 dbxout_typedefs (tree syms)
1084 for (; syms != NULL_TREE; syms = DECL_CHAIN (syms))
1086 if (TREE_CODE (syms) == TYPE_DECL)
1088 tree type = TREE_TYPE (syms);
1089 if (TYPE_NAME (type)
1090 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1091 && COMPLETE_OR_VOID_TYPE_P (type)
1092 && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
1093 dbxout_symbol (TYPE_NAME (type), 0);
1098 #ifdef DBX_USE_BINCL
1099 /* Emit BINCL stab using given name. */
1100 static void
1101 emit_bincl_stab (const char *name)
1103 dbxout_begin_simple_stabs (name, N_BINCL);
1104 dbxout_stab_value_zero ();
1107 /* If there are pending bincls then it is time to emit all of them. */
1109 static inline void
1110 emit_pending_bincls_if_required (void)
1112 if (pending_bincls)
1113 emit_pending_bincls ();
1116 /* Emit all pending bincls. */
1118 static void
1119 emit_pending_bincls (void)
1121 struct dbx_file *f = current_file;
1123 /* Find first pending bincl. */
1124 while (f->bincl_status == BINCL_PENDING)
1125 f = f->next;
1127 /* Now emit all bincls. */
1128 f = f->prev;
1130 while (f)
1132 if (f->bincl_status == BINCL_PENDING)
1134 emit_bincl_stab (f->pending_bincl_name);
1136 /* Update file number and status. */
1137 f->file_number = next_file_number++;
1138 f->bincl_status = BINCL_PROCESSED;
1140 if (f == current_file)
1141 break;
1142 f = f->prev;
1145 /* All pending bincls have been emitted. */
1146 pending_bincls = 0;
1149 #else
1151 static inline void
1152 emit_pending_bincls_if_required (void) {}
1153 #endif
1155 /* Change to reading from a new source file. Generate a N_BINCL stab. */
1157 static void
1158 dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED,
1159 const char *filename ATTRIBUTE_UNUSED)
1161 #ifdef DBX_USE_BINCL
1162 struct dbx_file *n = XNEW (struct dbx_file);
1164 n->next = current_file;
1165 n->next_type_number = 1;
1166 /* Do not assign file number now.
1167 Delay it until we actually emit BINCL. */
1168 n->file_number = 0;
1169 n->prev = NULL;
1170 current_file->prev = n;
1171 n->bincl_status = BINCL_PENDING;
1172 n->pending_bincl_name = remap_debug_filename (filename);
1173 pending_bincls = 1;
1174 current_file = n;
1175 #endif
1178 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
1180 static void
1181 dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED)
1183 #ifdef DBX_USE_BINCL
1184 /* Emit EINCL stab only if BINCL is not pending. */
1185 if (current_file->bincl_status == BINCL_PROCESSED)
1187 dbxout_begin_stabn (N_EINCL);
1188 dbxout_stab_value_zero ();
1190 current_file->bincl_status = BINCL_NOT_REQUIRED;
1191 current_file = current_file->next;
1192 #endif
1195 /* Handle a few odd cases that occur when trying to make PCH files work. */
1197 static void
1198 dbxout_handle_pch (unsigned at_end)
1200 if (! at_end)
1202 /* When using the PCH, this file will be included, so we need to output
1203 a BINCL. */
1204 dbxout_start_source_file (0, lastfile);
1206 /* The base file when using the PCH won't be the same as
1207 the base file when it's being generated. */
1208 lastfile = NULL;
1210 else
1212 /* ... and an EINCL. */
1213 dbxout_end_source_file (0);
1215 /* Deal with cases where 'lastfile' was never actually changed. */
1216 lastfile_is_base = lastfile == NULL;
1220 #if defined (DBX_DEBUGGING_INFO)
1222 static void dbxout_block (tree, int, tree);
1224 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
1226 static void
1227 dbxout_source_file (const char *filename)
1229 if (lastfile == 0 && lastfile_is_base)
1231 lastfile = base_input_file;
1232 lastfile_is_base = 0;
1235 if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
1237 /* Don't change section amid function. */
1238 if (current_function_decl == NULL_TREE)
1239 switch_to_section (text_section);
1241 dbxout_begin_simple_stabs (remap_debug_filename (filename), N_SOL);
1242 dbxout_stab_value_internal_label ("Ltext", &source_label_number);
1243 lastfile = filename;
1247 /* Output N_BNSYM, line number symbol entry, and local symbol at
1248 function scope */
1250 static void
1251 dbxout_begin_prologue (unsigned int lineno, const char *filename)
1253 if (use_gnu_debug_info_extensions
1254 && !NO_DBX_FUNCTION_END
1255 && !NO_DBX_BNSYM_ENSYM
1256 && !flag_debug_only_used_symbols)
1257 dbxout_stabd (N_BNSYM, 0);
1259 /* pre-increment the scope counter */
1260 scope_labelno++;
1262 dbxout_source_line (lineno, filename, 0, true);
1263 /* Output function begin block at function scope, referenced
1264 by dbxout_block, dbxout_source_line and dbxout_function_end. */
1265 emit_pending_bincls_if_required ();
1266 targetm.asm_out.internal_label (asm_out_file, "LFBB", scope_labelno);
1269 /* Output a line number symbol entry for source file FILENAME and line
1270 number LINENO. */
1272 static void
1273 dbxout_source_line (unsigned int lineno, const char *filename,
1274 int discriminator ATTRIBUTE_UNUSED,
1275 bool is_stmt ATTRIBUTE_UNUSED)
1277 dbxout_source_file (filename);
1279 #ifdef DBX_OUTPUT_SOURCE_LINE
1280 DBX_OUTPUT_SOURCE_LINE (asm_out_file, lineno, dbxout_source_line_counter);
1281 #else
1282 if (DBX_LINES_FUNCTION_RELATIVE)
1284 char begin_label[20];
1285 dbxout_begin_stabn_sline (lineno);
1286 /* Reference current function start using LFBB. */
1287 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
1288 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter,
1289 begin_label);
1291 else
1292 dbxout_stabd (N_SLINE, lineno);
1293 #endif
1296 /* Describe the beginning of an internal block within a function. */
1298 static void
1299 dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
1301 emit_pending_bincls_if_required ();
1302 targetm.asm_out.internal_label (asm_out_file, "LBB", n);
1305 /* Describe the end line-number of an internal block within a function. */
1307 static void
1308 dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
1310 emit_pending_bincls_if_required ();
1311 targetm.asm_out.internal_label (asm_out_file, "LBE", n);
1314 /* Output dbx data for a function definition.
1315 This includes a definition of the function name itself (a symbol),
1316 definitions of the parameters (locating them in the parameter list)
1317 and then output the block that makes up the function's body
1318 (including all the auto variables of the function). */
1320 static void
1321 dbxout_function_decl (tree decl)
1323 emit_pending_bincls_if_required ();
1324 #ifndef DBX_FUNCTION_FIRST
1325 dbxout_begin_function (decl);
1326 #endif
1327 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
1328 dbxout_function_end (decl);
1331 #endif /* DBX_DEBUGGING_INFO */
1333 static void
1334 dbxout_early_global_decl (tree decl ATTRIBUTE_UNUSED)
1336 /* NYI for non-dwarf. */
1339 /* Debug information for a global DECL. Called from toplev.c after
1340 compilation proper has finished. */
1341 static void
1342 dbxout_late_global_decl (tree decl)
1344 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
1346 int saved_tree_used = TREE_USED (decl);
1347 TREE_USED (decl) = 1;
1348 dbxout_symbol (decl, 0);
1349 TREE_USED (decl) = saved_tree_used;
1353 /* This is just a function-type adapter; dbxout_symbol does exactly
1354 what we want but returns an int. */
1355 static void
1356 dbxout_type_decl (tree decl, int local)
1358 dbxout_symbol (decl, local);
1361 /* At the end of compilation, finish writing the symbol table.
1362 The default is to call debug_free_queue but do nothing else. */
1364 static void
1365 dbxout_finish (const char *filename ATTRIBUTE_UNUSED)
1367 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1368 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file, filename);
1369 #elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
1371 switch_to_section (text_section);
1372 dbxout_begin_empty_stabs (N_SO);
1373 dbxout_stab_value_internal_label ("Letext", 0);
1375 #endif
1376 debug_free_queue ();
1379 /* Output the index of a type. */
1381 static void
1382 dbxout_type_index (tree type)
1384 #ifndef DBX_USE_BINCL
1385 stabstr_D (TYPE_SYMTAB_ADDRESS (type));
1386 #else
1387 struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
1388 stabstr_C ('(');
1389 stabstr_D (t->file_number);
1390 stabstr_C (',');
1391 stabstr_D (t->type_number);
1392 stabstr_C (')');
1393 #endif
1397 /* Generate the symbols for any queued up type symbols we encountered
1398 while generating the type info for some originally used symbol.
1399 This might generate additional entries in the queue. Only when
1400 the nesting depth goes to 0 is this routine called. */
1402 static void
1403 debug_flush_symbol_queue (void)
1405 int i;
1407 /* Make sure that additionally queued items are not flushed
1408 prematurely. */
1410 ++debug_nesting;
1412 for (i = 0; i < symbol_queue_index; ++i)
1414 /* If we pushed queued symbols then such symbols must be
1415 output no matter what anyone else says. Specifically,
1416 we need to make sure dbxout_symbol() thinks the symbol was
1417 used and also we need to override TYPE_DECL_SUPPRESS_DEBUG
1418 which may be set for outside reasons. */
1419 int saved_tree_used = TREE_USED (symbol_queue[i]);
1420 int saved_suppress_debug = TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]);
1421 TREE_USED (symbol_queue[i]) = 1;
1422 TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]) = 0;
1424 #ifdef DBX_DEBUGGING_INFO
1425 dbxout_symbol (symbol_queue[i], 0);
1426 #endif
1428 TREE_USED (symbol_queue[i]) = saved_tree_used;
1429 TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]) = saved_suppress_debug;
1432 symbol_queue_index = 0;
1433 --debug_nesting;
1436 /* Queue a type symbol needed as part of the definition of a decl
1437 symbol. These symbols are generated when debug_flush_symbol_queue()
1438 is called. */
1440 static void
1441 debug_queue_symbol (tree decl)
1443 if (symbol_queue_index >= symbol_queue_size)
1445 symbol_queue_size += 10;
1446 symbol_queue = XRESIZEVEC (tree, symbol_queue, symbol_queue_size);
1449 symbol_queue[symbol_queue_index++] = decl;
1452 /* Free symbol queue. */
1453 static void
1454 debug_free_queue (void)
1456 if (symbol_queue)
1458 free (symbol_queue);
1459 symbol_queue = NULL;
1460 symbol_queue_size = 0;
1464 /* Used in several places: evaluates to '0' for a private decl,
1465 '1' for a protected decl, '2' for a public decl. */
1466 #define DECL_ACCESSIBILITY_CHAR(DECL) \
1467 (TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
1469 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
1470 This must be a separate function because anonymous unions require
1471 recursive calls. */
1473 static void
1474 dbxout_type_fields (tree type)
1476 tree tem;
1478 /* Output the name, type, position (in bits), size (in bits) of each
1479 field that we can support. */
1480 for (tem = TYPE_FIELDS (type); tem; tem = DECL_CHAIN (tem))
1482 /* If one of the nodes is an error_mark or its type is then
1483 return early. */
1484 if (error_operand_p (tem))
1485 return;
1487 /* Omit here local type decls until we know how to support them. */
1488 if (TREE_CODE (tem) == TYPE_DECL
1489 /* Omit here the nameless fields that are used to skip bits. */
1490 || DECL_IGNORED_P (tem)
1491 /* Omit fields whose position or size are variable or too large to
1492 represent. */
1493 || (TREE_CODE (tem) == FIELD_DECL
1494 && (! tree_fits_shwi_p (bit_position (tem))
1495 || ! DECL_SIZE (tem)
1496 || ! tree_fits_uhwi_p (DECL_SIZE (tem)))))
1497 continue;
1499 else if (TREE_CODE (tem) != CONST_DECL)
1501 /* Continue the line if necessary,
1502 but not before the first field. */
1503 if (tem != TYPE_FIELDS (type))
1504 CONTIN;
1506 if (DECL_NAME (tem))
1507 stabstr_I (DECL_NAME (tem));
1508 stabstr_C (':');
1510 if (use_gnu_debug_info_extensions
1511 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
1512 || TREE_CODE (tem) != FIELD_DECL))
1514 stabstr_C ('/');
1515 stabstr_C (DECL_ACCESSIBILITY_CHAR (tem));
1518 dbxout_type ((TREE_CODE (tem) == FIELD_DECL
1519 && DECL_BIT_FIELD_TYPE (tem))
1520 ? DECL_BIT_FIELD_TYPE (tem) : TREE_TYPE (tem), 0);
1522 if (TREE_CODE (tem) == VAR_DECL)
1524 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
1526 tree name = DECL_ASSEMBLER_NAME (tem);
1528 stabstr_C (':');
1529 stabstr_I (name);
1530 stabstr_C (';');
1532 else
1533 /* If TEM is non-static, GDB won't understand it. */
1534 stabstr_S (",0,0;");
1536 else
1538 stabstr_C (',');
1539 stabstr_D (int_bit_position (tem));
1540 stabstr_C (',');
1541 stabstr_D (tree_to_uhwi (DECL_SIZE (tem)));
1542 stabstr_C (';');
1548 /* Subroutine of `dbxout_type_methods'. Output debug info about the
1549 method described DECL. */
1551 static void
1552 dbxout_type_method_1 (tree decl)
1554 char c1 = 'A', c2;
1556 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
1557 c2 = '?';
1558 else /* it's a METHOD_TYPE. */
1560 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
1561 /* A for normal functions.
1562 B for `const' member functions.
1563 C for `volatile' member functions.
1564 D for `const volatile' member functions. */
1565 if (TYPE_READONLY (TREE_TYPE (firstarg)))
1566 c1 += 1;
1567 if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
1568 c1 += 2;
1570 if (DECL_VINDEX (decl))
1571 c2 = '*';
1572 else
1573 c2 = '.';
1576 /* ??? Output the mangled name, which contains an encoding of the
1577 method's type signature. May not be necessary anymore. */
1578 stabstr_C (':');
1579 stabstr_I (DECL_ASSEMBLER_NAME (decl));
1580 stabstr_C (';');
1581 stabstr_C (DECL_ACCESSIBILITY_CHAR (decl));
1582 stabstr_C (c1);
1583 stabstr_C (c2);
1585 if (DECL_VINDEX (decl) && tree_fits_shwi_p (DECL_VINDEX (decl)))
1587 stabstr_D (tree_to_shwi (DECL_VINDEX (decl)));
1588 stabstr_C (';');
1589 dbxout_type (DECL_CONTEXT (decl), 0);
1590 stabstr_C (';');
1594 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
1595 in TYPE. */
1597 static void
1598 dbxout_type_methods (tree type)
1600 /* C++: put out the method names and their parameter lists */
1601 tree methods = TYPE_METHODS (type);
1602 tree fndecl;
1603 tree last;
1605 if (methods == NULL_TREE)
1606 return;
1608 if (TREE_CODE (methods) != TREE_VEC)
1609 fndecl = methods;
1610 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
1611 fndecl = TREE_VEC_ELT (methods, 0);
1612 else
1613 fndecl = TREE_VEC_ELT (methods, 1);
1615 while (fndecl)
1617 int need_prefix = 1;
1619 /* Group together all the methods for the same operation.
1620 These differ in the types of the arguments. */
1621 for (last = NULL_TREE;
1622 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
1623 fndecl = DECL_CHAIN (fndecl))
1624 /* Output the name of the field (after overloading), as
1625 well as the name of the field before overloading, along
1626 with its parameter list */
1628 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
1629 include TEMPLATE_DECLs.) The debugger doesn't know what
1630 to do with such entities anyhow. */
1631 if (TREE_CODE (fndecl) != FUNCTION_DECL)
1632 continue;
1634 CONTIN;
1636 last = fndecl;
1638 /* Also ignore abstract methods; those are only interesting to
1639 the DWARF backends. */
1640 if (DECL_IGNORED_P (fndecl) || DECL_ABSTRACT_P (fndecl))
1641 continue;
1643 /* Redundantly output the plain name, since that's what gdb
1644 expects. */
1645 if (need_prefix)
1647 stabstr_I (DECL_NAME (fndecl));
1648 stabstr_S ("::");
1649 need_prefix = 0;
1652 dbxout_type (TREE_TYPE (fndecl), 0);
1653 dbxout_type_method_1 (fndecl);
1655 if (!need_prefix)
1656 stabstr_C (';');
1660 /* Emit a "range" type specification, which has the form:
1661 "r<index type>;<lower bound>;<upper bound>;".
1662 TYPE is an INTEGER_TYPE, LOW and HIGH are the bounds. */
1664 static void
1665 dbxout_range_type (tree type, tree low, tree high)
1667 stabstr_C ('r');
1668 if (TREE_TYPE (type))
1669 dbxout_type (TREE_TYPE (type), 0);
1670 else if (TREE_CODE (type) != INTEGER_TYPE)
1671 dbxout_type (type, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1672 else
1674 /* Traditionally, we made sure 'int' was type 1, and builtin types
1675 were defined to be sub-ranges of int. Unfortunately, this
1676 does not allow us to distinguish true sub-ranges from integer
1677 types. So, instead we define integer (non-sub-range) types as
1678 sub-ranges of themselves. This matters for Chill. If this isn't
1679 a subrange type, then we want to define it in terms of itself.
1680 However, in C, this may be an anonymous integer type, and we don't
1681 want to emit debug info referring to it. Just calling
1682 dbxout_type_index won't work anyways, because the type hasn't been
1683 defined yet. We make this work for both cases by checked to see
1684 whether this is a defined type, referring to it if it is, and using
1685 'int' otherwise. */
1686 if (TYPE_SYMTAB_ADDRESS (type) != 0)
1687 dbxout_type_index (type);
1688 else
1689 dbxout_type_index (integer_type_node);
1692 stabstr_C (';');
1693 if (low && tree_fits_shwi_p (low))
1695 if (print_int_cst_bounds_in_octal_p (type, low, high))
1696 stabstr_O (low);
1697 else
1698 stabstr_D (tree_to_shwi (low));
1700 else
1701 stabstr_C ('0');
1703 stabstr_C (';');
1704 if (high && tree_fits_shwi_p (high))
1706 if (print_int_cst_bounds_in_octal_p (type, low, high))
1707 stabstr_O (high);
1708 else
1709 stabstr_D (tree_to_shwi (high));
1710 stabstr_C (';');
1712 else
1713 stabstr_S ("-1;");
1717 /* Output a reference to a type. If the type has not yet been
1718 described in the dbx output, output its definition now.
1719 For a type already defined, just refer to its definition
1720 using the type number.
1722 If FULL is nonzero, and the type has been described only with
1723 a forward-reference, output the definition now.
1724 If FULL is zero in this case, just refer to the forward-reference
1725 using the number previously allocated. */
1727 static void
1728 dbxout_type (tree type, int full)
1730 static int anonymous_type_number = 0;
1731 tree tem, main_variant, low, high;
1733 if (TREE_CODE (type) == INTEGER_TYPE)
1735 if (TREE_TYPE (type) == 0)
1737 low = TYPE_MIN_VALUE (type);
1738 high = TYPE_MAX_VALUE (type);
1741 else if (subrange_type_for_debug_p (type, &low, &high))
1744 /* If this is a subtype that should not be emitted as a subrange type,
1745 use the base type. */
1746 else
1748 type = TREE_TYPE (type);
1749 low = TYPE_MIN_VALUE (type);
1750 high = TYPE_MAX_VALUE (type);
1754 /* If there was an input error and we don't really have a type,
1755 avoid crashing and write something that is at least valid
1756 by assuming `int'. */
1757 if (type == error_mark_node)
1758 type = integer_type_node;
1759 else
1761 if (TYPE_NAME (type)
1762 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1763 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
1764 full = 0;
1767 /* Try to find the "main variant" with the same name. */
1768 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1769 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1770 main_variant = TREE_TYPE (TYPE_NAME (type));
1771 else
1772 main_variant = TYPE_MAIN_VARIANT (type);
1774 /* If we are not using extensions, stabs does not distinguish const and
1775 volatile, so there is no need to make them separate types. */
1776 if (!use_gnu_debug_info_extensions)
1777 type = main_variant;
1779 if (TYPE_SYMTAB_ADDRESS (type) == 0)
1781 /* Type has no dbx number assigned. Assign next available number. */
1782 TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
1784 /* Make sure type vector is long enough to record about this type. */
1786 if (next_type_number == typevec_len)
1788 typevec = GGC_RESIZEVEC (struct typeinfo, typevec, typevec_len * 2);
1789 memset (typevec + typevec_len, 0, typevec_len * sizeof typevec[0]);
1790 typevec_len *= 2;
1793 #ifdef DBX_USE_BINCL
1794 emit_pending_bincls_if_required ();
1795 typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
1796 = current_file->file_number;
1797 typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
1798 = current_file->next_type_number++;
1799 #endif
1802 if (flag_debug_only_used_symbols)
1804 if ((TREE_CODE (type) == RECORD_TYPE
1805 || TREE_CODE (type) == UNION_TYPE
1806 || TREE_CODE (type) == QUAL_UNION_TYPE
1807 || TREE_CODE (type) == ENUMERAL_TYPE)
1808 && TYPE_STUB_DECL (type)
1809 && DECL_P (TYPE_STUB_DECL (type))
1810 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
1811 debug_queue_symbol (TYPE_STUB_DECL (type));
1812 else if (TYPE_NAME (type)
1813 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1814 debug_queue_symbol (TYPE_NAME (type));
1817 /* Output the number of this type, to refer to it. */
1818 dbxout_type_index (type);
1820 #ifdef DBX_TYPE_DEFINED
1821 if (DBX_TYPE_DEFINED (type))
1822 return;
1823 #endif
1825 /* If this type's definition has been output or is now being output,
1826 that is all. */
1828 switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
1830 case TYPE_UNSEEN:
1831 break;
1832 case TYPE_XREF:
1833 /* If we have already had a cross reference,
1834 and either that's all we want or that's the best we could do,
1835 don't repeat the cross reference.
1836 Sun dbx crashes if we do. */
1837 if (! full || !COMPLETE_TYPE_P (type)
1838 /* No way in DBX fmt to describe a variable size. */
1839 || ! tree_fits_uhwi_p (TYPE_SIZE (type)))
1840 return;
1841 break;
1842 case TYPE_DEFINED:
1843 return;
1846 #ifdef DBX_NO_XREFS
1847 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1848 leave the type-number completely undefined rather than output
1849 a cross-reference. If we have already used GNU debug info extensions,
1850 then it is OK to output a cross reference. This is necessary to get
1851 proper C++ debug output. */
1852 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
1853 || TREE_CODE (type) == QUAL_UNION_TYPE
1854 || TREE_CODE (type) == ENUMERAL_TYPE)
1855 && ! use_gnu_debug_info_extensions)
1856 /* We must use the same test here as we use twice below when deciding
1857 whether to emit a cross-reference. */
1858 if ((TYPE_NAME (type) != 0
1859 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1860 && DECL_IGNORED_P (TYPE_NAME (type)))
1861 && !full)
1862 || !COMPLETE_TYPE_P (type)
1863 /* No way in DBX fmt to describe a variable size. */
1864 || ! tree_fits_uhwi_p (TYPE_SIZE (type)))
1866 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1867 return;
1869 #endif
1871 /* Output a definition now. */
1872 stabstr_C ('=');
1874 /* Mark it as defined, so that if it is self-referent
1875 we will not get into an infinite recursion of definitions. */
1877 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
1879 /* If this type is a variant of some other, hand off. Types with
1880 different names are usefully distinguished. We only distinguish
1881 cv-qualified types if we're using extensions. */
1882 if (TYPE_READONLY (type) > TYPE_READONLY (main_variant))
1884 stabstr_C ('k');
1885 dbxout_type (build_type_variant (type, 0, TYPE_VOLATILE (type)), 0);
1886 return;
1888 else if (TYPE_VOLATILE (type) > TYPE_VOLATILE (main_variant))
1890 stabstr_C ('B');
1891 dbxout_type (build_type_variant (type, TYPE_READONLY (type), 0), 0);
1892 return;
1894 else if (main_variant != TYPE_MAIN_VARIANT (type))
1896 if (flag_debug_only_used_symbols)
1898 tree orig_type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
1900 if ((TREE_CODE (orig_type) == RECORD_TYPE
1901 || TREE_CODE (orig_type) == UNION_TYPE
1902 || TREE_CODE (orig_type) == QUAL_UNION_TYPE
1903 || TREE_CODE (orig_type) == ENUMERAL_TYPE)
1904 && TYPE_STUB_DECL (orig_type)
1905 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type)))
1906 debug_queue_symbol (TYPE_STUB_DECL (orig_type));
1908 /* 'type' is a typedef; output the type it refers to. */
1909 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0);
1910 return;
1912 /* else continue. */
1914 switch (TREE_CODE (type))
1916 case VOID_TYPE:
1917 case NULLPTR_TYPE:
1918 case LANG_TYPE:
1919 /* For a void type, just define it as itself; i.e., "5=5".
1920 This makes us consider it defined
1921 without saying what it is. The debugger will make it
1922 a void type when the reference is seen, and nothing will
1923 ever override that default. */
1924 dbxout_type_index (type);
1925 break;
1927 case INTEGER_TYPE:
1928 if (type == char_type_node && ! TYPE_UNSIGNED (type))
1930 /* Output the type `char' as a subrange of itself!
1931 I don't understand this definition, just copied it
1932 from the output of pcc.
1933 This used to use `r2' explicitly and we used to
1934 take care to make sure that `char' was type number 2. */
1935 stabstr_C ('r');
1936 dbxout_type_index (type);
1937 stabstr_S (";0;127;");
1940 /* If this is a subtype of another integer type, always prefer to
1941 write it as a subtype. */
1942 else if (TREE_TYPE (type) != 0
1943 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
1945 /* If the size is non-standard, say what it is if we can use
1946 GDB extensions. */
1948 if (use_gnu_debug_info_extensions
1949 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1951 stabstr_S ("@s");
1952 stabstr_D (TYPE_PRECISION (type));
1953 stabstr_C (';');
1956 dbxout_range_type (type, low, high);
1959 else
1961 /* If the size is non-standard, say what it is if we can use
1962 GDB extensions. */
1964 if (use_gnu_debug_info_extensions
1965 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1967 stabstr_S ("@s");
1968 stabstr_D (TYPE_PRECISION (type));
1969 stabstr_C (';');
1972 if (print_int_cst_bounds_in_octal_p (type, low, high))
1974 stabstr_C ('r');
1976 /* If this type derives from another type, output type index of
1977 parent type. This is particularly important when parent type
1978 is an enumerated type, because not generating the parent type
1979 index would transform the definition of this enumerated type
1980 into a plain unsigned type. */
1981 if (TREE_TYPE (type) != 0)
1982 dbxout_type_index (TREE_TYPE (type));
1983 else
1984 dbxout_type_index (type);
1986 stabstr_C (';');
1987 stabstr_O (low);
1988 stabstr_C (';');
1989 stabstr_O (high);
1990 stabstr_C (';');
1993 else
1994 /* Output other integer types as subranges of `int'. */
1995 dbxout_range_type (type, low, high);
1998 break;
2000 case REAL_TYPE:
2001 case FIXED_POINT_TYPE:
2002 /* This used to say `r1' and we used to take care
2003 to make sure that `int' was type number 1. */
2004 stabstr_C ('r');
2005 dbxout_type_index (integer_type_node);
2006 stabstr_C (';');
2007 stabstr_D (int_size_in_bytes (type));
2008 stabstr_S (";0;");
2009 break;
2011 case BOOLEAN_TYPE:
2012 if (use_gnu_debug_info_extensions)
2014 stabstr_S ("@s");
2015 stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
2016 stabstr_S (";-16;");
2018 else /* Define as enumeral type (False, True) */
2019 stabstr_S ("eFalse:0,True:1,;");
2020 break;
2022 case COMPLEX_TYPE:
2023 /* Differs from the REAL_TYPE by its new data type number.
2024 R3 is NF_COMPLEX. We don't try to use any of the other NF_*
2025 codes since gdb doesn't care anyway. */
2027 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
2029 stabstr_S ("R3;");
2030 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type)));
2031 stabstr_S (";0;");
2033 else
2035 /* Output a complex integer type as a structure,
2036 pending some other way to do it. */
2037 stabstr_C ('s');
2038 stabstr_D (int_size_in_bytes (type));
2040 stabstr_S ("real:");
2041 dbxout_type (TREE_TYPE (type), 0);
2042 stabstr_S (",0,");
2043 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
2045 stabstr_S (";imag:");
2046 dbxout_type (TREE_TYPE (type), 0);
2047 stabstr_C (',');
2048 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
2049 stabstr_C (',');
2050 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
2051 stabstr_S (";;");
2053 break;
2055 case ARRAY_TYPE:
2056 /* Make arrays of packed bits look like bitstrings for chill. */
2057 if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
2059 stabstr_S ("@s");
2060 stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
2061 stabstr_S (";@S;S");
2062 dbxout_type (TYPE_DOMAIN (type), 0);
2063 break;
2066 /* Output "a" followed by a range type definition
2067 for the index type of the array
2068 followed by a reference to the target-type.
2069 ar1;0;N;M for a C array of type M and size N+1. */
2070 /* Check if a character string type, which in Chill is
2071 different from an array of characters. */
2072 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
2074 stabstr_S ("@S;");
2076 tem = TYPE_DOMAIN (type);
2077 if (tem == NULL)
2079 stabstr_S ("ar");
2080 dbxout_type_index (integer_type_node);
2081 stabstr_S (";0;-1;");
2083 else
2085 stabstr_C ('a');
2086 dbxout_range_type (tem, TYPE_MIN_VALUE (tem), TYPE_MAX_VALUE (tem));
2089 dbxout_type (TREE_TYPE (type), 0);
2090 break;
2092 case VECTOR_TYPE:
2093 /* Make vectors look like an array. */
2094 if (use_gnu_debug_info_extensions)
2095 stabstr_S ("@V;");
2097 /* Output "a" followed by a range type definition
2098 for the index type of the array
2099 followed by a reference to the target-type.
2100 ar1;0;N;M for a C array of type M and size N+1. */
2101 stabstr_C ('a');
2102 dbxout_range_type (integer_type_node, size_zero_node,
2103 size_int (TYPE_VECTOR_SUBPARTS (type) - 1));
2105 dbxout_type (TREE_TYPE (type), 0);
2106 break;
2108 case RECORD_TYPE:
2109 case UNION_TYPE:
2110 case QUAL_UNION_TYPE:
2112 tree binfo = TYPE_BINFO (type);
2114 /* Output a structure type. We must use the same test here as we
2115 use in the DBX_NO_XREFS case above. */
2116 if ((TYPE_NAME (type) != 0
2117 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
2118 && DECL_IGNORED_P (TYPE_NAME (type)))
2119 && !full)
2120 || !COMPLETE_TYPE_P (type)
2121 /* No way in DBX fmt to describe a variable size. */
2122 || ! tree_fits_uhwi_p (TYPE_SIZE (type)))
2124 /* If the type is just a cross reference, output one
2125 and mark the type as partially described.
2126 If it later becomes defined, we will output
2127 its real definition.
2128 If the type has a name, don't nest its definition within
2129 another type's definition; instead, output an xref
2130 and let the definition come when the name is defined. */
2131 stabstr_S ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
2132 if (TYPE_IDENTIFIER (type))
2134 /* Note that the C frontend creates for anonymous variable
2135 length records/unions TYPE_NAME with DECL_NAME NULL. */
2136 dbxout_type_name (type);
2138 else
2140 stabstr_S ("$$");
2141 stabstr_D (anonymous_type_number++);
2144 stabstr_C (':');
2145 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
2146 break;
2149 /* Identify record or union, and print its size. */
2150 stabstr_C ((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u');
2151 stabstr_D (int_size_in_bytes (type));
2153 if (binfo)
2155 int i;
2156 tree child;
2157 vec<tree, va_gc> *accesses = BINFO_BASE_ACCESSES (binfo);
2159 if (use_gnu_debug_info_extensions)
2161 if (BINFO_N_BASE_BINFOS (binfo))
2163 stabstr_C ('!');
2164 stabstr_U (BINFO_N_BASE_BINFOS (binfo));
2165 stabstr_C (',');
2168 for (i = 0; BINFO_BASE_ITERATE (binfo, i, child); i++)
2170 tree access = (accesses ? (*accesses)[i] : access_public_node);
2172 if (use_gnu_debug_info_extensions)
2174 stabstr_C (BINFO_VIRTUAL_P (child) ? '1' : '0');
2175 stabstr_C (access == access_public_node ? '2' :
2176 access == access_protected_node
2177 ? '1' :'0');
2178 if (BINFO_VIRTUAL_P (child)
2179 && (lang_GNU_CXX ()
2180 || strcmp (lang_hooks.name, "GNU Objective-C++") == 0))
2181 /* For a virtual base, print the (negative)
2182 offset within the vtable where we must look
2183 to find the necessary adjustment. */
2184 stabstr_D
2185 (tree_to_shwi (BINFO_VPTR_FIELD (child))
2186 * BITS_PER_UNIT);
2187 else
2188 stabstr_D (tree_to_shwi (BINFO_OFFSET (child))
2189 * BITS_PER_UNIT);
2190 stabstr_C (',');
2191 dbxout_type (BINFO_TYPE (child), 0);
2192 stabstr_C (';');
2194 else
2196 /* Print out the base class information with
2197 fields which have the same names at the types
2198 they hold. */
2199 dbxout_type_name (BINFO_TYPE (child));
2200 stabstr_C (':');
2201 dbxout_type (BINFO_TYPE (child), full);
2202 stabstr_C (',');
2203 stabstr_D (tree_to_shwi (BINFO_OFFSET (child))
2204 * BITS_PER_UNIT);
2205 stabstr_C (',');
2206 stabstr_D
2207 (tree_to_shwi (TYPE_SIZE (BINFO_TYPE (child)))
2208 * BITS_PER_UNIT);
2209 stabstr_C (';');
2215 /* Write out the field declarations. */
2216 dbxout_type_fields (type);
2217 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
2219 dbxout_type_methods (type);
2222 stabstr_C (';');
2224 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
2225 /* Avoid the ~ if we don't really need it--it confuses dbx. */
2226 && TYPE_VFIELD (type))
2229 /* We need to write out info about what field this class
2230 uses as its "main" vtable pointer field, because if this
2231 field is inherited from a base class, GDB cannot necessarily
2232 figure out which field it's using in time. */
2233 stabstr_S ("~%");
2234 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
2235 stabstr_C (';');
2237 break;
2239 case ENUMERAL_TYPE:
2240 /* We must use the same test here as we use in the DBX_NO_XREFS case
2241 above. We simplify it a bit since an enum will never have a variable
2242 size. */
2243 if ((TYPE_NAME (type) != 0
2244 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
2245 && DECL_IGNORED_P (TYPE_NAME (type)))
2246 && !full)
2247 || !COMPLETE_TYPE_P (type))
2249 stabstr_S ("xe");
2250 dbxout_type_name (type);
2251 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
2252 stabstr_C (':');
2253 return;
2255 if (use_gnu_debug_info_extensions
2256 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
2258 stabstr_S ("@s");
2259 stabstr_D (TYPE_PRECISION (type));
2260 stabstr_C (';');
2263 stabstr_C ('e');
2264 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
2266 tree value = TREE_VALUE (tem);
2268 stabstr_I (TREE_PURPOSE (tem));
2269 stabstr_C (':');
2271 if (TREE_CODE (value) == CONST_DECL)
2272 value = DECL_INITIAL (value);
2274 if (cst_and_fits_in_hwi (value))
2275 stabstr_D (TREE_INT_CST_LOW (value));
2276 else
2277 stabstr_O (value);
2279 stabstr_C (',');
2280 if (TREE_CHAIN (tem) != 0)
2281 CONTIN;
2284 stabstr_C (';');
2285 break;
2287 case POINTER_TYPE:
2288 stabstr_C ('*');
2289 dbxout_type (TREE_TYPE (type), 0);
2290 break;
2292 case METHOD_TYPE:
2293 if (use_gnu_debug_info_extensions)
2295 stabstr_C ('#');
2297 /* Write the argument types out longhand. */
2298 dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
2299 stabstr_C (',');
2300 dbxout_type (TREE_TYPE (type), 0);
2301 dbxout_args (TYPE_ARG_TYPES (type));
2302 stabstr_C (';');
2304 else
2305 /* Treat it as a function type. */
2306 dbxout_type (TREE_TYPE (type), 0);
2307 break;
2309 case OFFSET_TYPE:
2310 if (use_gnu_debug_info_extensions)
2312 stabstr_C ('@');
2313 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
2314 stabstr_C (',');
2315 dbxout_type (TREE_TYPE (type), 0);
2317 else
2318 /* Should print as an int, because it is really just an offset. */
2319 dbxout_type (integer_type_node, 0);
2320 break;
2322 case REFERENCE_TYPE:
2323 if (use_gnu_debug_info_extensions)
2325 stabstr_C ('&');
2327 else
2328 stabstr_C ('*');
2329 dbxout_type (TREE_TYPE (type), 0);
2330 break;
2332 case FUNCTION_TYPE:
2333 stabstr_C ('f');
2334 dbxout_type (TREE_TYPE (type), 0);
2335 break;
2337 case POINTER_BOUNDS_TYPE:
2338 /* No debug info for pointer bounds type supported yet. */
2339 break;
2341 default:
2342 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
2343 named 'auto' in its type.
2344 No debug info for TEMPLATE_TYPE_PARM type supported yet. */
2345 if (lang_GNU_CXX ())
2347 tree name = TYPE_IDENTIFIER (type);
2348 if (name == get_identifier ("auto")
2349 || name == get_identifier ("decltype(auto)"))
2350 break;
2353 gcc_unreachable ();
2357 /* Return nonzero if the given type represents an integer whose bounds
2358 should be printed in octal format. */
2360 static bool
2361 print_int_cst_bounds_in_octal_p (tree type, tree low, tree high)
2363 /* If we can use GDB extensions and the size is wider than a long
2364 (the size used by GDB to read them) or we may have trouble writing
2365 the bounds the usual way, write them in octal. Note the test is for
2366 the *target's* size of "long", not that of the host. The host test
2367 is just to make sure we can write it out in case the host wide int
2368 is narrower than the target "long".
2370 For unsigned types, we use octal if they are the same size or larger.
2371 This is because we print the bounds as signed decimal, and hence they
2372 can't span same size unsigned types. */
2374 if (use_gnu_debug_info_extensions
2375 && low && TREE_CODE (low) == INTEGER_CST
2376 && high && TREE_CODE (high) == INTEGER_CST
2377 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
2378 || ((TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2379 && TYPE_UNSIGNED (type))
2380 || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
2381 || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
2382 && TYPE_UNSIGNED (type))))
2383 return TRUE;
2384 else
2385 return FALSE;
2388 /* Output the name of type TYPE, with no punctuation.
2389 Such names can be set up either by typedef declarations
2390 or by struct, enum and union tags. */
2392 static void
2393 dbxout_type_name (tree type)
2395 tree t = TYPE_NAME (type);
2397 gcc_assert (t);
2398 switch (TREE_CODE (t))
2400 case IDENTIFIER_NODE:
2401 break;
2402 case TYPE_DECL:
2403 t = DECL_NAME (t);
2404 break;
2405 default:
2406 gcc_unreachable ();
2409 stabstr_I (t);
2412 /* Output leading struct or class names needed for qualifying type
2413 whose scope is limited to a struct or class. */
2415 static void
2416 dbxout_class_name_qualifiers (tree decl)
2418 tree context = decl_type_context (decl);
2420 if (context != NULL_TREE
2421 && TREE_CODE (context) == RECORD_TYPE
2422 && TYPE_NAME (context) != 0
2423 && (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE
2424 || (DECL_NAME (TYPE_NAME (context)) != 0)))
2426 tree name = TYPE_NAME (context);
2428 if (TREE_CODE (name) == TYPE_DECL)
2430 dbxout_class_name_qualifiers (name);
2431 name = DECL_NAME (name);
2433 stabstr_I (name);
2434 stabstr_S ("::");
2438 /* This is a specialized subset of expand_expr for use by dbxout_symbol in
2439 evaluating DECL_VALUE_EXPR. In particular, we stop if we find decls that
2440 haven't been expanded, or if the expression is getting so complex we won't
2441 be able to represent it in stabs anyway. Returns NULL on failure. */
2443 static rtx
2444 dbxout_expand_expr (tree expr)
2446 switch (TREE_CODE (expr))
2448 case VAR_DECL:
2449 /* We can't handle emulated tls variables, because the address is an
2450 offset to the return value of __emutls_get_address, and there is no
2451 way to express that in stabs. Also, there are name mangling issues
2452 here. We end up with references to undefined symbols if we don't
2453 disable debug info for these variables. */
2454 if (!targetm.have_tls && DECL_THREAD_LOCAL_P (expr))
2455 return NULL;
2456 if (TREE_STATIC (expr)
2457 && !TREE_ASM_WRITTEN (expr)
2458 && !DECL_HAS_VALUE_EXPR_P (expr)
2459 && !TREE_PUBLIC (expr)
2460 && DECL_RTL_SET_P (expr)
2461 && MEM_P (DECL_RTL (expr)))
2463 /* If this is a var that might not be actually output,
2464 return NULL, otherwise stabs might reference an undefined
2465 symbol. */
2466 varpool_node *node = varpool_node::get (expr);
2467 if (!node || !node->definition)
2468 return NULL;
2470 /* FALLTHRU */
2472 case PARM_DECL:
2473 case RESULT_DECL:
2474 if (DECL_HAS_VALUE_EXPR_P (expr))
2475 return dbxout_expand_expr (DECL_VALUE_EXPR (expr));
2476 /* FALLTHRU */
2478 case CONST_DECL:
2479 return DECL_RTL_IF_SET (expr);
2481 case INTEGER_CST:
2482 return expand_expr (expr, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
2484 case COMPONENT_REF:
2485 case ARRAY_REF:
2486 case ARRAY_RANGE_REF:
2487 case BIT_FIELD_REF:
2489 machine_mode mode;
2490 HOST_WIDE_INT bitsize, bitpos;
2491 tree offset, tem;
2492 int volatilep = 0, unsignedp = 0;
2493 rtx x;
2495 tem = get_inner_reference (expr, &bitsize, &bitpos, &offset,
2496 &mode, &unsignedp, &volatilep, true);
2498 x = dbxout_expand_expr (tem);
2499 if (x == NULL || !MEM_P (x))
2500 return NULL;
2501 if (offset != NULL)
2503 if (!tree_fits_shwi_p (offset))
2504 return NULL;
2505 x = adjust_address_nv (x, mode, tree_to_shwi (offset));
2507 if (bitpos != 0)
2508 x = adjust_address_nv (x, mode, bitpos / BITS_PER_UNIT);
2510 return x;
2513 default:
2514 return NULL;
2518 /* Helper function for output_used_types. Queue one entry from the
2519 used types hash to be output. */
2521 bool
2522 output_used_types_helper (tree const &type, vec<tree> *types_p)
2524 if ((TREE_CODE (type) == RECORD_TYPE
2525 || TREE_CODE (type) == UNION_TYPE
2526 || TREE_CODE (type) == QUAL_UNION_TYPE
2527 || TREE_CODE (type) == ENUMERAL_TYPE)
2528 && TYPE_STUB_DECL (type)
2529 && DECL_P (TYPE_STUB_DECL (type))
2530 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
2531 types_p->quick_push (TYPE_STUB_DECL (type));
2532 else if (TYPE_NAME (type)
2533 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2534 types_p->quick_push (TYPE_NAME (type));
2536 return true;
2539 /* This is a qsort callback which sorts types and declarations into a
2540 predictable order (types, then declarations, sorted by UID
2541 within). */
2543 static int
2544 output_types_sort (const void *pa, const void *pb)
2546 const tree lhs = *((const tree *)pa);
2547 const tree rhs = *((const tree *)pb);
2549 if (TYPE_P (lhs))
2551 if (TYPE_P (rhs))
2552 return TYPE_UID (lhs) - TYPE_UID (rhs);
2553 else
2554 return 1;
2556 else
2558 if (TYPE_P (rhs))
2559 return -1;
2560 else
2561 return DECL_UID (lhs) - DECL_UID (rhs);
2566 /* Force all types used by this function to be output in debug
2567 information. */
2569 static void
2570 output_used_types (void)
2572 if (cfun && cfun->used_types_hash)
2574 vec<tree> types;
2575 int i;
2576 tree type;
2578 types.create (cfun->used_types_hash->elements ());
2579 cfun->used_types_hash->traverse<vec<tree> *, output_used_types_helper>
2580 (&types);
2582 /* Sort by UID to prevent dependence on hash table ordering. */
2583 types.qsort (output_types_sort);
2585 FOR_EACH_VEC_ELT (types, i, type)
2586 debug_queue_symbol (type);
2588 types.release ();
2592 /* Output a .stabs for the symbol defined by DECL,
2593 which must be a ..._DECL node in the normal namespace.
2594 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2595 LOCAL is nonzero if the scope is less than the entire file.
2596 Return 1 if a stabs might have been emitted. */
2599 dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
2601 tree type = TREE_TYPE (decl);
2602 tree context = NULL_TREE;
2603 int result = 0;
2604 rtx decl_rtl;
2606 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
2607 ++debug_nesting;
2609 /* Ignore nameless syms, but don't ignore type tags. */
2611 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
2612 || DECL_IGNORED_P (decl))
2613 DBXOUT_DECR_NESTING_AND_RETURN (0);
2615 /* If we are to generate only the symbols actually used then such
2616 symbol nodes are flagged with TREE_USED. Ignore any that
2617 aren't flagged as TREE_USED. */
2619 if (flag_debug_only_used_symbols
2620 && (!TREE_USED (decl)
2621 && (TREE_CODE (decl) != VAR_DECL || !DECL_INITIAL (decl))))
2622 DBXOUT_DECR_NESTING_AND_RETURN (0);
2624 /* If dbxout_init has not yet run, queue this symbol for later. */
2625 if (!typevec)
2627 preinit_symbols = tree_cons (0, decl, preinit_symbols);
2628 DBXOUT_DECR_NESTING_AND_RETURN (0);
2631 if (flag_debug_only_used_symbols)
2633 tree t;
2635 /* We now have a used symbol. We need to generate the info for
2636 the symbol's type in addition to the symbol itself. These
2637 type symbols are queued to be generated after were done with
2638 the symbol itself (otherwise they would fight over the
2639 stabstr obstack).
2641 Note, because the TREE_TYPE(type) might be something like a
2642 pointer to a named type we need to look for the first name
2643 we see following the TREE_TYPE chain. */
2645 t = type;
2646 while (POINTER_TYPE_P (t))
2647 t = TREE_TYPE (t);
2649 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2650 need special treatment. The TYPE_STUB_DECL field in these
2651 types generally represents the tag name type we want to
2652 output. In addition there could be a typedef type with
2653 a different name. In that case we also want to output
2654 that. */
2656 if (TREE_CODE (t) == RECORD_TYPE
2657 || TREE_CODE (t) == UNION_TYPE
2658 || TREE_CODE (t) == QUAL_UNION_TYPE
2659 || TREE_CODE (t) == ENUMERAL_TYPE)
2661 if (TYPE_STUB_DECL (t)
2662 && TYPE_STUB_DECL (t) != decl
2663 && DECL_P (TYPE_STUB_DECL (t))
2664 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t)))
2666 debug_queue_symbol (TYPE_STUB_DECL (t));
2667 if (TYPE_NAME (t)
2668 && TYPE_NAME (t) != TYPE_STUB_DECL (t)
2669 && TYPE_NAME (t) != decl
2670 && DECL_P (TYPE_NAME (t)))
2671 debug_queue_symbol (TYPE_NAME (t));
2674 else if (TYPE_NAME (t)
2675 && TYPE_NAME (t) != decl
2676 && DECL_P (TYPE_NAME (t)))
2677 debug_queue_symbol (TYPE_NAME (t));
2680 emit_pending_bincls_if_required ();
2682 switch (TREE_CODE (decl))
2684 case CONST_DECL:
2685 /* Enum values are defined by defining the enum type. */
2686 break;
2688 case FUNCTION_DECL:
2689 decl_rtl = DECL_RTL_IF_SET (decl);
2690 if (!decl_rtl)
2691 DBXOUT_DECR_NESTING_AND_RETURN (0);
2692 if (DECL_EXTERNAL (decl))
2693 break;
2694 /* Don't mention a nested function under its parent. */
2695 context = decl_function_context (decl);
2696 if (context == current_function_decl)
2697 break;
2698 /* Don't mention an inline instance of a nested function. */
2699 if (context && DECL_FROM_INLINE (decl))
2700 break;
2701 if (!MEM_P (decl_rtl)
2702 || GET_CODE (XEXP (decl_rtl, 0)) != SYMBOL_REF)
2703 break;
2705 if (flag_debug_only_used_symbols)
2706 output_used_types ();
2708 dbxout_begin_complex_stabs ();
2709 stabstr_I (DECL_ASSEMBLER_NAME (decl));
2710 stabstr_S (TREE_PUBLIC (decl) ? ":F" : ":f");
2711 result = 1;
2713 if (TREE_TYPE (type))
2714 dbxout_type (TREE_TYPE (type), 0);
2715 else
2716 dbxout_type (void_type_node, 0);
2718 /* For a nested function, when that function is compiled,
2719 mention the containing function name
2720 as well as (since dbx wants it) our own assembler-name. */
2721 if (context != 0)
2723 stabstr_C (',');
2724 stabstr_I (DECL_ASSEMBLER_NAME (decl));
2725 stabstr_C (',');
2726 stabstr_I (DECL_NAME (context));
2729 dbxout_finish_complex_stabs (decl, N_FUN, XEXP (decl_rtl, 0), 0, 0);
2730 break;
2732 case TYPE_DECL:
2733 /* Don't output the same typedef twice.
2734 And don't output what language-specific stuff doesn't want output. */
2735 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
2736 DBXOUT_DECR_NESTING_AND_RETURN (0);
2738 /* Don't output typedefs for types with magic type numbers (XCOFF). */
2739 #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2741 int fundamental_type_number =
2742 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl);
2744 if (fundamental_type_number != 0)
2746 TREE_ASM_WRITTEN (decl) = 1;
2747 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = fundamental_type_number;
2748 DBXOUT_DECR_NESTING_AND_RETURN (0);
2751 #endif
2752 FORCE_TEXT;
2753 result = 1;
2755 int tag_needed = 1;
2756 int did_output = 0;
2758 if (DECL_NAME (decl))
2760 /* Nonzero means we must output a tag as well as a typedef. */
2761 tag_needed = 0;
2763 /* Handle the case of a C++ structure or union
2764 where the TYPE_NAME is a TYPE_DECL
2765 which gives both a typedef name and a tag. */
2766 /* dbx requires the tag first and the typedef second. */
2767 if ((TREE_CODE (type) == RECORD_TYPE
2768 || TREE_CODE (type) == UNION_TYPE
2769 || TREE_CODE (type) == QUAL_UNION_TYPE)
2770 && TYPE_NAME (type) == decl
2771 && !use_gnu_debug_info_extensions
2772 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
2773 /* Distinguish the implicit typedefs of C++
2774 from explicit ones that might be found in C. */
2775 && DECL_ARTIFICIAL (decl)
2776 /* Do not generate a tag for incomplete records. */
2777 && COMPLETE_TYPE_P (type)
2778 /* Do not generate a tag for records of variable size,
2779 since this type can not be properly described in the
2780 DBX format, and it confuses some tools such as objdump. */
2781 && tree_fits_uhwi_p (TYPE_SIZE (type)))
2783 tree name = TYPE_IDENTIFIER (type);
2785 dbxout_begin_complex_stabs ();
2786 stabstr_I (name);
2787 stabstr_S (":T");
2788 dbxout_type (type, 1);
2789 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE,
2790 0, 0, 0);
2793 dbxout_begin_complex_stabs ();
2795 /* Output leading class/struct qualifiers. */
2796 if (use_gnu_debug_info_extensions)
2797 dbxout_class_name_qualifiers (decl);
2799 /* Output typedef name. */
2800 stabstr_I (DECL_NAME (decl));
2801 stabstr_C (':');
2803 /* Short cut way to output a tag also. */
2804 if ((TREE_CODE (type) == RECORD_TYPE
2805 || TREE_CODE (type) == UNION_TYPE
2806 || TREE_CODE (type) == QUAL_UNION_TYPE)
2807 && TYPE_NAME (type) == decl
2808 /* Distinguish the implicit typedefs of C++
2809 from explicit ones that might be found in C. */
2810 && DECL_ARTIFICIAL (decl))
2812 if (use_gnu_debug_info_extensions)
2814 stabstr_C ('T');
2815 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
2819 stabstr_C ('t');
2820 dbxout_type (type, 1);
2821 dbxout_finish_complex_stabs (decl, DBX_TYPE_DECL_STABS_CODE,
2822 0, 0, 0);
2823 did_output = 1;
2826 /* Don't output a tag if this is an incomplete type. This prevents
2827 the sun4 Sun OS 4.x dbx from crashing. */
2829 if (tag_needed && TYPE_NAME (type) != 0
2830 && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
2831 || (DECL_NAME (TYPE_NAME (type)) != 0))
2832 && COMPLETE_TYPE_P (type)
2833 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
2835 /* For a TYPE_DECL with no name, but the type has a name,
2836 output a tag.
2837 This is what represents `struct foo' with no typedef. */
2838 /* In C++, the name of a type is the corresponding typedef.
2839 In C, it is an IDENTIFIER_NODE. */
2840 tree name = TYPE_IDENTIFIER (type);
2842 dbxout_begin_complex_stabs ();
2843 stabstr_I (name);
2844 stabstr_S (":T");
2845 dbxout_type (type, 1);
2846 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
2847 did_output = 1;
2850 /* If an enum type has no name, it cannot be referred to, but
2851 we must output it anyway, to record the enumeration
2852 constants. */
2854 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
2856 dbxout_begin_complex_stabs ();
2857 /* Some debuggers fail when given NULL names, so give this a
2858 harmless name of " " (Why not "(anon)"?). */
2859 stabstr_S (" :T");
2860 dbxout_type (type, 1);
2861 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
2864 /* Prevent duplicate output of a typedef. */
2865 TREE_ASM_WRITTEN (decl) = 1;
2866 break;
2869 case PARM_DECL:
2870 if (DECL_HAS_VALUE_EXPR_P (decl))
2871 decl = DECL_VALUE_EXPR (decl);
2873 /* PARM_DECLs go in their own separate chain and are output by
2874 dbxout_reg_parms and dbxout_parms, except for those that are
2875 disguised VAR_DECLs like Out parameters in Ada. */
2876 gcc_assert (TREE_CODE (decl) == VAR_DECL);
2878 /* ... fall through ... */
2880 case RESULT_DECL:
2881 case VAR_DECL:
2882 /* Don't mention a variable that is external.
2883 Let the file that defines it describe it. */
2884 if (DECL_EXTERNAL (decl))
2885 break;
2887 /* If the variable is really a constant
2888 and not written in memory, inform the debugger.
2890 ??? Why do we skip emitting the type and location in this case? */
2891 if (TREE_STATIC (decl) && TREE_READONLY (decl)
2892 && DECL_INITIAL (decl) != 0
2893 && tree_fits_shwi_p (DECL_INITIAL (decl))
2894 && ! TREE_ASM_WRITTEN (decl)
2895 && (DECL_FILE_SCOPE_P (decl)
2896 || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK
2897 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
2898 && TREE_PUBLIC (decl) == 0)
2900 /* The sun4 assembler does not grok this. */
2902 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
2903 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
2905 HOST_WIDE_INT ival = tree_to_shwi (DECL_INITIAL (decl));
2907 dbxout_begin_complex_stabs ();
2908 dbxout_symbol_name (decl, NULL, 'c');
2909 stabstr_S ("=i");
2910 stabstr_D (ival);
2911 dbxout_finish_complex_stabs (0, N_LSYM, 0, 0, 0);
2912 DBXOUT_DECR_NESTING;
2913 return 1;
2915 else
2916 break;
2918 /* else it is something we handle like a normal variable. */
2920 decl_rtl = dbxout_expand_expr (decl);
2921 if (!decl_rtl)
2922 DBXOUT_DECR_NESTING_AND_RETURN (0);
2924 if (!is_global_var (decl))
2925 decl_rtl = eliminate_regs (decl_rtl, VOIDmode, NULL_RTX);
2926 #ifdef LEAF_REG_REMAP
2927 if (crtl->uses_only_leaf_regs)
2928 leaf_renumber_regs_insn (decl_rtl);
2929 #endif
2931 result = dbxout_symbol_location (decl, type, 0, decl_rtl);
2932 break;
2934 default:
2935 break;
2937 DBXOUT_DECR_NESTING;
2938 return result;
2941 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2942 Add SUFFIX to its name, if SUFFIX is not 0.
2943 Describe the variable as residing in HOME
2944 (usually HOME is DECL_RTL (DECL), but not always).
2945 Returns 1 if the stab was really emitted. */
2947 static int
2948 dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
2950 int letter = 0;
2951 stab_code_type code;
2952 rtx addr = 0;
2953 int number = 0;
2954 int regno = -1;
2956 /* Don't mention a variable at all
2957 if it was completely optimized into nothingness.
2959 If the decl was from an inline function, then its rtl
2960 is not identically the rtl that was used in this
2961 particular compilation. */
2962 if (GET_CODE (home) == SUBREG)
2964 rtx value = home;
2966 while (GET_CODE (value) == SUBREG)
2967 value = SUBREG_REG (value);
2968 if (REG_P (value))
2970 if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
2971 return 0;
2973 home = alter_subreg (&home, true);
2975 if (REG_P (home))
2977 regno = REGNO (home);
2978 if (regno >= FIRST_PSEUDO_REGISTER)
2979 return 0;
2982 /* The kind-of-variable letter depends on where
2983 the variable is and on the scope of its name:
2984 G and N_GSYM for static storage and global scope,
2985 S for static storage and file scope,
2986 V for static storage and local scope,
2987 for those two, use N_LCSYM if data is in bss segment,
2988 N_STSYM if in data segment, N_FUN otherwise.
2989 (We used N_FUN originally, then changed to N_STSYM
2990 to please GDB. However, it seems that confused ld.
2991 Now GDB has been fixed to like N_FUN, says Kingdon.)
2992 no letter at all, and N_LSYM, for auto variable,
2993 r and N_RSYM for register variable. */
2995 if (MEM_P (home) && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
2997 if (TREE_PUBLIC (decl))
2999 int offs;
3000 letter = 'G';
3001 code = N_GSYM;
3002 if (NULL != dbxout_common_check (decl, &offs))
3004 letter = 'V';
3005 addr = 0;
3006 number = offs;
3009 else
3011 addr = XEXP (home, 0);
3013 letter = decl_function_context (decl) ? 'V' : 'S';
3015 /* Some ports can transform a symbol ref into a label ref,
3016 because the symbol ref is too far away and has to be
3017 dumped into a constant pool. Alternatively, the symbol
3018 in the constant pool might be referenced by a different
3019 symbol. */
3020 if (GET_CODE (addr) == SYMBOL_REF
3021 && CONSTANT_POOL_ADDRESS_P (addr))
3023 bool marked;
3024 rtx tmp = get_pool_constant_mark (addr, &marked);
3026 if (GET_CODE (tmp) == SYMBOL_REF)
3028 addr = tmp;
3029 if (CONSTANT_POOL_ADDRESS_P (addr))
3030 get_pool_constant_mark (addr, &marked);
3031 else
3032 marked = true;
3034 else if (GET_CODE (tmp) == LABEL_REF)
3036 addr = tmp;
3037 marked = true;
3040 /* If all references to the constant pool were optimized
3041 out, we just ignore the symbol. */
3042 if (!marked)
3043 return 0;
3046 /* This should be the same condition as in assemble_variable, but
3047 we don't have access to dont_output_data here. So, instead,
3048 we rely on the fact that error_mark_node initializers always
3049 end up in bss for C++ and never end up in bss for C. */
3050 if (DECL_INITIAL (decl) == 0
3051 || (lang_GNU_CXX ()
3052 && DECL_INITIAL (decl) == error_mark_node))
3054 int offs;
3055 code = N_LCSYM;
3056 if (NULL != dbxout_common_check (decl, &offs))
3058 addr = 0;
3059 number = offs;
3060 letter = 'V';
3061 code = N_GSYM;
3064 else if (DECL_IN_TEXT_SECTION (decl))
3065 /* This is not quite right, but it's the closest
3066 of all the codes that Unix defines. */
3067 code = DBX_STATIC_CONST_VAR_CODE;
3068 else
3070 /* Ultrix `as' seems to need this. */
3071 #ifdef DBX_STATIC_STAB_DATA_SECTION
3072 switch_to_section (data_section);
3073 #endif
3074 code = N_STSYM;
3078 else if (regno >= 0)
3080 letter = 'r';
3081 code = N_RSYM;
3082 number = DBX_REGISTER_NUMBER (regno);
3084 else if (MEM_P (home)
3085 && (MEM_P (XEXP (home, 0))
3086 || (REG_P (XEXP (home, 0))
3087 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
3088 && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
3089 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
3090 && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
3091 #endif
3093 /* If the value is indirect by memory or by a register
3094 that isn't the frame pointer
3095 then it means the object is variable-sized and address through
3096 that register or stack slot. DBX has no way to represent this
3097 so all we can do is output the variable as a pointer.
3098 If it's not a parameter, ignore it. */
3100 if (REG_P (XEXP (home, 0)))
3102 letter = 'r';
3103 code = N_RSYM;
3104 if (REGNO (XEXP (home, 0)) >= FIRST_PSEUDO_REGISTER)
3105 return 0;
3106 number = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
3108 else
3110 code = N_LSYM;
3111 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
3112 We want the value of that CONST_INT. */
3113 number = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
3116 /* Effectively do build_pointer_type, but don't cache this type,
3117 since it might be temporary whereas the type it points to
3118 might have been saved for inlining. */
3119 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
3120 type = make_node (POINTER_TYPE);
3121 TREE_TYPE (type) = TREE_TYPE (decl);
3123 else if (MEM_P (home)
3124 && REG_P (XEXP (home, 0)))
3126 code = N_LSYM;
3127 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
3129 else if (MEM_P (home)
3130 && GET_CODE (XEXP (home, 0)) == PLUS
3131 && CONST_INT_P (XEXP (XEXP (home, 0), 1)))
3133 code = N_LSYM;
3134 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
3135 We want the value of that CONST_INT. */
3136 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
3138 else if (MEM_P (home)
3139 && GET_CODE (XEXP (home, 0)) == CONST)
3141 /* Handle an obscure case which can arise when optimizing and
3142 when there are few available registers. (This is *always*
3143 the case for i386/i486 targets). The RTL looks like
3144 (MEM (CONST ...)) even though this variable is a local `auto'
3145 or a local `register' variable. In effect, what has happened
3146 is that the reload pass has seen that all assignments and
3147 references for one such a local variable can be replaced by
3148 equivalent assignments and references to some static storage
3149 variable, thereby avoiding the need for a register. In such
3150 cases we're forced to lie to debuggers and tell them that
3151 this variable was itself `static'. */
3152 int offs;
3153 code = N_LCSYM;
3154 letter = 'V';
3155 if (NULL == dbxout_common_check (decl, &offs))
3156 addr = XEXP (XEXP (home, 0), 0);
3157 else
3159 addr = 0;
3160 number = offs;
3161 code = N_GSYM;
3164 else if (GET_CODE (home) == CONCAT)
3166 tree subtype;
3168 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
3169 for example), then there is no easy way to figure out
3170 what SUBTYPE should be. So, we give up. */
3171 if (TREE_CODE (type) != COMPLEX_TYPE)
3172 return 0;
3174 subtype = TREE_TYPE (type);
3176 /* If the variable's storage is in two parts,
3177 output each as a separate stab with a modified name. */
3178 if (WORDS_BIG_ENDIAN)
3179 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
3180 else
3181 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
3183 if (WORDS_BIG_ENDIAN)
3184 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
3185 else
3186 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
3187 return 1;
3189 else
3190 /* Address might be a MEM, when DECL is a variable-sized object.
3191 Or it might be const0_rtx, meaning previous passes
3192 want us to ignore this variable. */
3193 return 0;
3195 /* Ok, start a symtab entry and output the variable name. */
3196 emit_pending_bincls_if_required ();
3197 FORCE_TEXT;
3199 #ifdef DBX_STATIC_BLOCK_START
3200 DBX_STATIC_BLOCK_START (asm_out_file, code);
3201 #endif
3203 dbxout_begin_complex_stabs_noforcetext ();
3204 dbxout_symbol_name (decl, suffix, letter);
3205 dbxout_type (type, 0);
3206 dbxout_finish_complex_stabs (decl, code, addr, 0, number);
3208 #ifdef DBX_STATIC_BLOCK_END
3209 DBX_STATIC_BLOCK_END (asm_out_file, code);
3210 #endif
3211 return 1;
3214 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
3215 Then output LETTER to indicate the kind of location the symbol has. */
3217 static void
3218 dbxout_symbol_name (tree decl, const char *suffix, int letter)
3220 tree name;
3222 if (DECL_CONTEXT (decl)
3223 && (TYPE_P (DECL_CONTEXT (decl))
3224 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL))
3225 /* One slight hitch: if this is a VAR_DECL which is a class member
3226 or a namespace member, we must put out the mangled name instead of the
3227 DECL_NAME. Note also that static member (variable) names DO NOT begin
3228 with underscores in .stabs directives. */
3229 name = DECL_ASSEMBLER_NAME (decl);
3230 else
3231 /* ...but if we're function-local, we don't want to include the junk
3232 added by ASM_FORMAT_PRIVATE_NAME. */
3233 name = DECL_NAME (decl);
3235 if (name)
3236 stabstr_I (name);
3237 else
3238 stabstr_S ("(anon)");
3240 if (suffix)
3241 stabstr_S (suffix);
3242 stabstr_C (':');
3243 if (letter)
3244 stabstr_C (letter);
3248 /* Output the common block name for DECL in a stabs.
3250 Symbols in global common (.comm) get wrapped with an N_BCOMM/N_ECOMM pair
3251 around each group of symbols in the same .comm area. The N_GSYM stabs
3252 that are emitted only contain the offset in the common area. This routine
3253 emits the N_BCOMM and N_ECOMM stabs. */
3255 static void
3256 dbxout_common_name (tree decl, const char *name, stab_code_type op)
3258 dbxout_begin_complex_stabs ();
3259 stabstr_S (name);
3260 dbxout_finish_complex_stabs (decl, op, NULL_RTX, NULL, 0);
3263 /* Check decl to determine whether it is a VAR_DECL destined for storage in a
3264 common area. If it is, the return value will be a non-null string giving
3265 the name of the common storage block it will go into. If non-null, the
3266 value is the offset into the common block for that symbol's storage. */
3268 static const char *
3269 dbxout_common_check (tree decl, int *value)
3271 rtx home;
3272 rtx sym_addr;
3273 const char *name = NULL;
3275 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
3276 it does not have a value (the offset into the common area), or if it
3277 is thread local (as opposed to global) then it isn't common, and shouldn't
3278 be handled as such.
3280 ??? DECL_THREAD_LOCAL_P check prevents problems with improper .stabs
3281 for thread-local symbols. Can be handled via same mechanism as used
3282 in dwarf2out.c. */
3283 if (TREE_CODE (decl) != VAR_DECL
3284 || !TREE_STATIC (decl)
3285 || !DECL_HAS_VALUE_EXPR_P (decl)
3286 || DECL_THREAD_LOCAL_P (decl)
3287 || !is_fortran ())
3288 return NULL;
3290 home = DECL_RTL (decl);
3291 if (home == NULL_RTX || GET_CODE (home) != MEM)
3292 return NULL;
3294 sym_addr = dbxout_expand_expr (DECL_VALUE_EXPR (decl));
3295 if (sym_addr == NULL_RTX || GET_CODE (sym_addr) != MEM)
3296 return NULL;
3298 sym_addr = XEXP (sym_addr, 0);
3299 if (GET_CODE (sym_addr) == CONST)
3300 sym_addr = XEXP (sym_addr, 0);
3301 if ((GET_CODE (sym_addr) == SYMBOL_REF || GET_CODE (sym_addr) == PLUS)
3302 && DECL_INITIAL (decl) == 0)
3305 /* We have a sym that will go into a common area, meaning that it
3306 will get storage reserved with a .comm/.lcomm assembler pseudo-op.
3308 Determine name of common area this symbol will be an offset into,
3309 and offset into that area. Also retrieve the decl for the area
3310 that the symbol is offset into. */
3311 tree cdecl = NULL;
3313 switch (GET_CODE (sym_addr))
3315 case PLUS:
3316 if (CONST_INT_P (XEXP (sym_addr, 0)))
3318 name =
3319 targetm.strip_name_encoding (XSTR (XEXP (sym_addr, 1), 0));
3320 *value = INTVAL (XEXP (sym_addr, 0));
3321 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 1));
3323 else
3325 name =
3326 targetm.strip_name_encoding (XSTR (XEXP (sym_addr, 0), 0));
3327 *value = INTVAL (XEXP (sym_addr, 1));
3328 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 0));
3330 break;
3332 case SYMBOL_REF:
3333 name = targetm.strip_name_encoding (XSTR (sym_addr, 0));
3334 *value = 0;
3335 cdecl = SYMBOL_REF_DECL (sym_addr);
3336 break;
3338 default:
3339 error ("common symbol debug info is not structured as "
3340 "symbol+offset");
3343 /* Check area common symbol is offset into. If this is not public, then
3344 it is not a symbol in a common block. It must be a .lcomm symbol, not
3345 a .comm symbol. */
3346 if (cdecl == NULL || !TREE_PUBLIC (cdecl))
3347 name = NULL;
3349 else
3350 name = NULL;
3352 return name;
3355 /* Output definitions of all the decls in a chain. Return nonzero if
3356 anything was output */
3359 dbxout_syms (tree syms)
3361 int result = 0;
3362 const char *comm_prev = NULL;
3363 tree syms_prev = NULL;
3365 while (syms)
3367 int temp, copen, cclos;
3368 const char *comm_new;
3370 /* Check for common symbol, and then progression into a new/different
3371 block of common symbols. Emit closing/opening common bracket if
3372 necessary. */
3373 comm_new = dbxout_common_check (syms, &temp);
3374 copen = comm_new != NULL
3375 && (comm_prev == NULL || strcmp (comm_new, comm_prev));
3376 cclos = comm_prev != NULL
3377 && (comm_new == NULL || strcmp (comm_new, comm_prev));
3378 if (cclos)
3379 dbxout_common_name (syms_prev, comm_prev, N_ECOMM);
3380 if (copen)
3382 dbxout_common_name (syms, comm_new, N_BCOMM);
3383 syms_prev = syms;
3385 comm_prev = comm_new;
3387 result += dbxout_symbol (syms, 1);
3388 syms = DECL_CHAIN (syms);
3391 if (comm_prev != NULL)
3392 dbxout_common_name (syms_prev, comm_prev, N_ECOMM);
3394 return result;
3397 /* The following two functions output definitions of function parameters.
3398 Each parameter gets a definition locating it in the parameter list.
3399 Each parameter that is a register variable gets a second definition
3400 locating it in the register.
3402 Printing or argument lists in gdb uses the definitions that
3403 locate in the parameter list. But reference to the variable in
3404 expressions uses preferentially the definition as a register. */
3406 /* Output definitions, referring to storage in the parmlist,
3407 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
3409 void
3410 dbxout_parms (tree parms)
3412 ++debug_nesting;
3413 emit_pending_bincls_if_required ();
3415 for (; parms; parms = DECL_CHAIN (parms))
3416 if (DECL_NAME (parms)
3417 && TREE_TYPE (parms) != error_mark_node
3418 && DECL_RTL_SET_P (parms)
3419 && DECL_INCOMING_RTL (parms))
3421 tree eff_type;
3422 char letter;
3423 stab_code_type code;
3424 int number;
3426 /* Perform any necessary register eliminations on the parameter's rtl,
3427 so that the debugging output will be accurate. */
3428 DECL_INCOMING_RTL (parms)
3429 = eliminate_regs (DECL_INCOMING_RTL (parms), VOIDmode, NULL_RTX);
3430 SET_DECL_RTL (parms,
3431 eliminate_regs (DECL_RTL (parms), VOIDmode, NULL_RTX));
3432 #ifdef LEAF_REG_REMAP
3433 if (crtl->uses_only_leaf_regs)
3435 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
3436 leaf_renumber_regs_insn (DECL_RTL (parms));
3438 #endif
3440 if (PARM_PASSED_IN_MEMORY (parms))
3442 rtx inrtl = XEXP (DECL_INCOMING_RTL (parms), 0);
3444 /* ??? Here we assume that the parm address is indexed
3445 off the frame pointer or arg pointer.
3446 If that is not true, we produce meaningless results,
3447 but do not crash. */
3448 if (GET_CODE (inrtl) == PLUS
3449 && CONST_INT_P (XEXP (inrtl, 1)))
3450 number = INTVAL (XEXP (inrtl, 1));
3451 else
3452 number = 0;
3454 code = N_PSYM;
3455 number = DEBUGGER_ARG_OFFSET (number, inrtl);
3456 letter = 'p';
3458 /* It is quite tempting to use TREE_TYPE (parms) instead
3459 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
3460 reports the actual type of the parameter, rather than
3461 the promoted type. This certainly makes GDB's life
3462 easier, at least for some ports. The change is a bad
3463 idea however, since GDB expects to be able access the
3464 type without performing any conversions. So for
3465 example, if we were passing a float to an unprototyped
3466 function, gcc will store a double on the stack, but if
3467 we emit a stab saying the type is a float, then gdb
3468 will only read in a single value, and this will produce
3469 an erroneous value. */
3470 eff_type = DECL_ARG_TYPE (parms);
3472 else if (REG_P (DECL_RTL (parms)))
3474 rtx best_rtl;
3476 /* Parm passed in registers and lives in registers or nowhere. */
3477 code = DBX_REGPARM_STABS_CODE;
3478 letter = DBX_REGPARM_STABS_LETTER;
3480 /* For parms passed in registers, it is better to use the
3481 declared type of the variable, not the type it arrived in. */
3482 eff_type = TREE_TYPE (parms);
3484 /* If parm lives in a register, use that register; pretend
3485 the parm was passed there. It would be more consistent
3486 to describe the register where the parm was passed, but
3487 in practice that register usually holds something else.
3488 If the parm lives nowhere, use the register where it
3489 was passed. */
3490 if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
3491 best_rtl = DECL_RTL (parms);
3492 else if (GET_CODE (DECL_INCOMING_RTL (parms)) == PARALLEL)
3493 best_rtl = XEXP (XVECEXP (DECL_INCOMING_RTL (parms), 0, 0), 0);
3494 else
3495 best_rtl = DECL_INCOMING_RTL (parms);
3497 number = DBX_REGISTER_NUMBER (REGNO (best_rtl));
3499 else if (MEM_P (DECL_RTL (parms))
3500 && REG_P (XEXP (DECL_RTL (parms), 0))
3501 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
3502 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
3503 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
3504 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
3505 #endif
3508 /* Parm was passed via invisible reference.
3509 That is, its address was passed in a register.
3510 Output it as if it lived in that register.
3511 The debugger will know from the type
3512 that it was actually passed by invisible reference. */
3514 code = DBX_REGPARM_STABS_CODE;
3516 /* GDB likes this marked with a special letter. */
3517 letter = (use_gnu_debug_info_extensions
3518 ? 'a' : DBX_REGPARM_STABS_LETTER);
3519 eff_type = TREE_TYPE (parms);
3521 /* DECL_RTL looks like (MEM (REG...). Get the register number.
3522 If it is an unallocated pseudo-reg, then use the register where
3523 it was passed instead.
3524 ??? Why is DBX_REGISTER_NUMBER not used here? */
3526 if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
3527 number = REGNO (XEXP (DECL_RTL (parms), 0));
3528 else
3529 number = REGNO (DECL_INCOMING_RTL (parms));
3531 else if (MEM_P (DECL_RTL (parms))
3532 && MEM_P (XEXP (DECL_RTL (parms), 0)))
3534 /* Parm was passed via invisible reference, with the reference
3535 living on the stack. DECL_RTL looks like
3536 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3537 could look like (MEM (MEM (REG))). */
3539 code = N_PSYM;
3540 letter = 'v';
3541 eff_type = TREE_TYPE (parms);
3543 if (!REG_P (XEXP (XEXP (DECL_RTL (parms), 0), 0)))
3544 number = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
3545 else
3546 number = 0;
3548 number = DEBUGGER_ARG_OFFSET (number,
3549 XEXP (XEXP (DECL_RTL (parms), 0), 0));
3551 else if (MEM_P (DECL_RTL (parms))
3552 && XEXP (DECL_RTL (parms), 0) != const0_rtx
3553 /* ??? A constant address for a parm can happen
3554 when the reg it lives in is equiv to a constant in memory.
3555 Should make this not happen, after 2.4. */
3556 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
3558 /* Parm was passed in registers but lives on the stack. */
3560 code = N_PSYM;
3561 letter = 'p';
3562 eff_type = TREE_TYPE (parms);
3564 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3565 in which case we want the value of that CONST_INT,
3566 or (MEM (REG ...)),
3567 in which case we use a value of zero. */
3568 if (!REG_P (XEXP (DECL_RTL (parms), 0)))
3569 number = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
3570 else
3571 number = 0;
3573 /* Make a big endian correction if the mode of the type of the
3574 parameter is not the same as the mode of the rtl. */
3575 if (BYTES_BIG_ENDIAN
3576 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
3577 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
3578 number += (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
3579 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))));
3581 else
3582 /* ??? We don't know how to represent this argument. */
3583 continue;
3585 dbxout_begin_complex_stabs ();
3587 if (DECL_NAME (parms))
3589 stabstr_I (DECL_NAME (parms));
3590 stabstr_C (':');
3592 else
3593 stabstr_S ("(anon):");
3594 stabstr_C (letter);
3595 dbxout_type (eff_type, 0);
3596 dbxout_finish_complex_stabs (parms, code, 0, 0, number);
3598 DBXOUT_DECR_NESTING;
3601 /* Output definitions for the places where parms live during the function,
3602 when different from where they were passed, when the parms were passed
3603 in memory.
3605 It is not useful to do this for parms passed in registers
3606 that live during the function in different registers, because it is
3607 impossible to look in the passed register for the passed value,
3608 so we use the within-the-function register to begin with.
3610 PARMS is a chain of PARM_DECL nodes. */
3612 void
3613 dbxout_reg_parms (tree parms)
3615 ++debug_nesting;
3617 for (; parms; parms = DECL_CHAIN (parms))
3618 if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
3620 /* Report parms that live in registers during the function
3621 but were passed in memory. */
3622 if (REG_P (DECL_RTL (parms))
3623 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
3624 dbxout_symbol_location (parms, TREE_TYPE (parms),
3625 0, DECL_RTL (parms));
3626 else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
3627 dbxout_symbol_location (parms, TREE_TYPE (parms),
3628 0, DECL_RTL (parms));
3629 /* Report parms that live in memory but not where they were passed. */
3630 else if (MEM_P (DECL_RTL (parms))
3631 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
3632 dbxout_symbol_location (parms, TREE_TYPE (parms),
3633 0, DECL_RTL (parms));
3635 DBXOUT_DECR_NESTING;
3638 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
3639 output definitions of those names, in raw form */
3641 static void
3642 dbxout_args (tree args)
3644 while (args)
3646 stabstr_C (',');
3647 dbxout_type (TREE_VALUE (args), 0);
3648 args = TREE_CHAIN (args);
3652 #if defined (DBX_DEBUGGING_INFO)
3654 /* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
3655 BEGIN_LABEL is the name of the beginning of the function, which may
3656 be required. */
3657 static void
3658 dbx_output_lbrac (const char *label,
3659 const char *begin_label ATTRIBUTE_UNUSED)
3661 dbxout_begin_stabn (N_LBRAC);
3662 if (DBX_BLOCKS_FUNCTION_RELATIVE)
3663 dbxout_stab_value_label_diff (label, begin_label);
3664 else
3665 dbxout_stab_value_label (label);
3668 /* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
3669 BEGIN_LABEL is the name of the beginning of the function, which may
3670 be required. */
3671 static void
3672 dbx_output_rbrac (const char *label,
3673 const char *begin_label ATTRIBUTE_UNUSED)
3675 dbxout_begin_stabn (N_RBRAC);
3676 if (DBX_BLOCKS_FUNCTION_RELATIVE)
3677 dbxout_stab_value_label_diff (label, begin_label);
3678 else
3679 dbxout_stab_value_label (label);
3682 /* Output everything about a symbol block (a BLOCK node
3683 that represents a scope level),
3684 including recursive output of contained blocks.
3686 BLOCK is the BLOCK node.
3687 DEPTH is its depth within containing symbol blocks.
3688 ARGS is usually zero; but for the outermost block of the
3689 body of a function, it is a chain of PARM_DECLs for the function parameters.
3690 We output definitions of all the register parms
3691 as if they were local variables of that block.
3693 If -g1 was used, we count blocks just the same, but output nothing
3694 except for the outermost block.
3696 Actually, BLOCK may be several blocks chained together.
3697 We handle them all in sequence. */
3699 static void
3700 dbxout_block (tree block, int depth, tree args)
3702 char begin_label[20];
3703 /* Reference current function start using LFBB. */
3704 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
3706 while (block)
3708 /* Ignore blocks never expanded or otherwise marked as real. */
3709 if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
3711 int did_output;
3712 int blocknum = BLOCK_NUMBER (block);
3714 /* In dbx format, the syms of a block come before the N_LBRAC.
3715 If nothing is output, we don't need the N_LBRAC, either. */
3716 did_output = 0;
3717 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
3718 did_output = dbxout_syms (BLOCK_VARS (block));
3719 if (args)
3720 dbxout_reg_parms (args);
3722 /* Now output an N_LBRAC symbol to represent the beginning of
3723 the block. Use the block's tree-walk order to generate
3724 the assembler symbols LBBn and LBEn
3725 that final will define around the code in this block. */
3726 if (did_output)
3728 char buf[20];
3729 const char *scope_start;
3731 if (depth == 0)
3732 /* The outermost block doesn't get LBB labels; use
3733 the LFBB local symbol emitted by dbxout_begin_prologue. */
3734 scope_start = begin_label;
3735 else
3737 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
3738 scope_start = buf;
3741 dbx_output_lbrac (scope_start, begin_label);
3744 /* Output the subblocks. */
3745 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
3747 /* Refer to the marker for the end of the block. */
3748 if (did_output)
3750 char buf[100];
3751 if (depth == 0)
3752 /* The outermost block doesn't get LBE labels;
3753 use the "scope" label which will be emitted
3754 by dbxout_function_end. */
3755 ASM_GENERATE_INTERNAL_LABEL (buf, "Lscope", scope_labelno);
3756 else
3757 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
3759 dbx_output_rbrac (buf, begin_label);
3762 block = BLOCK_CHAIN (block);
3766 /* Output the information about a function and its arguments and result.
3767 Usually this follows the function's code,
3768 but on some systems, it comes before. */
3770 static void
3771 dbxout_begin_function (tree decl)
3773 int saved_tree_used1;
3775 saved_tree_used1 = TREE_USED (decl);
3776 TREE_USED (decl) = 1;
3777 if (DECL_NAME (DECL_RESULT (decl)) != 0)
3779 int saved_tree_used2 = TREE_USED (DECL_RESULT (decl));
3780 TREE_USED (DECL_RESULT (decl)) = 1;
3781 dbxout_symbol (decl, 0);
3782 TREE_USED (DECL_RESULT (decl)) = saved_tree_used2;
3784 else
3785 dbxout_symbol (decl, 0);
3786 TREE_USED (decl) = saved_tree_used1;
3788 dbxout_parms (DECL_ARGUMENTS (decl));
3789 if (DECL_NAME (DECL_RESULT (decl)) != 0)
3790 dbxout_symbol (DECL_RESULT (decl), 1);
3792 #endif /* DBX_DEBUGGING_INFO */
3794 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3796 /* Record an element in the table of global destructors. SYMBOL is
3797 a SYMBOL_REF of the function to be called; PRIORITY is a number
3798 between 0 and MAX_INIT_PRIORITY. */
3800 void
3801 default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED,
3802 int priority ATTRIBUTE_UNUSED)
3804 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
3805 /* Tell GNU LD that this is part of the static destructor set.
3806 This will work for any system that uses stabs, most usefully
3807 aout systems. */
3808 dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
3809 dbxout_stab_value_label (XSTR (symbol, 0));
3810 #else
3811 sorry ("global destructors not supported on this target");
3812 #endif
3815 /* Likewise for global constructors. */
3817 void
3818 default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED,
3819 int priority ATTRIBUTE_UNUSED)
3821 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
3822 /* Tell GNU LD that this is part of the static destructor set.
3823 This will work for any system that uses stabs, most usefully
3824 aout systems. */
3825 dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
3826 dbxout_stab_value_label (XSTR (symbol, 0));
3827 #else
3828 sorry ("global constructors not supported on this target");
3829 #endif
3832 #include "gt-dbxout.h"