Daily bump.
[official-gcc.git] / gcc / dbxout.c
blobbb8ca3254c09f5034b3cadb4ab686e292683d19a
1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987-2017 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 "target.h"
73 #include "function.h"
74 #include "rtl.h"
75 #include "tree.h"
76 #include "memmodel.h"
77 #include "tm_p.h"
78 #include "stringpool.h"
79 #include "insn-config.h"
80 #include "emit-rtl.h"
81 #include "cgraph.h"
82 #include "diagnostic-core.h"
83 #include "fold-const.h"
84 #include "varasm.h"
85 #include "stor-layout.h"
86 #include "reload.h"
87 #include "output.h"
88 #include "dbxout.h"
89 #include "toplev.h"
90 #include "debug.h"
91 #include "common/common-target.h"
92 #include "langhooks.h"
93 #include "expr.h"
95 #ifdef XCOFF_DEBUGGING_INFO
96 #include "xcoffout.h"
97 #endif
99 #ifndef ASM_STABS_OP
100 # ifdef XCOFF_DEBUGGING_INFO
101 # define ASM_STABS_OP "\t.stabx\t"
102 # else
103 # define ASM_STABS_OP "\t.stabs\t"
104 # endif
105 #endif
107 #ifndef ASM_STABN_OP
108 #define ASM_STABN_OP "\t.stabn\t"
109 #endif
111 #ifndef ASM_STABD_OP
112 #define ASM_STABD_OP "\t.stabd\t"
113 #endif
115 #ifndef DBX_TYPE_DECL_STABS_CODE
116 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
117 #endif
119 #ifndef DBX_STATIC_CONST_VAR_CODE
120 #define DBX_STATIC_CONST_VAR_CODE N_FUN
121 #endif
123 #ifndef DBX_REGPARM_STABS_CODE
124 #define DBX_REGPARM_STABS_CODE N_RSYM
125 #endif
127 #ifndef DBX_REGPARM_STABS_LETTER
128 #define DBX_REGPARM_STABS_LETTER 'P'
129 #endif
131 #ifndef NO_DBX_FUNCTION_END
132 #define NO_DBX_FUNCTION_END 0
133 #endif
135 #ifndef NO_DBX_BNSYM_ENSYM
136 #define NO_DBX_BNSYM_ENSYM 0
137 #endif
139 #ifndef NO_DBX_MAIN_SOURCE_DIRECTORY
140 #define NO_DBX_MAIN_SOURCE_DIRECTORY 0
141 #endif
143 #ifndef DBX_BLOCKS_FUNCTION_RELATIVE
144 #define DBX_BLOCKS_FUNCTION_RELATIVE 0
145 #endif
147 #ifndef DBX_LINES_FUNCTION_RELATIVE
148 #define DBX_LINES_FUNCTION_RELATIVE 0
149 #endif
151 #ifndef DBX_CONTIN_LENGTH
152 #define DBX_CONTIN_LENGTH 80
153 #endif
155 #ifndef DBX_CONTIN_CHAR
156 #define DBX_CONTIN_CHAR '\\'
157 #endif
159 enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
161 /* Structure recording information about a C data type.
162 The status element says whether we have yet output
163 the definition of the type. TYPE_XREF says we have
164 output it as a cross-reference only.
165 The file_number and type_number elements are used if DBX_USE_BINCL
166 is defined. */
168 struct GTY(()) typeinfo {
169 enum typestatus status;
170 int file_number;
171 int type_number;
174 /* Vector recording information about C data types.
175 When we first notice a data type (a tree node),
176 we assign it a number using next_type_number.
177 That is its index in this vector. */
179 static GTY ((length ("typevec_len"))) struct typeinfo *typevec;
181 /* Number of elements of space allocated in `typevec'. */
183 static GTY(()) int typevec_len;
185 /* In dbx output, each type gets a unique number.
186 This is the number for the next type output.
187 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
189 static GTY(()) int next_type_number;
191 /* The C front end may call dbxout_symbol before dbxout_init runs.
192 We save all such decls in this list and output them when we get
193 to dbxout_init. */
195 static GTY(()) tree preinit_symbols;
197 enum binclstatus {BINCL_NOT_REQUIRED, BINCL_PENDING, BINCL_PROCESSED};
199 /* When using N_BINCL in dbx output, each type number is actually a
200 pair of the file number and the type number within the file.
201 This is a stack of input files. */
203 struct dbx_file
205 struct dbx_file *next;
206 int file_number;
207 int next_type_number;
208 enum binclstatus bincl_status; /* Keep track of lazy bincl. */
209 const char *pending_bincl_name; /* Name of bincl. */
210 struct dbx_file *prev; /* Chain to traverse all pending bincls. */
213 /* This is the top of the stack.
215 This is not saved for PCH, because restoring a PCH should not change it.
216 next_file_number does have to be saved, because the PCH may use some
217 file numbers; however, just before restoring a PCH, next_file_number
218 should always be 0 because we should not have needed any file numbers
219 yet. */
221 #if (defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)) \
222 && defined (DBX_USE_BINCL)
223 static struct dbx_file *current_file;
224 #endif
226 /* This is the next file number to use. */
228 static GTY(()) int next_file_number;
230 /* A counter for dbxout_function_end. */
232 static GTY(()) int scope_labelno;
234 /* A counter for dbxout_source_line. */
236 static GTY(()) int dbxout_source_line_counter;
238 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
239 for the N_SO filename stabs label. */
241 static GTY(()) int source_label_number = 1;
243 /* Last source file name mentioned in a NOTE insn. */
245 static GTY(()) const char *lastfile;
247 /* Used by PCH machinery to detect if 'lastfile' should be reset to
248 base_input_file. */
249 static GTY(()) int lastfile_is_base;
251 /* Typical USG systems don't have stab.h, and they also have
252 no use for DBX-format debugging info. */
254 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
256 #ifdef DBX_USE_BINCL
257 /* If zero then there is no pending BINCL. */
258 static int pending_bincls = 0;
259 #endif
261 /* The original input file name. */
262 static const char *base_input_file;
264 #ifdef DEBUG_SYMS_TEXT
265 #define FORCE_TEXT switch_to_section (current_function_section ())
266 #else
267 #define FORCE_TEXT
268 #endif
270 #include "gstab.h"
272 /* 1 if PARM is passed to this function in memory. */
274 #define PARM_PASSED_IN_MEMORY(PARM) \
275 (MEM_P (DECL_INCOMING_RTL (PARM)))
277 /* A C expression for the integer offset value of an automatic variable
278 (N_LSYM) having address X (an RTX). */
279 #ifndef DEBUGGER_AUTO_OFFSET
280 #define DEBUGGER_AUTO_OFFSET(X) \
281 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
282 #endif
284 /* A C expression for the integer offset value of an argument (N_PSYM)
285 having address X (an RTX). The nominal offset is OFFSET.
286 Note that we use OFFSET + 0 here to avoid the self-assign warning
287 when the macro is called in a context like
288 number = DEBUGGER_ARG_OFFSET(number, X) */
289 #ifndef DEBUGGER_ARG_OFFSET
290 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET + 0)
291 #endif
293 /* This obstack holds the stab string currently being constructed. We
294 build it up here, then write it out, so we can split long lines up
295 properly (see dbxout_finish_complex_stabs). */
296 static struct obstack stabstr_ob;
297 static size_t stabstr_last_contin_point;
299 #ifdef DBX_USE_BINCL
300 static void emit_bincl_stab (const char *c);
301 static void emit_pending_bincls (void);
302 #endif
303 static inline void emit_pending_bincls_if_required (void);
305 static void dbxout_init (const char *);
307 static void dbxout_finish (const char *);
308 static void dbxout_start_source_file (unsigned, const char *);
309 static void dbxout_end_source_file (unsigned);
310 static void dbxout_typedefs (tree);
311 static void dbxout_type_index (tree);
312 static void dbxout_args (tree);
313 static void dbxout_type_fields (tree);
314 static void dbxout_type_method_1 (tree);
315 static void dbxout_type_methods (tree);
316 static void dbxout_range_type (tree, tree, tree);
317 static void dbxout_type (tree, int);
318 static bool print_int_cst_bounds_in_octal_p (tree, tree, tree);
319 static bool is_fortran (void);
320 static void dbxout_type_name (tree);
321 static void dbxout_class_name_qualifiers (tree);
322 static int dbxout_symbol_location (tree, tree, const char *, rtx);
323 static void dbxout_symbol_name (tree, const char *, int);
324 static void dbxout_common_name (tree, const char *, stab_code_type);
325 static const char *dbxout_common_check (tree, int *);
326 static void dbxout_early_global_decl (tree);
327 static void dbxout_late_global_decl (tree);
328 static void dbxout_type_decl (tree, int);
329 static void dbxout_handle_pch (unsigned);
330 static void debug_free_queue (void);
332 /* The debug hooks structure. */
333 #if defined (DBX_DEBUGGING_INFO)
335 static void dbxout_source_line (unsigned int, unsigned int, const char *,
336 int, bool);
337 static void dbxout_begin_prologue (unsigned int, unsigned int, const char *);
338 static void dbxout_source_file (const char *);
339 static void dbxout_function_end (tree);
340 static void dbxout_begin_function (tree);
341 static void dbxout_begin_block (unsigned, unsigned);
342 static void dbxout_end_block (unsigned, unsigned);
343 static void dbxout_function_decl (tree);
345 const struct gcc_debug_hooks dbx_debug_hooks =
347 dbxout_init,
348 dbxout_finish,
349 debug_nothing_charstar,
350 debug_nothing_void,
351 debug_nothing_int_charstar,
352 debug_nothing_int_charstar,
353 dbxout_start_source_file,
354 dbxout_end_source_file,
355 dbxout_begin_block,
356 dbxout_end_block,
357 debug_true_const_tree, /* ignore_block */
358 dbxout_source_line, /* source_line */
359 dbxout_begin_prologue, /* begin_prologue */
360 debug_nothing_int_charstar, /* end_prologue */
361 debug_nothing_int_charstar, /* begin_epilogue */
362 debug_nothing_int_charstar, /* end_epilogue */
363 #ifdef DBX_FUNCTION_FIRST
364 dbxout_begin_function,
365 #else
366 debug_nothing_tree, /* begin_function */
367 #endif
368 debug_nothing_int, /* end_function */
369 debug_nothing_tree, /* register_main_translation_unit */
370 dbxout_function_decl,
371 dbxout_early_global_decl, /* early_global_decl */
372 dbxout_late_global_decl, /* late_global_decl */
373 dbxout_type_decl, /* type_decl */
374 debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */
375 debug_nothing_tree, /* deferred_inline_function */
376 debug_nothing_tree, /* outlining_inline_function */
377 debug_nothing_rtx_code_label, /* label */
378 dbxout_handle_pch, /* handle_pch */
379 debug_nothing_rtx_insn, /* var_location */
380 debug_nothing_tree, /* size_function */
381 debug_nothing_void, /* switch_text_section */
382 debug_nothing_tree_tree, /* set_name */
383 0, /* start_end_main_source_file */
384 TYPE_SYMTAB_IS_ADDRESS /* tree_type_symtab_field */
386 #endif /* DBX_DEBUGGING_INFO */
388 #if defined (XCOFF_DEBUGGING_INFO)
389 const struct gcc_debug_hooks xcoff_debug_hooks =
391 dbxout_init,
392 dbxout_finish,
393 debug_nothing_charstar,
394 debug_nothing_void,
395 debug_nothing_int_charstar,
396 debug_nothing_int_charstar,
397 dbxout_start_source_file,
398 dbxout_end_source_file,
399 xcoffout_begin_block,
400 xcoffout_end_block,
401 debug_true_const_tree, /* ignore_block */
402 xcoffout_source_line,
403 xcoffout_begin_prologue, /* begin_prologue */
404 debug_nothing_int_charstar, /* end_prologue */
405 debug_nothing_int_charstar, /* begin_epilogue */
406 xcoffout_end_epilogue,
407 debug_nothing_tree, /* begin_function */
408 xcoffout_end_function,
409 debug_nothing_tree, /* register_main_translation_unit */
410 debug_nothing_tree, /* function_decl */
411 dbxout_early_global_decl, /* early_global_decl */
412 dbxout_late_global_decl, /* late_global_decl */
413 dbxout_type_decl, /* type_decl */
414 debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */
415 debug_nothing_tree, /* deferred_inline_function */
416 debug_nothing_tree, /* outlining_inline_function */
417 debug_nothing_rtx_code_label, /* label */
418 dbxout_handle_pch, /* handle_pch */
419 debug_nothing_rtx_insn, /* var_location */
420 debug_nothing_tree, /* size_function */
421 debug_nothing_void, /* switch_text_section */
422 debug_nothing_tree_tree, /* set_name */
423 0, /* start_end_main_source_file */
424 TYPE_SYMTAB_IS_ADDRESS /* tree_type_symtab_field */
426 #endif /* XCOFF_DEBUGGING_INFO */
428 /* Numeric formatting helper macro. Note that this does not handle
429 hexadecimal. */
430 #define NUMBER_FMT_LOOP(P, NUM, BASE) \
431 do \
433 int digit = NUM % BASE; \
434 NUM /= BASE; \
435 *--P = digit + '0'; \
437 while (NUM > 0)
439 /* Utility: write a decimal integer NUM to asm_out_file. */
440 void
441 dbxout_int (int num)
443 char buf[64];
444 char *p = buf + sizeof buf;
445 unsigned int unum;
447 if (num == 0)
449 putc ('0', asm_out_file);
450 return;
452 if (num < 0)
454 putc ('-', asm_out_file);
455 unum = -num;
457 else
458 unum = num;
460 NUMBER_FMT_LOOP (p, unum, 10);
462 while (p < buf + sizeof buf)
464 putc (*p, asm_out_file);
465 p++;
470 /* Primitives for emitting simple stabs directives. All other stabs
471 routines should use these functions instead of directly emitting
472 stabs. They are exported because machine-dependent code may need
473 to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
474 forwards to code in CPU.c. */
476 /* The following functions should all be called immediately after one
477 of the dbxout_begin_stab* functions (below). They write out
478 various things as the value of a stab. */
480 /* Write out a literal zero as the value of a stab. */
481 void
482 dbxout_stab_value_zero (void)
484 fputs ("0\n", asm_out_file);
487 /* Write out the label LABEL as the value of a stab. */
488 void
489 dbxout_stab_value_label (const char *label)
491 assemble_name (asm_out_file, label);
492 putc ('\n', asm_out_file);
495 /* Write out the difference of two labels, LABEL - BASE, as the value
496 of a stab. */
497 void
498 dbxout_stab_value_label_diff (const char *label, const char *base)
500 assemble_name (asm_out_file, label);
501 putc ('-', asm_out_file);
502 assemble_name (asm_out_file, base);
503 putc ('\n', asm_out_file);
506 /* Write out an internal label as the value of a stab, and immediately
507 emit that internal label. This should be used only when
508 dbxout_stabd will not work. STEM is the name stem of the label,
509 COUNTERP is a pointer to a counter variable which will be used to
510 guarantee label uniqueness. */
511 void
512 dbxout_stab_value_internal_label (const char *stem, int *counterp)
514 char label[100];
515 int counter = counterp ? (*counterp)++ : 0;
517 ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
518 dbxout_stab_value_label (label);
519 targetm.asm_out.internal_label (asm_out_file, stem, counter);
522 /* Write out the difference between BASE and an internal label as the
523 value of a stab, and immediately emit that internal label. STEM and
524 COUNTERP are as for dbxout_stab_value_internal_label. */
525 void
526 dbxout_stab_value_internal_label_diff (const char *stem, int *counterp,
527 const char *base)
529 char label[100];
530 int counter = counterp ? (*counterp)++ : 0;
532 ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
533 dbxout_stab_value_label_diff (label, base);
534 targetm.asm_out.internal_label (asm_out_file, stem, counter);
537 /* The following functions produce specific kinds of stab directives. */
539 /* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file. */
540 void
541 dbxout_stabd (int stype, int sdesc)
543 fputs (ASM_STABD_OP, asm_out_file);
544 dbxout_int (stype);
545 fputs (",0,", asm_out_file);
546 dbxout_int (sdesc);
547 putc ('\n', asm_out_file);
550 /* Write a .stabn directive with type STYPE. This function stops
551 short of emitting the value field, which is the responsibility of
552 the caller (normally it will be either a symbol or the difference
553 of two symbols). */
555 void
556 dbxout_begin_stabn (int stype)
558 fputs (ASM_STABN_OP, asm_out_file);
559 dbxout_int (stype);
560 fputs (",0,0,", asm_out_file);
563 /* Write a .stabn directive with type N_SLINE and desc LINE. As above,
564 the value field is the responsibility of the caller. */
565 void
566 dbxout_begin_stabn_sline (int lineno)
568 fputs (ASM_STABN_OP, asm_out_file);
569 dbxout_int (N_SLINE);
570 fputs (",0,", asm_out_file);
571 dbxout_int (lineno);
572 putc (',', asm_out_file);
575 /* Begin a .stabs directive with string "", type STYPE, and desc and
576 other fields 0. The value field is the responsibility of the
577 caller. This function cannot be used for .stabx directives. */
578 void
579 dbxout_begin_empty_stabs (int stype)
581 fputs (ASM_STABS_OP, asm_out_file);
582 fputs ("\"\",", asm_out_file);
583 dbxout_int (stype);
584 fputs (",0,0,", asm_out_file);
587 /* Begin a .stabs directive with string STR, type STYPE, and desc 0.
588 The value field is the responsibility of the caller. */
589 void
590 dbxout_begin_simple_stabs (const char *str, int stype)
592 fputs (ASM_STABS_OP, asm_out_file);
593 output_quoted_string (asm_out_file, str);
594 putc (',', asm_out_file);
595 dbxout_int (stype);
596 fputs (",0,0,", asm_out_file);
599 /* As above but use SDESC for the desc field. */
600 void
601 dbxout_begin_simple_stabs_desc (const char *str, int stype, int sdesc)
603 fputs (ASM_STABS_OP, asm_out_file);
604 output_quoted_string (asm_out_file, str);
605 putc (',', asm_out_file);
606 dbxout_int (stype);
607 fputs (",0,", asm_out_file);
608 dbxout_int (sdesc);
609 putc (',', asm_out_file);
612 /* The next set of functions are entirely concerned with production of
613 "complex" .stabs directives: that is, .stabs directives whose
614 strings have to be constructed piecemeal. dbxout_type,
615 dbxout_symbol, etc. use these routines heavily. The string is queued
616 up in an obstack, then written out by dbxout_finish_complex_stabs, which
617 is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
618 (You might think it would be more efficient to go straight to stdio
619 when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
620 out not to be the case, and anyway this needs fewer #ifdefs.) */
622 /* Begin a complex .stabs directive. If we can, write the initial
623 ASM_STABS_OP to the asm_out_file. */
625 static void
626 dbxout_begin_complex_stabs (void)
628 emit_pending_bincls_if_required ();
629 FORCE_TEXT;
630 fputs (ASM_STABS_OP, asm_out_file);
631 putc ('"', asm_out_file);
632 gcc_assert (stabstr_last_contin_point == 0);
635 /* As above, but do not force text or emit pending bincls. This is
636 used by dbxout_symbol_location, which needs to do something else. */
637 static void
638 dbxout_begin_complex_stabs_noforcetext (void)
640 fputs (ASM_STABS_OP, asm_out_file);
641 putc ('"', asm_out_file);
642 gcc_assert (stabstr_last_contin_point == 0);
645 /* Add CHR, a single character, to the string being built. */
646 #define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
648 /* Add STR, a normal C string, to the string being built. */
649 #define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen (str))
651 /* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */
652 #define stabstr_I(id) obstack_grow (&stabstr_ob, \
653 IDENTIFIER_POINTER (id), \
654 IDENTIFIER_LENGTH (id))
656 /* Add NUM, a signed decimal number, to the string being built. */
657 static void
658 stabstr_D (HOST_WIDE_INT num)
660 char buf[64];
661 char *p = buf + sizeof buf;
662 unsigned int unum;
664 if (num == 0)
666 stabstr_C ('0');
667 return;
669 if (num < 0)
671 stabstr_C ('-');
672 unum = -num;
674 else
675 unum = num;
677 NUMBER_FMT_LOOP (p, unum, 10);
679 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
682 /* Add NUM, an unsigned decimal number, to the string being built. */
683 static void
684 stabstr_U (unsigned HOST_WIDE_INT num)
686 char buf[64];
687 char *p = buf + sizeof buf;
688 if (num == 0)
690 stabstr_C ('0');
691 return;
693 NUMBER_FMT_LOOP (p, num, 10);
694 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
697 /* Add CST, an INTEGER_CST tree, to the string being built as an
698 unsigned octal number. This routine handles values which are
699 larger than a single HOST_WIDE_INT. */
700 static void
701 stabstr_O (tree cst)
703 int prec = TYPE_PRECISION (TREE_TYPE (cst));
704 int res_pres = prec % 3;
705 int i;
706 unsigned int digit;
708 /* Leading zero for base indicator. */
709 stabstr_C ('0');
711 /* If the value is zero, the base indicator will serve as the value
712 all by itself. */
713 if (wi::eq_p (cst, 0))
714 return;
716 /* GDB wants constants with no extra leading "1" bits, so
717 we need to remove any sign-extension that might be
718 present. */
719 if (res_pres == 1)
721 digit = wi::extract_uhwi (cst, prec - 1, 1);
722 stabstr_C ('0' + digit);
724 else if (res_pres == 2)
726 digit = wi::extract_uhwi (cst, prec - 2, 2);
727 stabstr_C ('0' + digit);
730 prec -= res_pres;
731 for (i = prec - 3; i >= 0; i = i - 3)
733 digit = wi::extract_uhwi (cst, i, 3);
734 stabstr_C ('0' + digit);
738 /* Called whenever it is safe to break a stabs string into multiple
739 .stabs directives. If the current string has exceeded the limit
740 set by DBX_CONTIN_LENGTH, mark the current position in the buffer
741 as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
742 it is a backslash) and a null character. */
743 static inline void
744 stabstr_continue (void)
746 if (DBX_CONTIN_LENGTH > 0
747 && obstack_object_size (&stabstr_ob) - stabstr_last_contin_point
748 > DBX_CONTIN_LENGTH)
750 if (DBX_CONTIN_CHAR == '\\')
751 obstack_1grow (&stabstr_ob, '\\');
752 obstack_1grow (&stabstr_ob, DBX_CONTIN_CHAR);
753 obstack_1grow (&stabstr_ob, '\0');
754 stabstr_last_contin_point = obstack_object_size (&stabstr_ob);
757 #define CONTIN stabstr_continue ()
759 /* Macro subroutine of dbxout_finish_complex_stabs, which emits
760 all of the arguments to the .stabs directive after the string.
761 Overridden by xcoffout.h. CODE is the stabs code for this symbol;
762 LINE is the source line to write into the desc field (in extended
763 mode); SYM is the symbol itself.
765 ADDR, LABEL, and NUMBER are three different ways to represent the
766 stabs value field. At most one of these should be nonzero.
768 ADDR is used most of the time; it represents the value as an
769 RTL address constant.
771 LABEL is used (currently) only for N_CATCH stabs; it represents
772 the value as a string suitable for assemble_name.
774 NUMBER is used when the value is an offset from an implicit base
775 pointer (e.g. for a stack variable), or an index (e.g. for a
776 register variable). It represents the value as a decimal integer. */
778 #ifndef DBX_FINISH_STABS
779 #define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER) \
780 do { \
781 int line_ = use_gnu_debug_info_extensions ? LINE : 0; \
783 dbxout_int (CODE); \
784 fputs (",0,", asm_out_file); \
785 dbxout_int (line_); \
786 putc (',', asm_out_file); \
787 if (ADDR) \
788 output_addr_const (asm_out_file, ADDR); \
789 else if (LABEL) \
790 assemble_name (asm_out_file, LABEL); \
791 else \
792 dbxout_int (NUMBER); \
793 putc ('\n', asm_out_file); \
794 } while (0)
795 #endif
797 /* Finish the emission of a complex .stabs directive. When DBX_CONTIN_LENGTH
798 is zero, this has only to emit the close quote and the remainder of
799 the arguments. When it is nonzero, the string has been marshalled in
800 stabstr_ob, and this routine is responsible for breaking it up into
801 DBX_CONTIN_LENGTH-sized chunks.
803 SYM is the DECL of the symbol under consideration; it is used only
804 for its DECL_SOURCE_LINE. The other arguments are all passed directly
805 to DBX_FINISH_STABS; see above for details. */
807 static void
808 dbxout_finish_complex_stabs (tree sym, stab_code_type code,
809 rtx addr, const char *label, int number)
811 int line ATTRIBUTE_UNUSED;
812 char *str;
813 size_t len;
815 line = sym ? DECL_SOURCE_LINE (sym) : 0;
816 if (DBX_CONTIN_LENGTH > 0)
818 char *chunk;
819 size_t chunklen;
821 /* Nul-terminate the growing string, then get its size and
822 address. */
823 obstack_1grow (&stabstr_ob, '\0');
825 len = obstack_object_size (&stabstr_ob);
826 chunk = str = XOBFINISH (&stabstr_ob, char *);
828 /* Within the buffer are a sequence of NUL-separated strings,
829 each of which is to be written out as a separate stab
830 directive. */
831 for (;;)
833 chunklen = strlen (chunk);
834 fwrite (chunk, 1, chunklen, asm_out_file);
835 fputs ("\",", asm_out_file);
837 /* Must add an extra byte to account for the NUL separator. */
838 chunk += chunklen + 1;
839 len -= chunklen + 1;
841 /* Only put a line number on the last stab in the sequence. */
842 DBX_FINISH_STABS (sym, code, len == 0 ? line : 0,
843 addr, label, number);
844 if (len == 0)
845 break;
847 fputs (ASM_STABS_OP, asm_out_file);
848 putc ('"', asm_out_file);
850 stabstr_last_contin_point = 0;
852 else
854 /* No continuations - we can put the whole string out at once.
855 It is faster to augment the string with the close quote and
856 comma than to do a two-character fputs. */
857 obstack_grow (&stabstr_ob, "\",", 2);
858 len = obstack_object_size (&stabstr_ob);
859 str = XOBFINISH (&stabstr_ob, char *);
861 fwrite (str, 1, len, asm_out_file);
862 DBX_FINISH_STABS (sym, code, line, addr, label, number);
864 obstack_free (&stabstr_ob, str);
867 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
869 /* When -gused is used, emit debug info for only used symbols. But in
870 addition to the standard intercepted debug_hooks there are some
871 direct calls into this file, i.e., dbxout_symbol, dbxout_parms, and
872 dbxout_reg_params. Those routines may also be called from a higher
873 level intercepted routine. So to prevent recording data for an inner
874 call to one of these for an intercept, we maintain an intercept
875 nesting counter (debug_nesting). We only save the intercepted
876 arguments if the nesting is 1. */
877 static int debug_nesting = 0;
879 static tree *symbol_queue;
880 static int symbol_queue_index = 0;
881 static int symbol_queue_size = 0;
883 #define DBXOUT_DECR_NESTING \
884 if (--debug_nesting == 0 && symbol_queue_index > 0) \
885 { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
887 #define DBXOUT_DECR_NESTING_AND_RETURN(x) \
888 do {--debug_nesting; return (x);} while (0)
890 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
892 #if defined (DBX_DEBUGGING_INFO)
894 static void
895 dbxout_function_end (tree decl ATTRIBUTE_UNUSED)
897 char lscope_label_name[100];
899 /* The Lscope label must be emitted even if we aren't doing anything
900 else; dbxout_block needs it. */
901 switch_to_section (function_section (current_function_decl));
903 /* Convert Lscope into the appropriate format for local labels in case
904 the system doesn't insert underscores in front of user generated
905 labels. */
906 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
907 targetm.asm_out.internal_label (asm_out_file, "Lscope", scope_labelno);
909 /* The N_FUN tag at the end of the function is a GNU extension,
910 which may be undesirable, and is unnecessary if we do not have
911 named sections. */
912 if (!use_gnu_debug_info_extensions
913 || NO_DBX_FUNCTION_END
914 || !targetm_common.have_named_sections)
915 return;
917 /* By convention, GCC will mark the end of a function with an N_FUN
918 symbol and an empty string. */
919 if (crtl->has_bb_partition)
921 dbxout_begin_empty_stabs (N_FUN);
922 dbxout_stab_value_label_diff (crtl->subsections.hot_section_end_label,
923 crtl->subsections.hot_section_label);
924 dbxout_begin_empty_stabs (N_FUN);
925 dbxout_stab_value_label_diff (crtl->subsections.cold_section_end_label,
926 crtl->subsections.cold_section_label);
928 else
930 char begin_label[20];
931 /* Reference current function start using LFBB. */
932 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
933 dbxout_begin_empty_stabs (N_FUN);
934 dbxout_stab_value_label_diff (lscope_label_name, begin_label);
937 if (!NO_DBX_BNSYM_ENSYM && !flag_debug_only_used_symbols)
938 dbxout_stabd (N_ENSYM, 0);
940 #endif /* DBX_DEBUGGING_INFO */
942 /* Get lang description for N_SO stab. */
943 static unsigned int ATTRIBUTE_UNUSED
944 get_lang_number (void)
946 const char *language_string = lang_hooks.name;
947 if (lang_GNU_C ())
948 return N_SO_C;
949 else if (lang_GNU_CXX ())
950 return N_SO_CC;
951 else if (strcmp (language_string, "GNU F77") == 0)
952 return N_SO_FORTRAN;
953 else if (lang_GNU_Fortran ())
954 return N_SO_FORTRAN90; /* CHECKME */
955 else if (strcmp (language_string, "GNU Pascal") == 0)
956 return N_SO_PASCAL;
957 else if (strcmp (language_string, "GNU Objective-C") == 0)
958 return N_SO_OBJC;
959 else if (strcmp (language_string, "GNU Objective-C++") == 0)
960 return N_SO_OBJCPLUS;
961 else
962 return 0;
966 static bool
967 is_fortran (void)
969 unsigned int lang = get_lang_number ();
971 return (lang == N_SO_FORTRAN) || (lang == N_SO_FORTRAN90);
974 /* At the beginning of compilation, start writing the symbol table.
975 Initialize `typevec' and output the standard data types of C. */
977 static void
978 dbxout_init (const char *input_file_name)
980 char ltext_label_name[100];
981 bool used_ltext_label_name = false;
982 tree syms = lang_hooks.decls.getdecls ();
983 const char *mapped_name;
985 typevec_len = 100;
986 typevec = ggc_cleared_vec_alloc<typeinfo> (typevec_len);
988 /* stabstr_ob contains one string, which will be just fine with
989 1-byte alignment. */
990 obstack_specify_allocation (&stabstr_ob, 0, 1, xmalloc, free);
992 /* Convert Ltext into the appropriate format for local labels in case
993 the system doesn't insert underscores in front of user generated
994 labels. */
995 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
997 /* Put the current working directory in an N_SO symbol. */
998 if (use_gnu_debug_info_extensions && !NO_DBX_MAIN_SOURCE_DIRECTORY)
1000 static const char *cwd;
1002 if (!cwd)
1004 cwd = get_src_pwd ();
1005 if (cwd[0] == '\0')
1006 cwd = "/";
1007 else if (!IS_DIR_SEPARATOR (cwd[strlen (cwd) - 1]))
1008 cwd = concat (cwd, "/", NULL);
1009 cwd = remap_debug_filename (cwd);
1011 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
1012 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file, cwd);
1013 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1014 dbxout_begin_simple_stabs_desc (cwd, N_SO, get_lang_number ());
1015 dbxout_stab_value_label (ltext_label_name);
1016 used_ltext_label_name = true;
1017 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1020 mapped_name = remap_debug_filename (input_file_name);
1021 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
1022 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file, mapped_name);
1023 #else
1024 dbxout_begin_simple_stabs_desc (mapped_name, N_SO, get_lang_number ());
1025 dbxout_stab_value_label (ltext_label_name);
1026 used_ltext_label_name = true;
1027 #endif
1029 if (used_ltext_label_name)
1031 switch_to_section (text_section);
1032 targetm.asm_out.internal_label (asm_out_file, "Ltext", 0);
1035 /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
1036 The string used is historical. */
1037 #ifndef NO_DBX_GCC_MARKER
1038 dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT);
1039 dbxout_stab_value_zero ();
1040 #endif
1042 base_input_file = lastfile = input_file_name;
1044 next_type_number = 1;
1046 #ifdef DBX_USE_BINCL
1047 current_file = XNEW (struct dbx_file);
1048 current_file->next = NULL;
1049 current_file->file_number = 0;
1050 current_file->next_type_number = 1;
1051 next_file_number = 1;
1052 current_file->prev = NULL;
1053 current_file->bincl_status = BINCL_NOT_REQUIRED;
1054 current_file->pending_bincl_name = NULL;
1055 #endif
1057 /* Get all permanent types that have typedef names, and output them
1058 all, except for those already output. Some language front ends
1059 put these declarations in the top-level scope; some do not;
1060 the latter are responsible for calling debug_hooks->type_decl from
1061 their record_builtin_type function. */
1062 dbxout_typedefs (syms);
1064 if (preinit_symbols)
1066 tree t;
1067 for (t = nreverse (preinit_symbols); t; t = TREE_CHAIN (t))
1068 dbxout_symbol (TREE_VALUE (t), 0);
1069 preinit_symbols = 0;
1073 /* Output any typedef names for types described by TYPE_DECLs in SYMS. */
1075 static void
1076 dbxout_typedefs (tree syms)
1078 for (; syms != NULL_TREE; syms = DECL_CHAIN (syms))
1080 if (TREE_CODE (syms) == TYPE_DECL)
1082 tree type = TREE_TYPE (syms);
1083 if (TYPE_NAME (type)
1084 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1085 && COMPLETE_OR_VOID_TYPE_P (type)
1086 && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
1087 dbxout_symbol (TYPE_NAME (type), 0);
1092 #ifdef DBX_USE_BINCL
1093 /* Emit BINCL stab using given name. */
1094 static void
1095 emit_bincl_stab (const char *name)
1097 dbxout_begin_simple_stabs (name, N_BINCL);
1098 dbxout_stab_value_zero ();
1101 /* If there are pending bincls then it is time to emit all of them. */
1103 static inline void
1104 emit_pending_bincls_if_required (void)
1106 if (pending_bincls)
1107 emit_pending_bincls ();
1110 /* Emit all pending bincls. */
1112 static void
1113 emit_pending_bincls (void)
1115 struct dbx_file *f = current_file;
1117 /* Find first pending bincl. */
1118 while (f->bincl_status == BINCL_PENDING)
1119 f = f->next;
1121 /* Now emit all bincls. */
1122 f = f->prev;
1124 while (f)
1126 if (f->bincl_status == BINCL_PENDING)
1128 emit_bincl_stab (f->pending_bincl_name);
1130 /* Update file number and status. */
1131 f->file_number = next_file_number++;
1132 f->bincl_status = BINCL_PROCESSED;
1134 if (f == current_file)
1135 break;
1136 f = f->prev;
1139 /* All pending bincls have been emitted. */
1140 pending_bincls = 0;
1143 #else
1145 static inline void
1146 emit_pending_bincls_if_required (void) {}
1147 #endif
1149 /* Change to reading from a new source file. Generate a N_BINCL stab. */
1151 static void
1152 dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED,
1153 const char *filename ATTRIBUTE_UNUSED)
1155 #ifdef DBX_USE_BINCL
1156 struct dbx_file *n = XNEW (struct dbx_file);
1158 n->next = current_file;
1159 n->next_type_number = 1;
1160 /* Do not assign file number now.
1161 Delay it until we actually emit BINCL. */
1162 n->file_number = 0;
1163 n->prev = NULL;
1164 current_file->prev = n;
1165 n->bincl_status = BINCL_PENDING;
1166 n->pending_bincl_name = remap_debug_filename (filename);
1167 pending_bincls = 1;
1168 current_file = n;
1169 #endif
1172 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
1174 static void
1175 dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED)
1177 #ifdef DBX_USE_BINCL
1178 /* Emit EINCL stab only if BINCL is not pending. */
1179 if (current_file->bincl_status == BINCL_PROCESSED)
1181 dbxout_begin_stabn (N_EINCL);
1182 dbxout_stab_value_zero ();
1184 current_file->bincl_status = BINCL_NOT_REQUIRED;
1185 current_file = current_file->next;
1186 #endif
1189 /* Handle a few odd cases that occur when trying to make PCH files work. */
1191 static void
1192 dbxout_handle_pch (unsigned at_end)
1194 if (! at_end)
1196 /* When using the PCH, this file will be included, so we need to output
1197 a BINCL. */
1198 dbxout_start_source_file (0, lastfile);
1200 /* The base file when using the PCH won't be the same as
1201 the base file when it's being generated. */
1202 lastfile = NULL;
1204 else
1206 /* ... and an EINCL. */
1207 dbxout_end_source_file (0);
1209 /* Deal with cases where 'lastfile' was never actually changed. */
1210 lastfile_is_base = lastfile == NULL;
1214 #if defined (DBX_DEBUGGING_INFO)
1216 static void dbxout_block (tree, int, tree);
1218 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
1220 static void
1221 dbxout_source_file (const char *filename)
1223 if (lastfile == 0 && lastfile_is_base)
1225 lastfile = base_input_file;
1226 lastfile_is_base = 0;
1229 if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
1231 /* Don't change section amid function. */
1232 if (current_function_decl == NULL_TREE)
1233 switch_to_section (text_section);
1235 dbxout_begin_simple_stabs (remap_debug_filename (filename), N_SOL);
1236 dbxout_stab_value_internal_label ("Ltext", &source_label_number);
1237 lastfile = filename;
1241 /* Output N_BNSYM, line number symbol entry, and local symbol at
1242 function scope */
1244 static void
1245 dbxout_begin_prologue (unsigned int lineno,
1246 unsigned int column ATTRIBUTE_UNUSED,
1247 const char *filename)
1249 if (use_gnu_debug_info_extensions
1250 && !NO_DBX_FUNCTION_END
1251 && !NO_DBX_BNSYM_ENSYM
1252 && !flag_debug_only_used_symbols)
1253 dbxout_stabd (N_BNSYM, 0);
1255 /* pre-increment the scope counter */
1256 scope_labelno++;
1258 dbxout_source_line (lineno, 0, filename, 0, true);
1259 /* Output function begin block at function scope, referenced
1260 by dbxout_block, dbxout_source_line and dbxout_function_end. */
1261 emit_pending_bincls_if_required ();
1262 targetm.asm_out.internal_label (asm_out_file, "LFBB", scope_labelno);
1265 /* Output a line number symbol entry for source file FILENAME and line
1266 number LINENO. */
1268 static void
1269 dbxout_source_line (unsigned int lineno, unsigned int column ATTRIBUTE_UNUSED,
1270 const char *filename, int discriminator ATTRIBUTE_UNUSED,
1271 bool is_stmt ATTRIBUTE_UNUSED)
1273 dbxout_source_file (filename);
1275 #ifdef DBX_OUTPUT_SOURCE_LINE
1276 DBX_OUTPUT_SOURCE_LINE (asm_out_file, lineno, dbxout_source_line_counter);
1277 #else
1278 if (DBX_LINES_FUNCTION_RELATIVE)
1280 char begin_label[20];
1281 dbxout_begin_stabn_sline (lineno);
1282 /* Reference current function start using LFBB. */
1283 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
1284 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter,
1285 begin_label);
1287 else
1288 dbxout_stabd (N_SLINE, lineno);
1289 #endif
1292 /* Describe the beginning of an internal block within a function. */
1294 static void
1295 dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
1297 emit_pending_bincls_if_required ();
1298 targetm.asm_out.internal_label (asm_out_file, "LBB", n);
1301 /* Describe the end line-number of an internal block within a function. */
1303 static void
1304 dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
1306 emit_pending_bincls_if_required ();
1307 targetm.asm_out.internal_label (asm_out_file, "LBE", n);
1310 /* Output dbx data for a function definition.
1311 This includes a definition of the function name itself (a symbol),
1312 definitions of the parameters (locating them in the parameter list)
1313 and then output the block that makes up the function's body
1314 (including all the auto variables of the function). */
1316 static void
1317 dbxout_function_decl (tree decl)
1319 emit_pending_bincls_if_required ();
1320 #ifndef DBX_FUNCTION_FIRST
1321 dbxout_begin_function (decl);
1322 #endif
1323 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
1324 dbxout_function_end (decl);
1327 #endif /* DBX_DEBUGGING_INFO */
1329 static void
1330 dbxout_early_global_decl (tree decl ATTRIBUTE_UNUSED)
1332 /* NYI for non-dwarf. */
1335 /* Debug information for a global DECL. Called from toplev.c after
1336 compilation proper has finished. */
1337 static void
1338 dbxout_late_global_decl (tree decl)
1340 if (VAR_P (decl) && !DECL_EXTERNAL (decl))
1342 int saved_tree_used = TREE_USED (decl);
1343 TREE_USED (decl) = 1;
1344 dbxout_symbol (decl, 0);
1345 TREE_USED (decl) = saved_tree_used;
1349 /* This is just a function-type adapter; dbxout_symbol does exactly
1350 what we want but returns an int. */
1351 static void
1352 dbxout_type_decl (tree decl, int local)
1354 dbxout_symbol (decl, local);
1357 /* At the end of compilation, finish writing the symbol table.
1358 The default is to call debug_free_queue but do nothing else. */
1360 static void
1361 dbxout_finish (const char *filename ATTRIBUTE_UNUSED)
1363 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1364 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file, filename);
1365 #elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
1367 switch_to_section (text_section);
1368 dbxout_begin_empty_stabs (N_SO);
1369 dbxout_stab_value_internal_label ("Letext", 0);
1371 #endif
1372 debug_free_queue ();
1375 /* Output the index of a type. */
1377 static void
1378 dbxout_type_index (tree type)
1380 #ifndef DBX_USE_BINCL
1381 stabstr_D (TYPE_SYMTAB_ADDRESS (type));
1382 #else
1383 struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
1384 stabstr_C ('(');
1385 stabstr_D (t->file_number);
1386 stabstr_C (',');
1387 stabstr_D (t->type_number);
1388 stabstr_C (')');
1389 #endif
1393 /* Generate the symbols for any queued up type symbols we encountered
1394 while generating the type info for some originally used symbol.
1395 This might generate additional entries in the queue. Only when
1396 the nesting depth goes to 0 is this routine called. */
1398 static void
1399 debug_flush_symbol_queue (void)
1401 int i;
1403 /* Make sure that additionally queued items are not flushed
1404 prematurely. */
1406 ++debug_nesting;
1408 for (i = 0; i < symbol_queue_index; ++i)
1410 /* If we pushed queued symbols then such symbols must be
1411 output no matter what anyone else says. Specifically,
1412 we need to make sure dbxout_symbol() thinks the symbol was
1413 used and also we need to override TYPE_DECL_SUPPRESS_DEBUG
1414 which may be set for outside reasons. */
1415 int saved_tree_used = TREE_USED (symbol_queue[i]);
1416 int saved_suppress_debug = TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]);
1417 TREE_USED (symbol_queue[i]) = 1;
1418 TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]) = 0;
1420 #ifdef DBX_DEBUGGING_INFO
1421 dbxout_symbol (symbol_queue[i], 0);
1422 #endif
1424 TREE_USED (symbol_queue[i]) = saved_tree_used;
1425 TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]) = saved_suppress_debug;
1428 symbol_queue_index = 0;
1429 --debug_nesting;
1432 /* Queue a type symbol needed as part of the definition of a decl
1433 symbol. These symbols are generated when debug_flush_symbol_queue()
1434 is called. */
1436 static void
1437 debug_queue_symbol (tree decl)
1439 if (symbol_queue_index >= symbol_queue_size)
1441 symbol_queue_size += 10;
1442 symbol_queue = XRESIZEVEC (tree, symbol_queue, symbol_queue_size);
1445 symbol_queue[symbol_queue_index++] = decl;
1448 /* Free symbol queue. */
1449 static void
1450 debug_free_queue (void)
1452 if (symbol_queue)
1454 free (symbol_queue);
1455 symbol_queue = NULL;
1456 symbol_queue_size = 0;
1460 /* Used in several places: evaluates to '0' for a private decl,
1461 '1' for a protected decl, '2' for a public decl. */
1462 #define DECL_ACCESSIBILITY_CHAR(DECL) \
1463 (TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
1465 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
1466 This must be a separate function because anonymous unions require
1467 recursive calls. */
1469 static void
1470 dbxout_type_fields (tree type)
1472 tree tem;
1474 /* Output the name, type, position (in bits), size (in bits) of each
1475 field that we can support. */
1476 for (tem = TYPE_FIELDS (type); tem; tem = DECL_CHAIN (tem))
1478 /* If one of the nodes is an error_mark or its type is then
1479 return early. */
1480 if (error_operand_p (tem))
1481 return;
1483 /* Omit here local type decls until we know how to support them. */
1484 if (TREE_CODE (tem) == TYPE_DECL
1485 || TREE_CODE (tem) == TEMPLATE_DECL
1486 /* Omit here the nameless fields that are used to skip bits. */
1487 || DECL_IGNORED_P (tem)
1488 /* Omit fields whose position or size are variable or too large to
1489 represent. */
1490 || (TREE_CODE (tem) == FIELD_DECL
1491 && (! tree_fits_shwi_p (bit_position (tem))
1492 || ! DECL_SIZE (tem)
1493 || ! tree_fits_uhwi_p (DECL_SIZE (tem)))))
1494 continue;
1496 else if (TREE_CODE (tem) != CONST_DECL)
1498 /* Continue the line if necessary,
1499 but not before the first field. */
1500 if (tem != TYPE_FIELDS (type))
1501 CONTIN;
1503 if (DECL_NAME (tem))
1504 stabstr_I (DECL_NAME (tem));
1505 stabstr_C (':');
1507 if (use_gnu_debug_info_extensions
1508 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
1509 || TREE_CODE (tem) != FIELD_DECL))
1511 stabstr_C ('/');
1512 stabstr_C (DECL_ACCESSIBILITY_CHAR (tem));
1515 dbxout_type ((TREE_CODE (tem) == FIELD_DECL
1516 && DECL_BIT_FIELD_TYPE (tem))
1517 ? DECL_BIT_FIELD_TYPE (tem) : TREE_TYPE (tem), 0);
1519 if (VAR_P (tem))
1521 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
1523 tree name = DECL_ASSEMBLER_NAME (tem);
1525 stabstr_C (':');
1526 stabstr_I (name);
1527 stabstr_C (';');
1529 else
1530 /* If TEM is non-static, GDB won't understand it. */
1531 stabstr_S (",0,0;");
1533 else
1535 stabstr_C (',');
1536 stabstr_D (int_bit_position (tem));
1537 stabstr_C (',');
1538 stabstr_D (tree_to_uhwi (DECL_SIZE (tem)));
1539 stabstr_C (';');
1545 /* Subroutine of `dbxout_type_methods'. Output debug info about the
1546 method described DECL. */
1548 static void
1549 dbxout_type_method_1 (tree decl)
1551 char c1 = 'A', c2;
1553 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
1554 c2 = '?';
1555 else /* it's a METHOD_TYPE. */
1557 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
1558 /* A for normal functions.
1559 B for `const' member functions.
1560 C for `volatile' member functions.
1561 D for `const volatile' member functions. */
1562 if (TYPE_READONLY (TREE_TYPE (firstarg)))
1563 c1 += 1;
1564 if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
1565 c1 += 2;
1567 if (DECL_VINDEX (decl))
1568 c2 = '*';
1569 else
1570 c2 = '.';
1573 /* ??? Output the mangled name, which contains an encoding of the
1574 method's type signature. May not be necessary anymore. */
1575 stabstr_C (':');
1576 stabstr_I (DECL_ASSEMBLER_NAME (decl));
1577 stabstr_C (';');
1578 stabstr_C (DECL_ACCESSIBILITY_CHAR (decl));
1579 stabstr_C (c1);
1580 stabstr_C (c2);
1582 if (DECL_VINDEX (decl) && tree_fits_shwi_p (DECL_VINDEX (decl)))
1584 stabstr_D (tree_to_shwi (DECL_VINDEX (decl)));
1585 stabstr_C (';');
1586 dbxout_type (DECL_CONTEXT (decl), 0);
1587 stabstr_C (';');
1591 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
1592 in TYPE. */
1594 static void
1595 dbxout_type_methods (tree type)
1597 /* C++: put out the method names and their parameter lists */
1598 tree methods = TYPE_METHODS (type);
1599 tree fndecl;
1600 tree last;
1602 if (methods == NULL_TREE)
1603 return;
1605 if (TREE_CODE (methods) != TREE_VEC)
1606 fndecl = methods;
1607 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
1608 fndecl = TREE_VEC_ELT (methods, 0);
1609 else
1610 fndecl = TREE_VEC_ELT (methods, 1);
1612 while (fndecl)
1614 int need_prefix = 1;
1616 /* Group together all the methods for the same operation.
1617 These differ in the types of the arguments. */
1618 for (last = NULL_TREE;
1619 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
1620 fndecl = DECL_CHAIN (fndecl))
1621 /* Output the name of the field (after overloading), as
1622 well as the name of the field before overloading, along
1623 with its parameter list */
1625 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
1626 include TEMPLATE_DECLs.) The debugger doesn't know what
1627 to do with such entities anyhow. */
1628 if (TREE_CODE (fndecl) != FUNCTION_DECL)
1629 continue;
1631 CONTIN;
1633 last = fndecl;
1635 /* Also ignore abstract methods; those are only interesting to
1636 the DWARF backends. */
1637 if (DECL_IGNORED_P (fndecl) || DECL_ABSTRACT_P (fndecl))
1638 continue;
1640 /* Redundantly output the plain name, since that's what gdb
1641 expects. */
1642 if (need_prefix)
1644 stabstr_I (DECL_NAME (fndecl));
1645 stabstr_S ("::");
1646 need_prefix = 0;
1649 dbxout_type (TREE_TYPE (fndecl), 0);
1650 dbxout_type_method_1 (fndecl);
1652 if (!need_prefix)
1653 stabstr_C (';');
1657 /* Emit a "range" type specification, which has the form:
1658 "r<index type>;<lower bound>;<upper bound>;".
1659 TYPE is an INTEGER_TYPE, LOW and HIGH are the bounds. */
1661 static void
1662 dbxout_range_type (tree type, tree low, tree high)
1664 stabstr_C ('r');
1665 if (TREE_TYPE (type))
1666 dbxout_type (TREE_TYPE (type), 0);
1667 else if (TREE_CODE (type) != INTEGER_TYPE)
1668 dbxout_type (type, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1669 else
1671 /* Traditionally, we made sure 'int' was type 1, and builtin types
1672 were defined to be sub-ranges of int. Unfortunately, this
1673 does not allow us to distinguish true sub-ranges from integer
1674 types. So, instead we define integer (non-sub-range) types as
1675 sub-ranges of themselves. This matters for Chill. If this isn't
1676 a subrange type, then we want to define it in terms of itself.
1677 However, in C, this may be an anonymous integer type, and we don't
1678 want to emit debug info referring to it. Just calling
1679 dbxout_type_index won't work anyways, because the type hasn't been
1680 defined yet. We make this work for both cases by checked to see
1681 whether this is a defined type, referring to it if it is, and using
1682 'int' otherwise. */
1683 if (TYPE_SYMTAB_ADDRESS (type) != 0)
1684 dbxout_type_index (type);
1685 else
1686 dbxout_type_index (integer_type_node);
1689 stabstr_C (';');
1690 if (low && tree_fits_shwi_p (low))
1692 if (print_int_cst_bounds_in_octal_p (type, low, high))
1693 stabstr_O (low);
1694 else
1695 stabstr_D (tree_to_shwi (low));
1697 else
1698 stabstr_C ('0');
1700 stabstr_C (';');
1701 if (high && tree_fits_shwi_p (high))
1703 if (print_int_cst_bounds_in_octal_p (type, low, high))
1704 stabstr_O (high);
1705 else
1706 stabstr_D (tree_to_shwi (high));
1707 stabstr_C (';');
1709 else
1710 stabstr_S ("-1;");
1714 /* Output a reference to a type. If the type has not yet been
1715 described in the dbx output, output its definition now.
1716 For a type already defined, just refer to its definition
1717 using the type number.
1719 If FULL is nonzero, and the type has been described only with
1720 a forward-reference, output the definition now.
1721 If FULL is zero in this case, just refer to the forward-reference
1722 using the number previously allocated. */
1724 static void
1725 dbxout_type (tree type, int full)
1727 static int anonymous_type_number = 0;
1728 tree tem, main_variant, low, high;
1730 if (TREE_CODE (type) == INTEGER_TYPE)
1732 if (TREE_TYPE (type) == 0)
1734 low = TYPE_MIN_VALUE (type);
1735 high = TYPE_MAX_VALUE (type);
1738 else if (subrange_type_for_debug_p (type, &low, &high))
1741 /* If this is a subtype that should not be emitted as a subrange type,
1742 use the base type. */
1743 else
1745 type = TREE_TYPE (type);
1746 low = TYPE_MIN_VALUE (type);
1747 high = TYPE_MAX_VALUE (type);
1751 /* If there was an input error and we don't really have a type,
1752 avoid crashing and write something that is at least valid
1753 by assuming `int'. */
1754 if (type == error_mark_node)
1755 type = integer_type_node;
1756 else
1758 if (TYPE_NAME (type)
1759 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1760 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
1761 full = 0;
1764 /* Try to find the "main variant" with the same name. */
1765 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1766 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1767 main_variant = TREE_TYPE (TYPE_NAME (type));
1768 else
1769 main_variant = TYPE_MAIN_VARIANT (type);
1771 /* If we are not using extensions, stabs does not distinguish const and
1772 volatile, so there is no need to make them separate types. */
1773 if (!use_gnu_debug_info_extensions)
1774 type = main_variant;
1776 if (TYPE_SYMTAB_ADDRESS (type) == 0)
1778 /* Type has no dbx number assigned. Assign next available number. */
1779 TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
1781 /* Make sure type vector is long enough to record about this type. */
1783 if (next_type_number == typevec_len)
1785 typevec = GGC_RESIZEVEC (struct typeinfo, typevec, typevec_len * 2);
1786 memset (typevec + typevec_len, 0, typevec_len * sizeof typevec[0]);
1787 typevec_len *= 2;
1790 #ifdef DBX_USE_BINCL
1791 emit_pending_bincls_if_required ();
1792 typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
1793 = current_file->file_number;
1794 typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
1795 = current_file->next_type_number++;
1796 #endif
1799 if (flag_debug_only_used_symbols)
1801 if ((TREE_CODE (type) == RECORD_TYPE
1802 || TREE_CODE (type) == UNION_TYPE
1803 || TREE_CODE (type) == QUAL_UNION_TYPE
1804 || TREE_CODE (type) == ENUMERAL_TYPE)
1805 && TYPE_STUB_DECL (type)
1806 && DECL_P (TYPE_STUB_DECL (type))
1807 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
1808 debug_queue_symbol (TYPE_STUB_DECL (type));
1809 else if (TYPE_NAME (type)
1810 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1811 debug_queue_symbol (TYPE_NAME (type));
1814 /* Output the number of this type, to refer to it. */
1815 dbxout_type_index (type);
1817 #ifdef DBX_TYPE_DEFINED
1818 if (DBX_TYPE_DEFINED (type))
1819 return;
1820 #endif
1822 /* If this type's definition has been output or is now being output,
1823 that is all. */
1825 switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
1827 case TYPE_UNSEEN:
1828 break;
1829 case TYPE_XREF:
1830 /* If we have already had a cross reference,
1831 and either that's all we want or that's the best we could do,
1832 don't repeat the cross reference.
1833 Sun dbx crashes if we do. */
1834 if (! full || !COMPLETE_TYPE_P (type)
1835 /* No way in DBX fmt to describe a variable size. */
1836 || ! tree_fits_uhwi_p (TYPE_SIZE (type)))
1837 return;
1838 break;
1839 case TYPE_DEFINED:
1840 return;
1843 #ifdef DBX_NO_XREFS
1844 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1845 leave the type-number completely undefined rather than output
1846 a cross-reference. If we have already used GNU debug info extensions,
1847 then it is OK to output a cross reference. This is necessary to get
1848 proper C++ debug output. */
1849 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
1850 || TREE_CODE (type) == QUAL_UNION_TYPE
1851 || TREE_CODE (type) == ENUMERAL_TYPE)
1852 && ! use_gnu_debug_info_extensions)
1853 /* We must use the same test here as we use twice below when deciding
1854 whether to emit a cross-reference. */
1855 if ((TYPE_NAME (type) != 0
1856 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1857 && DECL_IGNORED_P (TYPE_NAME (type)))
1858 && !full)
1859 || !COMPLETE_TYPE_P (type)
1860 /* No way in DBX fmt to describe a variable size. */
1861 || ! tree_fits_uhwi_p (TYPE_SIZE (type)))
1863 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1864 return;
1866 #endif
1868 /* Output a definition now. */
1869 stabstr_C ('=');
1871 /* Mark it as defined, so that if it is self-referent
1872 we will not get into an infinite recursion of definitions. */
1874 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
1876 /* If this type is a variant of some other, hand off. Types with
1877 different names are usefully distinguished. We only distinguish
1878 cv-qualified types if we're using extensions. */
1879 if (TYPE_READONLY (type) > TYPE_READONLY (main_variant))
1881 stabstr_C ('k');
1882 dbxout_type (build_type_variant (type, 0, TYPE_VOLATILE (type)), 0);
1883 return;
1885 else if (TYPE_VOLATILE (type) > TYPE_VOLATILE (main_variant))
1887 stabstr_C ('B');
1888 dbxout_type (build_type_variant (type, TYPE_READONLY (type), 0), 0);
1889 return;
1891 else if (main_variant != TYPE_MAIN_VARIANT (type))
1893 if (flag_debug_only_used_symbols)
1895 tree orig_type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
1897 if ((TREE_CODE (orig_type) == RECORD_TYPE
1898 || TREE_CODE (orig_type) == UNION_TYPE
1899 || TREE_CODE (orig_type) == QUAL_UNION_TYPE
1900 || TREE_CODE (orig_type) == ENUMERAL_TYPE)
1901 && TYPE_STUB_DECL (orig_type)
1902 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type)))
1903 debug_queue_symbol (TYPE_STUB_DECL (orig_type));
1905 /* 'type' is a typedef; output the type it refers to. */
1906 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0);
1907 return;
1909 /* else continue. */
1911 switch (TREE_CODE (type))
1913 case VOID_TYPE:
1914 case NULLPTR_TYPE:
1915 case LANG_TYPE:
1916 /* For a void type, just define it as itself; i.e., "5=5".
1917 This makes us consider it defined
1918 without saying what it is. The debugger will make it
1919 a void type when the reference is seen, and nothing will
1920 ever override that default. */
1921 dbxout_type_index (type);
1922 break;
1924 case INTEGER_TYPE:
1925 if (type == char_type_node && ! TYPE_UNSIGNED (type))
1927 /* Output the type `char' as a subrange of itself!
1928 I don't understand this definition, just copied it
1929 from the output of pcc.
1930 This used to use `r2' explicitly and we used to
1931 take care to make sure that `char' was type number 2. */
1932 stabstr_C ('r');
1933 dbxout_type_index (type);
1934 stabstr_S (";0;127;");
1937 /* If this is a subtype of another integer type, always prefer to
1938 write it as a subtype. */
1939 else if (TREE_TYPE (type) != 0
1940 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
1942 /* If the size is non-standard, say what it is if we can use
1943 GDB extensions. */
1945 if (use_gnu_debug_info_extensions
1946 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1948 stabstr_S ("@s");
1949 stabstr_D (TYPE_PRECISION (type));
1950 stabstr_C (';');
1953 dbxout_range_type (type, low, high);
1956 else
1958 /* If the size is non-standard, say what it is if we can use
1959 GDB extensions. */
1961 if (use_gnu_debug_info_extensions
1962 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1964 stabstr_S ("@s");
1965 stabstr_D (TYPE_PRECISION (type));
1966 stabstr_C (';');
1969 if (print_int_cst_bounds_in_octal_p (type, low, high))
1971 stabstr_C ('r');
1973 /* If this type derives from another type, output type index of
1974 parent type. This is particularly important when parent type
1975 is an enumerated type, because not generating the parent type
1976 index would transform the definition of this enumerated type
1977 into a plain unsigned type. */
1978 if (TREE_TYPE (type) != 0)
1979 dbxout_type_index (TREE_TYPE (type));
1980 else
1981 dbxout_type_index (type);
1983 stabstr_C (';');
1984 stabstr_O (low);
1985 stabstr_C (';');
1986 stabstr_O (high);
1987 stabstr_C (';');
1990 else
1991 /* Output other integer types as subranges of `int'. */
1992 dbxout_range_type (type, low, high);
1995 break;
1997 case REAL_TYPE:
1998 case FIXED_POINT_TYPE:
1999 /* This used to say `r1' and we used to take care
2000 to make sure that `int' was type number 1. */
2001 stabstr_C ('r');
2002 dbxout_type_index (integer_type_node);
2003 stabstr_C (';');
2004 stabstr_D (int_size_in_bytes (type));
2005 stabstr_S (";0;");
2006 break;
2008 case BOOLEAN_TYPE:
2009 if (use_gnu_debug_info_extensions)
2011 stabstr_S ("@s");
2012 stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
2013 stabstr_S (";-16;");
2015 else /* Define as enumeral type (False, True) */
2016 stabstr_S ("eFalse:0,True:1,;");
2017 break;
2019 case COMPLEX_TYPE:
2020 /* Differs from the REAL_TYPE by its new data type number.
2021 R3 is NF_COMPLEX. We don't try to use any of the other NF_*
2022 codes since gdb doesn't care anyway. */
2024 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
2026 stabstr_S ("R3;");
2027 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type)));
2028 stabstr_S (";0;");
2030 else
2032 /* Output a complex integer type as a structure,
2033 pending some other way to do it. */
2034 stabstr_C ('s');
2035 stabstr_D (int_size_in_bytes (type));
2037 stabstr_S ("real:");
2038 dbxout_type (TREE_TYPE (type), 0);
2039 stabstr_S (",0,");
2040 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
2042 stabstr_S (";imag:");
2043 dbxout_type (TREE_TYPE (type), 0);
2044 stabstr_C (',');
2045 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
2046 stabstr_C (',');
2047 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
2048 stabstr_S (";;");
2050 break;
2052 case ARRAY_TYPE:
2053 /* Make arrays of packed bits look like bitstrings for chill. */
2054 if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
2056 stabstr_S ("@s");
2057 stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
2058 stabstr_S (";@S;S");
2059 dbxout_type (TYPE_DOMAIN (type), 0);
2060 break;
2063 /* Output "a" followed by a range type definition
2064 for the index type of the array
2065 followed by a reference to the target-type.
2066 ar1;0;N;M for a C array of type M and size N+1. */
2067 /* Check if a character string type, which in Chill is
2068 different from an array of characters. */
2069 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
2071 stabstr_S ("@S;");
2073 tem = TYPE_DOMAIN (type);
2074 if (tem == NULL)
2076 stabstr_S ("ar");
2077 dbxout_type_index (integer_type_node);
2078 stabstr_S (";0;-1;");
2080 else
2082 stabstr_C ('a');
2083 dbxout_range_type (tem, TYPE_MIN_VALUE (tem), TYPE_MAX_VALUE (tem));
2086 dbxout_type (TREE_TYPE (type), 0);
2087 break;
2089 case VECTOR_TYPE:
2090 /* Make vectors look like an array. */
2091 if (use_gnu_debug_info_extensions)
2092 stabstr_S ("@V;");
2094 /* Output "a" followed by a range type definition
2095 for the index type of the array
2096 followed by a reference to the target-type.
2097 ar1;0;N;M for a C array of type M and size N+1. */
2098 stabstr_C ('a');
2099 dbxout_range_type (integer_type_node, size_zero_node,
2100 size_int (TYPE_VECTOR_SUBPARTS (type) - 1));
2102 dbxout_type (TREE_TYPE (type), 0);
2103 break;
2105 case RECORD_TYPE:
2106 case UNION_TYPE:
2107 case QUAL_UNION_TYPE:
2109 tree binfo = TYPE_BINFO (type);
2111 /* Output a structure type. We must use the same test here as we
2112 use in the DBX_NO_XREFS case above. */
2113 if ((TYPE_NAME (type) != 0
2114 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
2115 && DECL_IGNORED_P (TYPE_NAME (type)))
2116 && !full)
2117 || !COMPLETE_TYPE_P (type)
2118 /* No way in DBX fmt to describe a variable size. */
2119 || ! tree_fits_uhwi_p (TYPE_SIZE (type)))
2121 /* If the type is just a cross reference, output one
2122 and mark the type as partially described.
2123 If it later becomes defined, we will output
2124 its real definition.
2125 If the type has a name, don't nest its definition within
2126 another type's definition; instead, output an xref
2127 and let the definition come when the name is defined. */
2128 stabstr_S ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
2129 if (TYPE_IDENTIFIER (type))
2131 /* Note that the C frontend creates for anonymous variable
2132 length records/unions TYPE_NAME with DECL_NAME NULL. */
2133 dbxout_type_name (type);
2135 else
2137 stabstr_S ("$$");
2138 stabstr_D (anonymous_type_number++);
2141 stabstr_C (':');
2142 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
2143 break;
2146 /* Identify record or union, and print its size. */
2147 stabstr_C ((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u');
2148 stabstr_D (int_size_in_bytes (type));
2150 if (binfo)
2152 int i;
2153 tree child;
2154 vec<tree, va_gc> *accesses = BINFO_BASE_ACCESSES (binfo);
2156 if (use_gnu_debug_info_extensions)
2158 if (BINFO_N_BASE_BINFOS (binfo))
2160 stabstr_C ('!');
2161 stabstr_U (BINFO_N_BASE_BINFOS (binfo));
2162 stabstr_C (',');
2165 for (i = 0; BINFO_BASE_ITERATE (binfo, i, child); i++)
2167 tree access = (accesses ? (*accesses)[i] : access_public_node);
2169 if (use_gnu_debug_info_extensions)
2171 stabstr_C (BINFO_VIRTUAL_P (child) ? '1' : '0');
2172 stabstr_C (access == access_public_node ? '2' :
2173 access == access_protected_node
2174 ? '1' :'0');
2175 if (BINFO_VIRTUAL_P (child)
2176 && (lang_GNU_CXX ()
2177 || strcmp (lang_hooks.name, "GNU Objective-C++") == 0))
2178 /* For a virtual base, print the (negative)
2179 offset within the vtable where we must look
2180 to find the necessary adjustment. */
2181 stabstr_D
2182 (tree_to_shwi (BINFO_VPTR_FIELD (child))
2183 * BITS_PER_UNIT);
2184 else
2185 stabstr_D (tree_to_shwi (BINFO_OFFSET (child))
2186 * BITS_PER_UNIT);
2187 stabstr_C (',');
2188 dbxout_type (BINFO_TYPE (child), 0);
2189 stabstr_C (';');
2191 else
2193 /* Print out the base class information with
2194 fields which have the same names at the types
2195 they hold. */
2196 dbxout_type_name (BINFO_TYPE (child));
2197 stabstr_C (':');
2198 dbxout_type (BINFO_TYPE (child), full);
2199 stabstr_C (',');
2200 stabstr_D (tree_to_shwi (BINFO_OFFSET (child))
2201 * BITS_PER_UNIT);
2202 stabstr_C (',');
2203 stabstr_D
2204 (tree_to_shwi (TYPE_SIZE (BINFO_TYPE (child)))
2205 * BITS_PER_UNIT);
2206 stabstr_C (';');
2212 /* Write out the field declarations. */
2213 dbxout_type_fields (type);
2214 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
2216 dbxout_type_methods (type);
2219 stabstr_C (';');
2221 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
2222 /* Avoid the ~ if we don't really need it--it confuses dbx. */
2223 && TYPE_VFIELD (type))
2226 /* We need to write out info about what field this class
2227 uses as its "main" vtable pointer field, because if this
2228 field is inherited from a base class, GDB cannot necessarily
2229 figure out which field it's using in time. */
2230 stabstr_S ("~%");
2231 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
2232 stabstr_C (';');
2234 break;
2236 case ENUMERAL_TYPE:
2237 /* We must use the same test here as we use in the DBX_NO_XREFS case
2238 above. We simplify it a bit since an enum will never have a variable
2239 size. */
2240 if ((TYPE_NAME (type) != 0
2241 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
2242 && DECL_IGNORED_P (TYPE_NAME (type)))
2243 && !full)
2244 || !COMPLETE_TYPE_P (type))
2246 stabstr_S ("xe");
2247 dbxout_type_name (type);
2248 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
2249 stabstr_C (':');
2250 return;
2252 if (use_gnu_debug_info_extensions
2253 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
2255 stabstr_S ("@s");
2256 stabstr_D (TYPE_PRECISION (type));
2257 stabstr_C (';');
2260 stabstr_C ('e');
2261 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
2263 tree value = TREE_VALUE (tem);
2265 stabstr_I (TREE_PURPOSE (tem));
2266 stabstr_C (':');
2268 if (TREE_CODE (value) == CONST_DECL)
2269 value = DECL_INITIAL (value);
2271 if (cst_and_fits_in_hwi (value))
2272 stabstr_D (TREE_INT_CST_LOW (value));
2273 else
2274 stabstr_O (value);
2276 stabstr_C (',');
2277 if (TREE_CHAIN (tem) != 0)
2278 CONTIN;
2281 stabstr_C (';');
2282 break;
2284 case POINTER_TYPE:
2285 stabstr_C ('*');
2286 dbxout_type (TREE_TYPE (type), 0);
2287 break;
2289 case METHOD_TYPE:
2290 if (use_gnu_debug_info_extensions)
2292 stabstr_C ('#');
2294 /* Write the argument types out longhand. */
2295 dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
2296 stabstr_C (',');
2297 dbxout_type (TREE_TYPE (type), 0);
2298 dbxout_args (TYPE_ARG_TYPES (type));
2299 stabstr_C (';');
2301 else
2302 /* Treat it as a function type. */
2303 dbxout_type (TREE_TYPE (type), 0);
2304 break;
2306 case OFFSET_TYPE:
2307 if (use_gnu_debug_info_extensions)
2309 stabstr_C ('@');
2310 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
2311 stabstr_C (',');
2312 dbxout_type (TREE_TYPE (type), 0);
2314 else
2315 /* Should print as an int, because it is really just an offset. */
2316 dbxout_type (integer_type_node, 0);
2317 break;
2319 case REFERENCE_TYPE:
2320 if (use_gnu_debug_info_extensions)
2322 stabstr_C ('&');
2324 else
2325 stabstr_C ('*');
2326 dbxout_type (TREE_TYPE (type), 0);
2327 break;
2329 case FUNCTION_TYPE:
2330 stabstr_C ('f');
2331 dbxout_type (TREE_TYPE (type), 0);
2332 break;
2334 case POINTER_BOUNDS_TYPE:
2335 /* No debug info for pointer bounds type supported yet. */
2336 break;
2338 default:
2339 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
2340 named 'auto' in its type.
2341 No debug info for TEMPLATE_TYPE_PARM type supported yet. */
2342 if (lang_GNU_CXX ())
2344 tree name = TYPE_IDENTIFIER (type);
2345 if (name == get_identifier ("auto")
2346 || name == get_identifier ("decltype(auto)"))
2347 break;
2350 gcc_unreachable ();
2354 /* Return nonzero if the given type represents an integer whose bounds
2355 should be printed in octal format. */
2357 static bool
2358 print_int_cst_bounds_in_octal_p (tree type, tree low, tree high)
2360 /* If we can use GDB extensions and the size is wider than a long
2361 (the size used by GDB to read them) or we may have trouble writing
2362 the bounds the usual way, write them in octal. Note the test is for
2363 the *target's* size of "long", not that of the host. The host test
2364 is just to make sure we can write it out in case the host wide int
2365 is narrower than the target "long".
2367 For unsigned types, we use octal if they are the same size or larger.
2368 This is because we print the bounds as signed decimal, and hence they
2369 can't span same size unsigned types. */
2371 if (use_gnu_debug_info_extensions
2372 && low && TREE_CODE (low) == INTEGER_CST
2373 && high && TREE_CODE (high) == INTEGER_CST
2374 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
2375 || ((TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2376 && TYPE_UNSIGNED (type))
2377 || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
2378 || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
2379 && TYPE_UNSIGNED (type))))
2380 return TRUE;
2381 else
2382 return FALSE;
2385 /* Output the name of type TYPE, with no punctuation.
2386 Such names can be set up either by typedef declarations
2387 or by struct, enum and union tags. */
2389 static void
2390 dbxout_type_name (tree type)
2392 tree t = TYPE_NAME (type);
2394 gcc_assert (t);
2395 switch (TREE_CODE (t))
2397 case IDENTIFIER_NODE:
2398 break;
2399 case TYPE_DECL:
2400 t = DECL_NAME (t);
2401 break;
2402 default:
2403 gcc_unreachable ();
2406 stabstr_I (t);
2409 /* Output leading struct or class names needed for qualifying type
2410 whose scope is limited to a struct or class. */
2412 static void
2413 dbxout_class_name_qualifiers (tree decl)
2415 tree context = decl_type_context (decl);
2417 if (context != NULL_TREE
2418 && TREE_CODE (context) == RECORD_TYPE
2419 && TYPE_NAME (context) != 0
2420 && (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE
2421 || (DECL_NAME (TYPE_NAME (context)) != 0)))
2423 tree name = TYPE_NAME (context);
2425 if (TREE_CODE (name) == TYPE_DECL)
2427 dbxout_class_name_qualifiers (name);
2428 name = DECL_NAME (name);
2430 stabstr_I (name);
2431 stabstr_S ("::");
2435 /* This is a specialized subset of expand_expr for use by dbxout_symbol in
2436 evaluating DECL_VALUE_EXPR. In particular, we stop if we find decls that
2437 haven't been expanded, or if the expression is getting so complex we won't
2438 be able to represent it in stabs anyway. Returns NULL on failure. */
2440 static rtx
2441 dbxout_expand_expr (tree expr)
2443 switch (TREE_CODE (expr))
2445 case VAR_DECL:
2446 /* We can't handle emulated tls variables, because the address is an
2447 offset to the return value of __emutls_get_address, and there is no
2448 way to express that in stabs. Also, there are name mangling issues
2449 here. We end up with references to undefined symbols if we don't
2450 disable debug info for these variables. */
2451 if (!targetm.have_tls && DECL_THREAD_LOCAL_P (expr))
2452 return NULL;
2453 if (TREE_STATIC (expr)
2454 && !TREE_ASM_WRITTEN (expr)
2455 && !DECL_HAS_VALUE_EXPR_P (expr)
2456 && !TREE_PUBLIC (expr)
2457 && DECL_RTL_SET_P (expr)
2458 && MEM_P (DECL_RTL (expr)))
2460 /* If this is a var that might not be actually output,
2461 return NULL, otherwise stabs might reference an undefined
2462 symbol. */
2463 varpool_node *node = varpool_node::get (expr);
2464 if (!node || !node->definition)
2465 return NULL;
2467 /* FALLTHRU */
2469 case PARM_DECL:
2470 case RESULT_DECL:
2471 if (DECL_HAS_VALUE_EXPR_P (expr))
2472 return dbxout_expand_expr (DECL_VALUE_EXPR (expr));
2473 /* FALLTHRU */
2475 case CONST_DECL:
2476 return DECL_RTL_IF_SET (expr);
2478 case INTEGER_CST:
2479 return expand_expr (expr, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
2481 case COMPONENT_REF:
2482 case ARRAY_REF:
2483 case ARRAY_RANGE_REF:
2484 case BIT_FIELD_REF:
2486 machine_mode mode;
2487 HOST_WIDE_INT bitsize, bitpos;
2488 tree offset, tem;
2489 int unsignedp, reversep, volatilep = 0;
2490 rtx x;
2492 tem = get_inner_reference (expr, &bitsize, &bitpos, &offset, &mode,
2493 &unsignedp, &reversep, &volatilep);
2495 x = dbxout_expand_expr (tem);
2496 if (x == NULL || !MEM_P (x))
2497 return NULL;
2498 if (offset != NULL)
2500 if (!tree_fits_shwi_p (offset))
2501 return NULL;
2502 x = adjust_address_nv (x, mode, tree_to_shwi (offset));
2504 if (bitpos != 0)
2505 x = adjust_address_nv (x, mode, bitpos / BITS_PER_UNIT);
2507 return x;
2510 default:
2511 return NULL;
2515 /* Helper function for output_used_types. Queue one entry from the
2516 used types hash to be output. */
2518 bool
2519 output_used_types_helper (tree const &type, vec<tree> *types_p)
2521 if ((TREE_CODE (type) == RECORD_TYPE
2522 || TREE_CODE (type) == UNION_TYPE
2523 || TREE_CODE (type) == QUAL_UNION_TYPE
2524 || TREE_CODE (type) == ENUMERAL_TYPE)
2525 && TYPE_STUB_DECL (type)
2526 && DECL_P (TYPE_STUB_DECL (type))
2527 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
2528 types_p->quick_push (TYPE_STUB_DECL (type));
2529 else if (TYPE_NAME (type)
2530 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2531 types_p->quick_push (TYPE_NAME (type));
2533 return true;
2536 /* This is a qsort callback which sorts types and declarations into a
2537 predictable order (types, then declarations, sorted by UID
2538 within). */
2540 static int
2541 output_types_sort (const void *pa, const void *pb)
2543 const tree lhs = *((const tree *)pa);
2544 const tree rhs = *((const tree *)pb);
2546 if (TYPE_P (lhs))
2548 if (TYPE_P (rhs))
2549 return TYPE_UID (lhs) - TYPE_UID (rhs);
2550 else
2551 return 1;
2553 else
2555 if (TYPE_P (rhs))
2556 return -1;
2557 else
2558 return DECL_UID (lhs) - DECL_UID (rhs);
2563 /* Force all types used by this function to be output in debug
2564 information. */
2566 static void
2567 output_used_types (void)
2569 if (cfun && cfun->used_types_hash)
2571 vec<tree> types;
2572 int i;
2573 tree type;
2575 types.create (cfun->used_types_hash->elements ());
2576 cfun->used_types_hash->traverse<vec<tree> *, output_used_types_helper>
2577 (&types);
2579 /* Sort by UID to prevent dependence on hash table ordering. */
2580 types.qsort (output_types_sort);
2582 FOR_EACH_VEC_ELT (types, i, type)
2583 debug_queue_symbol (type);
2585 types.release ();
2589 /* Output a .stabs for the symbol defined by DECL,
2590 which must be a ..._DECL node in the normal namespace.
2591 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2592 LOCAL is nonzero if the scope is less than the entire file.
2593 Return 1 if a stabs might have been emitted. */
2596 dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
2598 tree type = TREE_TYPE (decl);
2599 tree context = NULL_TREE;
2600 int result = 0;
2601 rtx decl_rtl;
2603 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
2604 ++debug_nesting;
2606 /* Ignore nameless syms, but don't ignore type tags. */
2608 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
2609 || DECL_IGNORED_P (decl))
2610 DBXOUT_DECR_NESTING_AND_RETURN (0);
2612 /* If we are to generate only the symbols actually used then such
2613 symbol nodes are flagged with TREE_USED. Ignore any that
2614 aren't flagged as TREE_USED. */
2616 if (flag_debug_only_used_symbols
2617 && (!TREE_USED (decl)
2618 && (!VAR_P (decl) || !DECL_INITIAL (decl))))
2619 DBXOUT_DECR_NESTING_AND_RETURN (0);
2621 /* If dbxout_init has not yet run, queue this symbol for later. */
2622 if (!typevec)
2624 preinit_symbols = tree_cons (0, decl, preinit_symbols);
2625 DBXOUT_DECR_NESTING_AND_RETURN (0);
2628 if (flag_debug_only_used_symbols)
2630 tree t;
2632 /* We now have a used symbol. We need to generate the info for
2633 the symbol's type in addition to the symbol itself. These
2634 type symbols are queued to be generated after were done with
2635 the symbol itself (otherwise they would fight over the
2636 stabstr obstack).
2638 Note, because the TREE_TYPE(type) might be something like a
2639 pointer to a named type we need to look for the first name
2640 we see following the TREE_TYPE chain. */
2642 t = type;
2643 while (POINTER_TYPE_P (t))
2644 t = TREE_TYPE (t);
2646 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2647 need special treatment. The TYPE_STUB_DECL field in these
2648 types generally represents the tag name type we want to
2649 output. In addition there could be a typedef type with
2650 a different name. In that case we also want to output
2651 that. */
2653 if (TREE_CODE (t) == RECORD_TYPE
2654 || TREE_CODE (t) == UNION_TYPE
2655 || TREE_CODE (t) == QUAL_UNION_TYPE
2656 || TREE_CODE (t) == ENUMERAL_TYPE)
2658 if (TYPE_STUB_DECL (t)
2659 && TYPE_STUB_DECL (t) != decl
2660 && DECL_P (TYPE_STUB_DECL (t))
2661 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t)))
2663 debug_queue_symbol (TYPE_STUB_DECL (t));
2664 if (TYPE_NAME (t)
2665 && TYPE_NAME (t) != TYPE_STUB_DECL (t)
2666 && TYPE_NAME (t) != decl
2667 && DECL_P (TYPE_NAME (t)))
2668 debug_queue_symbol (TYPE_NAME (t));
2671 else if (TYPE_NAME (t)
2672 && TYPE_NAME (t) != decl
2673 && DECL_P (TYPE_NAME (t)))
2674 debug_queue_symbol (TYPE_NAME (t));
2677 emit_pending_bincls_if_required ();
2679 switch (TREE_CODE (decl))
2681 case CONST_DECL:
2682 /* Enum values are defined by defining the enum type. */
2683 break;
2685 case FUNCTION_DECL:
2686 decl_rtl = DECL_RTL_IF_SET (decl);
2687 if (!decl_rtl)
2688 DBXOUT_DECR_NESTING_AND_RETURN (0);
2689 if (DECL_EXTERNAL (decl))
2690 break;
2691 /* Don't mention a nested function under its parent. */
2692 context = decl_function_context (decl);
2693 if (context == current_function_decl)
2694 break;
2695 /* Don't mention an inline instance of a nested function. */
2696 if (context && DECL_FROM_INLINE (decl))
2697 break;
2698 if (!MEM_P (decl_rtl)
2699 || GET_CODE (XEXP (decl_rtl, 0)) != SYMBOL_REF)
2700 break;
2702 if (flag_debug_only_used_symbols)
2703 output_used_types ();
2705 dbxout_begin_complex_stabs ();
2706 stabstr_I (DECL_ASSEMBLER_NAME (decl));
2707 stabstr_S (TREE_PUBLIC (decl) ? ":F" : ":f");
2708 result = 1;
2710 if (TREE_TYPE (type))
2711 dbxout_type (TREE_TYPE (type), 0);
2712 else
2713 dbxout_type (void_type_node, 0);
2715 /* For a nested function, when that function is compiled,
2716 mention the containing function name
2717 as well as (since dbx wants it) our own assembler-name. */
2718 if (context != 0)
2720 stabstr_C (',');
2721 stabstr_I (DECL_ASSEMBLER_NAME (decl));
2722 stabstr_C (',');
2723 stabstr_I (DECL_NAME (context));
2726 dbxout_finish_complex_stabs (decl, N_FUN, XEXP (decl_rtl, 0), 0, 0);
2727 break;
2729 case TYPE_DECL:
2730 /* Don't output the same typedef twice.
2731 And don't output what language-specific stuff doesn't want output. */
2732 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
2733 DBXOUT_DECR_NESTING_AND_RETURN (0);
2735 /* Don't output typedefs for types with magic type numbers (XCOFF). */
2736 #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2738 int fundamental_type_number =
2739 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl);
2741 if (fundamental_type_number != 0)
2743 TREE_ASM_WRITTEN (decl) = 1;
2744 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = fundamental_type_number;
2745 DBXOUT_DECR_NESTING_AND_RETURN (0);
2748 #endif
2749 FORCE_TEXT;
2750 result = 1;
2752 int tag_needed = 1;
2753 int did_output = 0;
2755 if (DECL_NAME (decl))
2757 /* Nonzero means we must output a tag as well as a typedef. */
2758 tag_needed = 0;
2760 /* Handle the case of a C++ structure or union
2761 where the TYPE_NAME is a TYPE_DECL
2762 which gives both a typedef name and a tag. */
2763 /* dbx requires the tag first and the typedef second. */
2764 if ((TREE_CODE (type) == RECORD_TYPE
2765 || TREE_CODE (type) == UNION_TYPE
2766 || TREE_CODE (type) == QUAL_UNION_TYPE)
2767 && TYPE_NAME (type) == decl
2768 && !use_gnu_debug_info_extensions
2769 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
2770 /* Distinguish the implicit typedefs of C++
2771 from explicit ones that might be found in C. */
2772 && DECL_ARTIFICIAL (decl)
2773 /* Do not generate a tag for incomplete records. */
2774 && COMPLETE_TYPE_P (type)
2775 /* Do not generate a tag for records of variable size,
2776 since this type can not be properly described in the
2777 DBX format, and it confuses some tools such as objdump. */
2778 && tree_fits_uhwi_p (TYPE_SIZE (type)))
2780 tree name = TYPE_IDENTIFIER (type);
2782 dbxout_begin_complex_stabs ();
2783 stabstr_I (name);
2784 stabstr_S (":T");
2785 dbxout_type (type, 1);
2786 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE,
2787 0, 0, 0);
2790 dbxout_begin_complex_stabs ();
2792 /* Output leading class/struct qualifiers. */
2793 if (use_gnu_debug_info_extensions)
2794 dbxout_class_name_qualifiers (decl);
2796 /* Output typedef name. */
2797 stabstr_I (DECL_NAME (decl));
2798 stabstr_C (':');
2800 /* Short cut way to output a tag also. */
2801 if ((TREE_CODE (type) == RECORD_TYPE
2802 || TREE_CODE (type) == UNION_TYPE
2803 || TREE_CODE (type) == QUAL_UNION_TYPE)
2804 && TYPE_NAME (type) == decl
2805 /* Distinguish the implicit typedefs of C++
2806 from explicit ones that might be found in C. */
2807 && DECL_ARTIFICIAL (decl))
2809 if (use_gnu_debug_info_extensions)
2811 stabstr_C ('T');
2812 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
2816 stabstr_C ('t');
2817 dbxout_type (type, 1);
2818 dbxout_finish_complex_stabs (decl, DBX_TYPE_DECL_STABS_CODE,
2819 0, 0, 0);
2820 did_output = 1;
2823 /* Don't output a tag if this is an incomplete type. This prevents
2824 the sun4 Sun OS 4.x dbx from crashing. */
2826 if (tag_needed && TYPE_NAME (type) != 0
2827 && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
2828 || (DECL_NAME (TYPE_NAME (type)) != 0))
2829 && COMPLETE_TYPE_P (type)
2830 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
2832 /* For a TYPE_DECL with no name, but the type has a name,
2833 output a tag.
2834 This is what represents `struct foo' with no typedef. */
2835 /* In C++, the name of a type is the corresponding typedef.
2836 In C, it is an IDENTIFIER_NODE. */
2837 tree name = TYPE_IDENTIFIER (type);
2839 dbxout_begin_complex_stabs ();
2840 stabstr_I (name);
2841 stabstr_S (":T");
2842 dbxout_type (type, 1);
2843 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
2844 did_output = 1;
2847 /* If an enum type has no name, it cannot be referred to, but
2848 we must output it anyway, to record the enumeration
2849 constants. */
2851 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
2853 dbxout_begin_complex_stabs ();
2854 /* Some debuggers fail when given NULL names, so give this a
2855 harmless name of " " (Why not "(anon)"?). */
2856 stabstr_S (" :T");
2857 dbxout_type (type, 1);
2858 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
2861 /* Prevent duplicate output of a typedef. */
2862 TREE_ASM_WRITTEN (decl) = 1;
2863 break;
2866 case PARM_DECL:
2867 if (DECL_HAS_VALUE_EXPR_P (decl))
2868 decl = DECL_VALUE_EXPR (decl);
2870 /* PARM_DECLs go in their own separate chain and are output by
2871 dbxout_reg_parms and dbxout_parms, except for those that are
2872 disguised VAR_DECLs like Out parameters in Ada. */
2873 gcc_assert (VAR_P (decl));
2875 /* fall through */
2877 case RESULT_DECL:
2878 case VAR_DECL:
2879 /* Don't mention a variable that is external.
2880 Let the file that defines it describe it. */
2881 if (DECL_EXTERNAL (decl))
2882 break;
2884 /* If the variable is really a constant
2885 and not written in memory, inform the debugger.
2887 ??? Why do we skip emitting the type and location in this case? */
2888 if (TREE_STATIC (decl) && TREE_READONLY (decl)
2889 && DECL_INITIAL (decl) != 0
2890 && tree_fits_shwi_p (DECL_INITIAL (decl))
2891 && ! TREE_ASM_WRITTEN (decl)
2892 && (DECL_FILE_SCOPE_P (decl)
2893 || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK
2894 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
2895 && TREE_PUBLIC (decl) == 0)
2897 /* The sun4 assembler does not grok this. */
2899 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
2900 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
2902 HOST_WIDE_INT ival = tree_to_shwi (DECL_INITIAL (decl));
2904 dbxout_begin_complex_stabs ();
2905 dbxout_symbol_name (decl, NULL, 'c');
2906 stabstr_S ("=i");
2907 stabstr_D (ival);
2908 dbxout_finish_complex_stabs (0, N_LSYM, 0, 0, 0);
2909 DBXOUT_DECR_NESTING;
2910 return 1;
2912 else
2913 break;
2915 /* else it is something we handle like a normal variable. */
2917 decl_rtl = dbxout_expand_expr (decl);
2918 if (!decl_rtl)
2919 DBXOUT_DECR_NESTING_AND_RETURN (0);
2921 if (!is_global_var (decl))
2922 decl_rtl = eliminate_regs (decl_rtl, VOIDmode, NULL_RTX);
2923 #ifdef LEAF_REG_REMAP
2924 if (crtl->uses_only_leaf_regs)
2925 leaf_renumber_regs_insn (decl_rtl);
2926 #endif
2928 result = dbxout_symbol_location (decl, type, 0, decl_rtl);
2929 break;
2931 default:
2932 break;
2934 DBXOUT_DECR_NESTING;
2935 return result;
2938 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2939 Add SUFFIX to its name, if SUFFIX is not 0.
2940 Describe the variable as residing in HOME
2941 (usually HOME is DECL_RTL (DECL), but not always).
2942 Returns 1 if the stab was really emitted. */
2944 static int
2945 dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
2947 int letter = 0;
2948 stab_code_type code;
2949 rtx addr = 0;
2950 int number = 0;
2951 int regno = -1;
2953 /* Don't mention a variable at all
2954 if it was completely optimized into nothingness.
2956 If the decl was from an inline function, then its rtl
2957 is not identically the rtl that was used in this
2958 particular compilation. */
2959 if (GET_CODE (home) == SUBREG)
2961 rtx value = home;
2963 while (GET_CODE (value) == SUBREG)
2964 value = SUBREG_REG (value);
2965 if (REG_P (value))
2967 if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
2968 return 0;
2970 home = alter_subreg (&home, true);
2972 if (REG_P (home))
2974 regno = REGNO (home);
2975 if (regno >= FIRST_PSEUDO_REGISTER)
2976 return 0;
2979 /* The kind-of-variable letter depends on where
2980 the variable is and on the scope of its name:
2981 G and N_GSYM for static storage and global scope,
2982 S for static storage and file scope,
2983 V for static storage and local scope,
2984 for those two, use N_LCSYM if data is in bss segment,
2985 N_STSYM if in data segment, N_FUN otherwise.
2986 (We used N_FUN originally, then changed to N_STSYM
2987 to please GDB. However, it seems that confused ld.
2988 Now GDB has been fixed to like N_FUN, says Kingdon.)
2989 no letter at all, and N_LSYM, for auto variable,
2990 r and N_RSYM for register variable. */
2992 if (MEM_P (home) && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
2994 if (TREE_PUBLIC (decl))
2996 int offs;
2997 letter = 'G';
2998 code = N_GSYM;
2999 if (NULL != dbxout_common_check (decl, &offs))
3001 letter = 'V';
3002 addr = 0;
3003 number = offs;
3006 else
3008 addr = XEXP (home, 0);
3010 letter = decl_function_context (decl) ? 'V' : 'S';
3012 /* Some ports can transform a symbol ref into a label ref,
3013 because the symbol ref is too far away and has to be
3014 dumped into a constant pool. Alternatively, the symbol
3015 in the constant pool might be referenced by a different
3016 symbol. */
3017 if (GET_CODE (addr) == SYMBOL_REF
3018 && CONSTANT_POOL_ADDRESS_P (addr))
3020 bool marked;
3021 rtx tmp = get_pool_constant_mark (addr, &marked);
3023 if (GET_CODE (tmp) == SYMBOL_REF)
3025 addr = tmp;
3026 if (CONSTANT_POOL_ADDRESS_P (addr))
3027 get_pool_constant_mark (addr, &marked);
3028 else
3029 marked = true;
3031 else if (GET_CODE (tmp) == LABEL_REF)
3033 addr = tmp;
3034 marked = true;
3037 /* If all references to the constant pool were optimized
3038 out, we just ignore the symbol. */
3039 if (!marked)
3040 return 0;
3043 /* This should be the same condition as in assemble_variable, but
3044 we don't have access to dont_output_data here. So, instead,
3045 we rely on the fact that error_mark_node initializers always
3046 end up in bss for C++ and never end up in bss for C. */
3047 if (DECL_INITIAL (decl) == 0
3048 || (lang_GNU_CXX ()
3049 && DECL_INITIAL (decl) == error_mark_node))
3051 int offs;
3052 code = N_LCSYM;
3053 if (NULL != dbxout_common_check (decl, &offs))
3055 addr = 0;
3056 number = offs;
3057 letter = 'V';
3058 code = N_GSYM;
3061 else if (DECL_IN_TEXT_SECTION (decl))
3062 /* This is not quite right, but it's the closest
3063 of all the codes that Unix defines. */
3064 code = DBX_STATIC_CONST_VAR_CODE;
3065 else
3067 /* Ultrix `as' seems to need this. */
3068 #ifdef DBX_STATIC_STAB_DATA_SECTION
3069 switch_to_section (data_section);
3070 #endif
3071 code = N_STSYM;
3075 else if (regno >= 0)
3077 letter = 'r';
3078 code = N_RSYM;
3079 number = DBX_REGISTER_NUMBER (regno);
3081 else if (MEM_P (home)
3082 && (MEM_P (XEXP (home, 0))
3083 || (REG_P (XEXP (home, 0))
3084 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
3085 && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
3086 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
3087 && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
3088 #endif
3090 /* If the value is indirect by memory or by a register
3091 that isn't the frame pointer
3092 then it means the object is variable-sized and address through
3093 that register or stack slot. DBX has no way to represent this
3094 so all we can do is output the variable as a pointer.
3095 If it's not a parameter, ignore it. */
3097 if (REG_P (XEXP (home, 0)))
3099 letter = 'r';
3100 code = N_RSYM;
3101 if (REGNO (XEXP (home, 0)) >= FIRST_PSEUDO_REGISTER)
3102 return 0;
3103 number = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
3105 else
3107 code = N_LSYM;
3108 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
3109 We want the value of that CONST_INT. */
3110 number = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
3113 /* Effectively do build_pointer_type, but don't cache this type,
3114 since it might be temporary whereas the type it points to
3115 might have been saved for inlining. */
3116 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
3117 type = make_node (POINTER_TYPE);
3118 TREE_TYPE (type) = TREE_TYPE (decl);
3120 else if (MEM_P (home)
3121 && REG_P (XEXP (home, 0)))
3123 code = N_LSYM;
3124 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
3126 else if (MEM_P (home)
3127 && GET_CODE (XEXP (home, 0)) == PLUS
3128 && CONST_INT_P (XEXP (XEXP (home, 0), 1)))
3130 code = N_LSYM;
3131 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
3132 We want the value of that CONST_INT. */
3133 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
3135 else if (MEM_P (home)
3136 && GET_CODE (XEXP (home, 0)) == CONST)
3138 /* Handle an obscure case which can arise when optimizing and
3139 when there are few available registers. (This is *always*
3140 the case for i386/i486 targets). The RTL looks like
3141 (MEM (CONST ...)) even though this variable is a local `auto'
3142 or a local `register' variable. In effect, what has happened
3143 is that the reload pass has seen that all assignments and
3144 references for one such a local variable can be replaced by
3145 equivalent assignments and references to some static storage
3146 variable, thereby avoiding the need for a register. In such
3147 cases we're forced to lie to debuggers and tell them that
3148 this variable was itself `static'. */
3149 int offs;
3150 code = N_LCSYM;
3151 letter = 'V';
3152 if (NULL == dbxout_common_check (decl, &offs))
3153 addr = XEXP (XEXP (home, 0), 0);
3154 else
3156 addr = 0;
3157 number = offs;
3158 code = N_GSYM;
3161 else if (GET_CODE (home) == CONCAT)
3163 tree subtype;
3165 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
3166 for example), then there is no easy way to figure out
3167 what SUBTYPE should be. So, we give up. */
3168 if (TREE_CODE (type) != COMPLEX_TYPE)
3169 return 0;
3171 subtype = TREE_TYPE (type);
3173 /* If the variable's storage is in two parts,
3174 output each as a separate stab with a modified name. */
3175 if (WORDS_BIG_ENDIAN)
3176 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
3177 else
3178 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
3180 if (WORDS_BIG_ENDIAN)
3181 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
3182 else
3183 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
3184 return 1;
3186 else
3187 /* Address might be a MEM, when DECL is a variable-sized object.
3188 Or it might be const0_rtx, meaning previous passes
3189 want us to ignore this variable. */
3190 return 0;
3192 /* Ok, start a symtab entry and output the variable name. */
3193 emit_pending_bincls_if_required ();
3194 FORCE_TEXT;
3196 #ifdef DBX_STATIC_BLOCK_START
3197 DBX_STATIC_BLOCK_START (asm_out_file, code);
3198 #endif
3200 dbxout_begin_complex_stabs_noforcetext ();
3201 dbxout_symbol_name (decl, suffix, letter);
3202 dbxout_type (type, 0);
3203 dbxout_finish_complex_stabs (decl, code, addr, 0, number);
3205 #ifdef DBX_STATIC_BLOCK_END
3206 DBX_STATIC_BLOCK_END (asm_out_file, code);
3207 #endif
3208 return 1;
3211 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
3212 Then output LETTER to indicate the kind of location the symbol has. */
3214 static void
3215 dbxout_symbol_name (tree decl, const char *suffix, int letter)
3217 tree name;
3219 if (DECL_CONTEXT (decl)
3220 && (TYPE_P (DECL_CONTEXT (decl))
3221 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL))
3222 /* One slight hitch: if this is a VAR_DECL which is a class member
3223 or a namespace member, we must put out the mangled name instead of the
3224 DECL_NAME. Note also that static member (variable) names DO NOT begin
3225 with underscores in .stabs directives. */
3226 name = DECL_ASSEMBLER_NAME (decl);
3227 else
3228 /* ...but if we're function-local, we don't want to include the junk
3229 added by ASM_FORMAT_PRIVATE_NAME. */
3230 name = DECL_NAME (decl);
3232 if (name)
3233 stabstr_I (name);
3234 else
3235 stabstr_S ("(anon)");
3237 if (suffix)
3238 stabstr_S (suffix);
3239 stabstr_C (':');
3240 if (letter)
3241 stabstr_C (letter);
3245 /* Output the common block name for DECL in a stabs.
3247 Symbols in global common (.comm) get wrapped with an N_BCOMM/N_ECOMM pair
3248 around each group of symbols in the same .comm area. The N_GSYM stabs
3249 that are emitted only contain the offset in the common area. This routine
3250 emits the N_BCOMM and N_ECOMM stabs. */
3252 static void
3253 dbxout_common_name (tree decl, const char *name, stab_code_type op)
3255 dbxout_begin_complex_stabs ();
3256 stabstr_S (name);
3257 dbxout_finish_complex_stabs (decl, op, NULL_RTX, NULL, 0);
3260 /* Check decl to determine whether it is a VAR_DECL destined for storage in a
3261 common area. If it is, the return value will be a non-null string giving
3262 the name of the common storage block it will go into. If non-null, the
3263 value is the offset into the common block for that symbol's storage. */
3265 static const char *
3266 dbxout_common_check (tree decl, int *value)
3268 rtx home;
3269 rtx sym_addr;
3270 const char *name = NULL;
3272 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
3273 it does not have a value (the offset into the common area), or if it
3274 is thread local (as opposed to global) then it isn't common, and shouldn't
3275 be handled as such.
3277 ??? DECL_THREAD_LOCAL_P check prevents problems with improper .stabs
3278 for thread-local symbols. Can be handled via same mechanism as used
3279 in dwarf2out.c. */
3280 if (!VAR_P (decl)
3281 || !TREE_STATIC (decl)
3282 || !DECL_HAS_VALUE_EXPR_P (decl)
3283 || DECL_THREAD_LOCAL_P (decl)
3284 || !is_fortran ())
3285 return NULL;
3287 home = DECL_RTL (decl);
3288 if (home == NULL_RTX || GET_CODE (home) != MEM)
3289 return NULL;
3291 sym_addr = dbxout_expand_expr (DECL_VALUE_EXPR (decl));
3292 if (sym_addr == NULL_RTX || GET_CODE (sym_addr) != MEM)
3293 return NULL;
3295 sym_addr = XEXP (sym_addr, 0);
3296 if (GET_CODE (sym_addr) == CONST)
3297 sym_addr = XEXP (sym_addr, 0);
3298 if ((GET_CODE (sym_addr) == SYMBOL_REF || GET_CODE (sym_addr) == PLUS)
3299 && DECL_INITIAL (decl) == 0)
3302 /* We have a sym that will go into a common area, meaning that it
3303 will get storage reserved with a .comm/.lcomm assembler pseudo-op.
3305 Determine name of common area this symbol will be an offset into,
3306 and offset into that area. Also retrieve the decl for the area
3307 that the symbol is offset into. */
3308 tree cdecl = NULL;
3310 switch (GET_CODE (sym_addr))
3312 case PLUS:
3313 if (CONST_INT_P (XEXP (sym_addr, 0)))
3315 name =
3316 targetm.strip_name_encoding (XSTR (XEXP (sym_addr, 1), 0));
3317 *value = INTVAL (XEXP (sym_addr, 0));
3318 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 1));
3320 else
3322 name =
3323 targetm.strip_name_encoding (XSTR (XEXP (sym_addr, 0), 0));
3324 *value = INTVAL (XEXP (sym_addr, 1));
3325 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 0));
3327 break;
3329 case SYMBOL_REF:
3330 name = targetm.strip_name_encoding (XSTR (sym_addr, 0));
3331 *value = 0;
3332 cdecl = SYMBOL_REF_DECL (sym_addr);
3333 break;
3335 default:
3336 error ("common symbol debug info is not structured as "
3337 "symbol+offset");
3340 /* Check area common symbol is offset into. If this is not public, then
3341 it is not a symbol in a common block. It must be a .lcomm symbol, not
3342 a .comm symbol. */
3343 if (cdecl == NULL || !TREE_PUBLIC (cdecl))
3344 name = NULL;
3346 else
3347 name = NULL;
3349 return name;
3352 /* Output definitions of all the decls in a chain. Return nonzero if
3353 anything was output */
3356 dbxout_syms (tree syms)
3358 int result = 0;
3359 const char *comm_prev = NULL;
3360 tree syms_prev = NULL;
3362 while (syms)
3364 int temp, copen, cclos;
3365 const char *comm_new;
3367 /* Check for common symbol, and then progression into a new/different
3368 block of common symbols. Emit closing/opening common bracket if
3369 necessary. */
3370 comm_new = dbxout_common_check (syms, &temp);
3371 copen = comm_new != NULL
3372 && (comm_prev == NULL || strcmp (comm_new, comm_prev));
3373 cclos = comm_prev != NULL
3374 && (comm_new == NULL || strcmp (comm_new, comm_prev));
3375 if (cclos)
3376 dbxout_common_name (syms_prev, comm_prev, N_ECOMM);
3377 if (copen)
3379 dbxout_common_name (syms, comm_new, N_BCOMM);
3380 syms_prev = syms;
3382 comm_prev = comm_new;
3384 result += dbxout_symbol (syms, 1);
3385 syms = DECL_CHAIN (syms);
3388 if (comm_prev != NULL)
3389 dbxout_common_name (syms_prev, comm_prev, N_ECOMM);
3391 return result;
3394 /* The following two functions output definitions of function parameters.
3395 Each parameter gets a definition locating it in the parameter list.
3396 Each parameter that is a register variable gets a second definition
3397 locating it in the register.
3399 Printing or argument lists in gdb uses the definitions that
3400 locate in the parameter list. But reference to the variable in
3401 expressions uses preferentially the definition as a register. */
3403 /* Output definitions, referring to storage in the parmlist,
3404 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
3406 void
3407 dbxout_parms (tree parms)
3409 ++debug_nesting;
3410 emit_pending_bincls_if_required ();
3412 for (; parms; parms = DECL_CHAIN (parms))
3413 if (DECL_NAME (parms)
3414 && TREE_TYPE (parms) != error_mark_node
3415 && DECL_RTL_SET_P (parms)
3416 && DECL_INCOMING_RTL (parms))
3418 tree eff_type;
3419 char letter;
3420 stab_code_type code;
3421 int number;
3423 /* Perform any necessary register eliminations on the parameter's rtl,
3424 so that the debugging output will be accurate. */
3425 DECL_INCOMING_RTL (parms)
3426 = eliminate_regs (DECL_INCOMING_RTL (parms), VOIDmode, NULL_RTX);
3427 SET_DECL_RTL (parms,
3428 eliminate_regs (DECL_RTL (parms), VOIDmode, NULL_RTX));
3429 #ifdef LEAF_REG_REMAP
3430 if (crtl->uses_only_leaf_regs)
3432 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
3433 leaf_renumber_regs_insn (DECL_RTL (parms));
3435 #endif
3437 if (PARM_PASSED_IN_MEMORY (parms))
3439 rtx inrtl = XEXP (DECL_INCOMING_RTL (parms), 0);
3441 /* ??? Here we assume that the parm address is indexed
3442 off the frame pointer or arg pointer.
3443 If that is not true, we produce meaningless results,
3444 but do not crash. */
3445 if (GET_CODE (inrtl) == PLUS
3446 && CONST_INT_P (XEXP (inrtl, 1)))
3447 number = INTVAL (XEXP (inrtl, 1));
3448 else
3449 number = 0;
3451 code = N_PSYM;
3452 number = DEBUGGER_ARG_OFFSET (number, inrtl);
3453 letter = 'p';
3455 /* It is quite tempting to use TREE_TYPE (parms) instead
3456 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
3457 reports the actual type of the parameter, rather than
3458 the promoted type. This certainly makes GDB's life
3459 easier, at least for some ports. The change is a bad
3460 idea however, since GDB expects to be able access the
3461 type without performing any conversions. So for
3462 example, if we were passing a float to an unprototyped
3463 function, gcc will store a double on the stack, but if
3464 we emit a stab saying the type is a float, then gdb
3465 will only read in a single value, and this will produce
3466 an erroneous value. */
3467 eff_type = DECL_ARG_TYPE (parms);
3469 else if (REG_P (DECL_RTL (parms)))
3471 rtx best_rtl;
3473 /* Parm passed in registers and lives in registers or nowhere. */
3474 code = DBX_REGPARM_STABS_CODE;
3475 letter = DBX_REGPARM_STABS_LETTER;
3477 /* For parms passed in registers, it is better to use the
3478 declared type of the variable, not the type it arrived in. */
3479 eff_type = TREE_TYPE (parms);
3481 /* If parm lives in a register, use that register; pretend
3482 the parm was passed there. It would be more consistent
3483 to describe the register where the parm was passed, but
3484 in practice that register usually holds something else.
3485 If the parm lives nowhere, use the register where it
3486 was passed. */
3487 if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
3488 best_rtl = DECL_RTL (parms);
3489 else if (GET_CODE (DECL_INCOMING_RTL (parms)) == PARALLEL)
3490 best_rtl = XEXP (XVECEXP (DECL_INCOMING_RTL (parms), 0, 0), 0);
3491 else
3492 best_rtl = DECL_INCOMING_RTL (parms);
3494 number = DBX_REGISTER_NUMBER (REGNO (best_rtl));
3496 else if (MEM_P (DECL_RTL (parms))
3497 && REG_P (XEXP (DECL_RTL (parms), 0))
3498 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
3499 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
3500 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
3501 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
3502 #endif
3505 /* Parm was passed via invisible reference.
3506 That is, its address was passed in a register.
3507 Output it as if it lived in that register.
3508 The debugger will know from the type
3509 that it was actually passed by invisible reference. */
3511 code = DBX_REGPARM_STABS_CODE;
3513 /* GDB likes this marked with a special letter. */
3514 letter = (use_gnu_debug_info_extensions
3515 ? 'a' : DBX_REGPARM_STABS_LETTER);
3516 eff_type = TREE_TYPE (parms);
3518 /* DECL_RTL looks like (MEM (REG...). Get the register number.
3519 If it is an unallocated pseudo-reg, then use the register where
3520 it was passed instead.
3521 ??? Why is DBX_REGISTER_NUMBER not used here? */
3523 if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
3524 number = REGNO (XEXP (DECL_RTL (parms), 0));
3525 else
3526 number = REGNO (DECL_INCOMING_RTL (parms));
3528 else if (MEM_P (DECL_RTL (parms))
3529 && MEM_P (XEXP (DECL_RTL (parms), 0)))
3531 /* Parm was passed via invisible reference, with the reference
3532 living on the stack. DECL_RTL looks like
3533 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3534 could look like (MEM (MEM (REG))). */
3536 code = N_PSYM;
3537 letter = 'v';
3538 eff_type = TREE_TYPE (parms);
3540 if (!REG_P (XEXP (XEXP (DECL_RTL (parms), 0), 0)))
3541 number = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
3542 else
3543 number = 0;
3545 number = DEBUGGER_ARG_OFFSET (number,
3546 XEXP (XEXP (DECL_RTL (parms), 0), 0));
3548 else if (MEM_P (DECL_RTL (parms))
3549 && XEXP (DECL_RTL (parms), 0) != const0_rtx
3550 /* ??? A constant address for a parm can happen
3551 when the reg it lives in is equiv to a constant in memory.
3552 Should make this not happen, after 2.4. */
3553 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
3555 /* Parm was passed in registers but lives on the stack. */
3557 code = N_PSYM;
3558 letter = 'p';
3559 eff_type = TREE_TYPE (parms);
3561 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3562 in which case we want the value of that CONST_INT,
3563 or (MEM (REG ...)),
3564 in which case we use a value of zero. */
3565 if (!REG_P (XEXP (DECL_RTL (parms), 0)))
3566 number = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
3567 else
3568 number = 0;
3570 /* Make a big endian correction if the mode of the type of the
3571 parameter is not the same as the mode of the rtl. */
3572 if (BYTES_BIG_ENDIAN
3573 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
3574 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
3575 number += (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
3576 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))));
3578 else
3579 /* ??? We don't know how to represent this argument. */
3580 continue;
3582 dbxout_begin_complex_stabs ();
3584 if (DECL_NAME (parms))
3586 stabstr_I (DECL_NAME (parms));
3587 stabstr_C (':');
3589 else
3590 stabstr_S ("(anon):");
3591 stabstr_C (letter);
3592 dbxout_type (eff_type, 0);
3593 dbxout_finish_complex_stabs (parms, code, 0, 0, number);
3595 DBXOUT_DECR_NESTING;
3598 /* Output definitions for the places where parms live during the function,
3599 when different from where they were passed, when the parms were passed
3600 in memory.
3602 It is not useful to do this for parms passed in registers
3603 that live during the function in different registers, because it is
3604 impossible to look in the passed register for the passed value,
3605 so we use the within-the-function register to begin with.
3607 PARMS is a chain of PARM_DECL nodes. */
3609 void
3610 dbxout_reg_parms (tree parms)
3612 ++debug_nesting;
3614 for (; parms; parms = DECL_CHAIN (parms))
3615 if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
3617 /* Report parms that live in registers during the function
3618 but were passed in memory. */
3619 if (REG_P (DECL_RTL (parms))
3620 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
3621 dbxout_symbol_location (parms, TREE_TYPE (parms),
3622 0, DECL_RTL (parms));
3623 else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
3624 dbxout_symbol_location (parms, TREE_TYPE (parms),
3625 0, DECL_RTL (parms));
3626 /* Report parms that live in memory but not where they were passed. */
3627 else if (MEM_P (DECL_RTL (parms))
3628 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
3629 dbxout_symbol_location (parms, TREE_TYPE (parms),
3630 0, DECL_RTL (parms));
3632 DBXOUT_DECR_NESTING;
3635 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
3636 output definitions of those names, in raw form */
3638 static void
3639 dbxout_args (tree args)
3641 while (args)
3643 stabstr_C (',');
3644 dbxout_type (TREE_VALUE (args), 0);
3645 args = TREE_CHAIN (args);
3649 #if defined (DBX_DEBUGGING_INFO)
3651 /* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
3652 BEGIN_LABEL is the name of the beginning of the function, which may
3653 be required. */
3654 static void
3655 dbx_output_lbrac (const char *label,
3656 const char *begin_label ATTRIBUTE_UNUSED)
3658 dbxout_begin_stabn (N_LBRAC);
3659 if (DBX_BLOCKS_FUNCTION_RELATIVE)
3660 dbxout_stab_value_label_diff (label, begin_label);
3661 else
3662 dbxout_stab_value_label (label);
3665 /* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
3666 BEGIN_LABEL is the name of the beginning of the function, which may
3667 be required. */
3668 static void
3669 dbx_output_rbrac (const char *label,
3670 const char *begin_label ATTRIBUTE_UNUSED)
3672 dbxout_begin_stabn (N_RBRAC);
3673 if (DBX_BLOCKS_FUNCTION_RELATIVE)
3674 dbxout_stab_value_label_diff (label, begin_label);
3675 else
3676 dbxout_stab_value_label (label);
3679 /* Output everything about a symbol block (a BLOCK node
3680 that represents a scope level),
3681 including recursive output of contained blocks.
3683 BLOCK is the BLOCK node.
3684 DEPTH is its depth within containing symbol blocks.
3685 ARGS is usually zero; but for the outermost block of the
3686 body of a function, it is a chain of PARM_DECLs for the function parameters.
3687 We output definitions of all the register parms
3688 as if they were local variables of that block.
3690 If -g1 was used, we count blocks just the same, but output nothing
3691 except for the outermost block.
3693 Actually, BLOCK may be several blocks chained together.
3694 We handle them all in sequence. */
3696 static void
3697 dbxout_block (tree block, int depth, tree args)
3699 char begin_label[20];
3700 /* Reference current function start using LFBB. */
3701 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
3703 while (block)
3705 /* Ignore blocks never expanded or otherwise marked as real. */
3706 if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
3708 int did_output;
3709 int blocknum = BLOCK_NUMBER (block);
3711 /* In dbx format, the syms of a block come before the N_LBRAC.
3712 If nothing is output, we don't need the N_LBRAC, either. */
3713 did_output = 0;
3714 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
3715 did_output = dbxout_syms (BLOCK_VARS (block));
3716 if (args)
3717 dbxout_reg_parms (args);
3719 /* Now output an N_LBRAC symbol to represent the beginning of
3720 the block. Use the block's tree-walk order to generate
3721 the assembler symbols LBBn and LBEn
3722 that final will define around the code in this block. */
3723 if (did_output)
3725 char buf[20];
3726 const char *scope_start;
3728 if (depth == 0)
3729 /* The outermost block doesn't get LBB labels; use
3730 the LFBB local symbol emitted by dbxout_begin_prologue. */
3731 scope_start = begin_label;
3732 else
3734 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
3735 scope_start = buf;
3738 dbx_output_lbrac (scope_start, begin_label);
3741 /* Output the subblocks. */
3742 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
3744 /* Refer to the marker for the end of the block. */
3745 if (did_output)
3747 char buf[100];
3748 if (depth == 0)
3749 /* The outermost block doesn't get LBE labels;
3750 use the "scope" label which will be emitted
3751 by dbxout_function_end. */
3752 ASM_GENERATE_INTERNAL_LABEL (buf, "Lscope", scope_labelno);
3753 else
3754 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
3756 dbx_output_rbrac (buf, begin_label);
3759 block = BLOCK_CHAIN (block);
3763 /* Output the information about a function and its arguments and result.
3764 Usually this follows the function's code,
3765 but on some systems, it comes before. */
3767 static void
3768 dbxout_begin_function (tree decl)
3770 int saved_tree_used1;
3772 saved_tree_used1 = TREE_USED (decl);
3773 TREE_USED (decl) = 1;
3774 if (DECL_NAME (DECL_RESULT (decl)) != 0)
3776 int saved_tree_used2 = TREE_USED (DECL_RESULT (decl));
3777 TREE_USED (DECL_RESULT (decl)) = 1;
3778 dbxout_symbol (decl, 0);
3779 TREE_USED (DECL_RESULT (decl)) = saved_tree_used2;
3781 else
3782 dbxout_symbol (decl, 0);
3783 TREE_USED (decl) = saved_tree_used1;
3785 dbxout_parms (DECL_ARGUMENTS (decl));
3786 if (DECL_NAME (DECL_RESULT (decl)) != 0)
3787 dbxout_symbol (DECL_RESULT (decl), 1);
3789 #endif /* DBX_DEBUGGING_INFO */
3791 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3793 /* Record an element in the table of global destructors. SYMBOL is
3794 a SYMBOL_REF of the function to be called; PRIORITY is a number
3795 between 0 and MAX_INIT_PRIORITY. */
3797 void
3798 default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED,
3799 int priority ATTRIBUTE_UNUSED)
3801 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
3802 /* Tell GNU LD that this is part of the static destructor set.
3803 This will work for any system that uses stabs, most usefully
3804 aout systems. */
3805 dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
3806 dbxout_stab_value_label (XSTR (symbol, 0));
3807 #else
3808 sorry ("global destructors not supported on this target");
3809 #endif
3812 /* Likewise for global constructors. */
3814 void
3815 default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED,
3816 int priority ATTRIBUTE_UNUSED)
3818 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
3819 /* Tell GNU LD that this is part of the static destructor set.
3820 This will work for any system that uses stabs, most usefully
3821 aout systems. */
3822 dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
3823 dbxout_stab_value_label (XSTR (symbol, 0));
3824 #else
3825 sorry ("global constructors not supported on this target");
3826 #endif
3829 #include "gt-dbxout.h"