OSDN Git Service

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