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