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