OSDN Git Service

Document the __OBJC__ macro.
[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 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.  */
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
74 #include "tree.h"
75 #include "rtl.h"
76 #include "flags.h"
77 #include "regs.h"
78 #include "insn-config.h"
79 #include "reload.h"
80 #include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions.  */
81 #include "dbxout.h"
82 #include "toplev.h"
83 #include "tm_p.h"
84 #include "ggc.h"
85 #include "debug.h"
86 #include "function.h"
87 #include "target.h"
88 #include "langhooks.h"
89
90 #ifdef XCOFF_DEBUGGING_INFO
91 #include "xcoffout.h"
92 #endif
93
94 #ifndef ASM_STABS_OP
95 #define ASM_STABS_OP "\t.stabs\t"
96 #endif
97
98 #ifndef ASM_STABN_OP
99 #define ASM_STABN_OP "\t.stabn\t"
100 #endif
101
102 #ifndef DBX_TYPE_DECL_STABS_CODE
103 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
104 #endif
105
106 #ifndef DBX_STATIC_CONST_VAR_CODE
107 #define DBX_STATIC_CONST_VAR_CODE N_FUN
108 #endif
109
110 #ifndef DBX_REGPARM_STABS_CODE
111 #define DBX_REGPARM_STABS_CODE N_RSYM
112 #endif
113
114 #ifndef DBX_REGPARM_STABS_LETTER
115 #define DBX_REGPARM_STABS_LETTER 'P'
116 #endif
117
118 /* This is used for parameters passed by invisible reference in a register.  */
119 #ifndef GDB_INV_REF_REGPARM_STABS_LETTER
120 #define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
121 #endif
122
123 #ifndef DBX_MEMPARM_STABS_LETTER
124 #define DBX_MEMPARM_STABS_LETTER 'p'
125 #endif
126
127 #ifndef FILE_NAME_JOINER
128 #define FILE_NAME_JOINER "/"
129 #endif
130
131 /* GDB needs to know that the stabs were generated by GCC.  We emit an
132    N_OPT stab at the beginning of the source file to indicate this.
133    The string is historical, and different on a very few targets.  */
134 #ifndef STABS_GCC_MARKER
135 #define STABS_GCC_MARKER "gcc2_compiled."
136 #endif
137
138 /* Typical USG systems don't have stab.h, and they also have
139    no use for DBX-format debugging info.  */
140
141 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
142
143 /* Nonzero if we have actually used any of the GDB extensions
144    to the debugging format.  The idea is that we use them for the
145    first time only if there's a strong reason, but once we have done that,
146    we use them whenever convenient.  */
147
148 static int have_used_extensions = 0;
149
150 /* Number for the next N_SOL filename stabs label.  The number 0 is reserved
151    for the N_SO filename stabs label.  */
152
153 #if defined (DBX_DEBUGGING_INFO) && !defined (DBX_OUTPUT_SOURCE_FILENAME)
154 static int source_label_number = 1;
155 #endif
156
157 #ifdef DEBUG_SYMS_TEXT
158 #define FORCE_TEXT text_section ();
159 #else
160 #define FORCE_TEXT
161 #endif
162
163 #include "gstab.h"
164
165 #define STAB_CODE_TYPE enum __stab_debug_code
166
167 /* 1 if PARM is passed to this function in memory.  */
168
169 #define PARM_PASSED_IN_MEMORY(PARM) \
170  (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
171
172 /* A C expression for the integer offset value of an automatic variable
173    (N_LSYM) having address X (an RTX).  */
174 #ifndef DEBUGGER_AUTO_OFFSET
175 #define DEBUGGER_AUTO_OFFSET(X) \
176   (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
177 #endif
178
179 /* A C expression for the integer offset value of an argument (N_PSYM)
180    having address X (an RTX).  The nominal offset is OFFSET.  */
181 #ifndef DEBUGGER_ARG_OFFSET
182 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
183 #endif
184
185 /* Stream for writing to assembler file.  */
186
187 static FILE *asmfile;
188
189 /* Last source file name mentioned in a NOTE insn.  */
190
191 static const char *lastfile;
192
193 /* Current working directory.  */
194
195 static const char *cwd;
196
197 enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
198
199 /* Structure recording information about a C data type.
200    The status element says whether we have yet output
201    the definition of the type.  TYPE_XREF says we have
202    output it as a cross-reference only.
203    The file_number and type_number elements are used if DBX_USE_BINCL
204    is defined.  */
205
206 struct typeinfo
207 {
208   enum typestatus status;
209 #ifdef DBX_USE_BINCL
210   int file_number;
211   int type_number;
212 #endif
213 };
214
215 /* Vector recording information about C data types.
216    When we first notice a data type (a tree node),
217    we assign it a number using next_type_number.
218    That is its index in this vector.  */
219
220 struct typeinfo *typevec;
221
222 /* Number of elements of space allocated in `typevec'.  */
223
224 static int typevec_len;
225
226 /* In dbx output, each type gets a unique number.
227    This is the number for the next type output.
228    The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field.  */
229
230 static int next_type_number;
231
232 #ifdef DBX_USE_BINCL
233
234 /* When using N_BINCL in dbx output, each type number is actually a
235    pair of the file number and the type number within the file.
236    This is a stack of input files.  */
237
238 struct dbx_file
239 {
240   struct dbx_file *next;
241   int file_number;
242   int next_type_number;
243 };
244
245 /* This is the top of the stack.  */
246
247 static struct dbx_file *current_file;
248
249 /* This is the next file number to use.  */
250
251 static int next_file_number;
252
253 #endif /* DBX_USE_BINCL */
254
255 /* These variables are for dbxout_symbol to communicate to
256    dbxout_finish_symbol.
257    current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
258    current_sym_value and current_sym_addr are two ways to address the
259    value to store in the symtab entry.
260    current_sym_addr if nonzero represents the value as an rtx.
261    If that is zero, current_sym_value is used.  This is used
262    when the value is an offset (such as for auto variables,
263    register variables and parms).  */
264
265 static STAB_CODE_TYPE current_sym_code;
266 static int current_sym_value;
267 static rtx current_sym_addr;
268
269 /* Number of chars of symbol-description generated so far for the
270    current symbol.  Used by CHARS and CONTIN.  */
271
272 static int current_sym_nchars;
273
274 /* Report having output N chars of the current symbol-description.  */
275
276 #define CHARS(N) (current_sym_nchars += (N))
277
278 /* Break the current symbol-description, generating a continuation,
279    if it has become long.  */
280
281 #ifndef DBX_CONTIN_LENGTH
282 #define DBX_CONTIN_LENGTH 80
283 #endif
284
285 #if DBX_CONTIN_LENGTH > 0
286 #define CONTIN  \
287   do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
288 #else
289 #define CONTIN do { } while (0)
290 #endif
291
292 static void dbxout_init                 PARAMS ((const char *));
293 static void dbxout_finish               PARAMS ((const char *));
294 static void dbxout_start_source_file    PARAMS ((unsigned, const char *));
295 static void dbxout_end_source_file      PARAMS ((unsigned));
296 static void dbxout_typedefs             PARAMS ((tree));
297 static void dbxout_type_index           PARAMS ((tree));
298 #if DBX_CONTIN_LENGTH > 0
299 static void dbxout_continue             PARAMS ((void));
300 #endif
301 static void dbxout_args                 PARAMS ((tree));
302 static void dbxout_type_fields          PARAMS ((tree));
303 static void dbxout_type_method_1        PARAMS ((tree, const char *));
304 static void dbxout_type_methods         PARAMS ((tree));
305 static void dbxout_range_type           PARAMS ((tree));
306 static void dbxout_type                 PARAMS ((tree, int));
307 static void print_int_cst_octal         PARAMS ((tree));
308 static void print_octal                 PARAMS ((unsigned HOST_WIDE_INT, int));
309 static void print_wide_int              PARAMS ((HOST_WIDE_INT));
310 static void dbxout_type_name            PARAMS ((tree));
311 static int dbxout_symbol_location       PARAMS ((tree, tree, const char *, rtx));
312 static void dbxout_symbol_name          PARAMS ((tree, const char *, int));
313 static void dbxout_prepare_symbol       PARAMS ((tree));
314 static void dbxout_finish_symbol        PARAMS ((tree));
315 static void dbxout_block                PARAMS ((tree, int, tree));
316 static void dbxout_global_decl          PARAMS ((tree));
317 \f
318 /* The debug hooks structure.  */
319 #if defined (DBX_DEBUGGING_INFO)
320
321 static void dbxout_source_line          PARAMS ((unsigned int, const char *));
322 static void dbxout_source_file          PARAMS ((FILE *, const char *));
323 static void dbxout_function_end         PARAMS ((void));
324 static void dbxout_begin_function       PARAMS ((tree));
325 static void dbxout_begin_block          PARAMS ((unsigned, unsigned));
326 static void dbxout_end_block            PARAMS ((unsigned, unsigned));
327 static void dbxout_function_decl        PARAMS ((tree));
328
329 struct gcc_debug_hooks dbx_debug_hooks =
330 {
331   dbxout_init,
332   dbxout_finish,
333   debug_nothing_int_charstar,
334   debug_nothing_int_charstar,
335   dbxout_start_source_file,
336   dbxout_end_source_file,
337   dbxout_begin_block,
338   dbxout_end_block,
339   debug_true_tree,              /* ignore_block */
340   dbxout_source_line,           /* source_line */
341   dbxout_source_line,           /* begin_prologue: just output line info */
342   debug_nothing_int,            /* end_prologue */
343   debug_nothing_void,           /* end_epilogue */
344 #ifdef DBX_FUNCTION_FIRST
345   dbxout_begin_function,
346 #else
347   debug_nothing_tree,           /* begin_function */
348 #endif
349   debug_nothing_int,            /* end_function */
350   dbxout_function_decl,
351   dbxout_global_decl,           /* global_decl */
352   debug_nothing_tree,           /* deferred_inline_function */
353   debug_nothing_tree,           /* outlining_inline_function */
354   debug_nothing_rtx             /* label */
355 };
356 #endif /* DBX_DEBUGGING_INFO  */
357
358 #if defined (XCOFF_DEBUGGING_INFO)
359 struct gcc_debug_hooks xcoff_debug_hooks =
360 {
361   dbxout_init,
362   dbxout_finish,
363   debug_nothing_int_charstar,
364   debug_nothing_int_charstar,
365   dbxout_start_source_file,
366   dbxout_end_source_file,
367   xcoffout_begin_block,
368   xcoffout_end_block,
369   debug_true_tree,              /* ignore_block */
370   xcoffout_source_line,
371   xcoffout_begin_prologue,      /* begin_prologue */
372   debug_nothing_int,            /* end_prologue */
373   xcoffout_end_epilogue,
374   debug_nothing_tree,           /* begin_function */
375   xcoffout_end_function,
376   debug_nothing_tree,           /* function_decl */
377   dbxout_global_decl,           /* global_decl */
378   debug_nothing_tree,           /* deferred_inline_function */
379   debug_nothing_tree,           /* outlining_inline_function */
380   debug_nothing_rtx             /* label */
381 };
382 #endif /* XCOFF_DEBUGGING_INFO  */
383 \f
384 #if defined (DBX_DEBUGGING_INFO)
385 static void
386 dbxout_function_end ()
387 {
388   static int scope_labelno = 0;
389   char lscope_label_name[100];
390   /* Convert Ltext into the appropriate format for local labels in case
391      the system doesn't insert underscores in front of user generated
392      labels.  */
393   ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
394   ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Lscope", scope_labelno);
395   scope_labelno++;
396
397   /* By convention, GCC will mark the end of a function with an N_FUN
398      symbol and an empty string.  */
399   fprintf (asmfile, "%s\"\",%d,0,0,", ASM_STABS_OP, N_FUN);
400   assemble_name (asmfile, lscope_label_name);
401   putc ('-', asmfile);
402   assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
403   fprintf (asmfile, "\n");
404 }
405 #endif /* DBX_DEBUGGING_INFO */
406
407 /* At the beginning of compilation, start writing the symbol table.
408    Initialize `typevec' and output the standard data types of C.  */
409
410 static void
411 dbxout_init (input_file_name)
412      const char *input_file_name;
413 {
414   char ltext_label_name[100];
415   tree syms = getdecls ();
416
417   asmfile = asm_out_file;
418
419   typevec_len = 100;
420   typevec = (struct typeinfo *) xcalloc (typevec_len, sizeof typevec[0]);
421
422   /* Convert Ltext into the appropriate format for local labels in case
423      the system doesn't insert underscores in front of user generated
424      labels.  */
425   ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
426
427   /* Put the current working directory in an N_SO symbol.  */
428 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
429                                  but GDB always does.  */
430   if (use_gnu_debug_info_extensions)
431 #endif
432     {
433       if (!cwd && (cwd = getpwd ()) && (!*cwd || cwd[strlen (cwd) - 1] != '/'))
434         cwd = concat (cwd, FILE_NAME_JOINER, NULL);
435       if (cwd)
436         {
437 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
438           DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd);
439 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
440           fprintf (asmfile, "%s", ASM_STABS_OP);
441           output_quoted_string (asmfile, cwd);
442           fprintf (asmfile, ",%d,0,0,%s\n", N_SO, &ltext_label_name[1]);
443 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
444         }
445     }
446
447 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
448   /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
449      would give us an N_SOL, and we want an N_SO.  */
450   DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile, input_file_name);
451 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
452   /* We include outputting `Ltext:' here,
453      because that gives you a way to override it.  */
454   /* Used to put `Ltext:' before the reference, but that loses on sun 4.  */
455   fprintf (asmfile, "%s", ASM_STABS_OP);
456   output_quoted_string (asmfile, input_file_name);
457   fprintf (asmfile, ",%d,0,0,%s\n", 
458            N_SO, &ltext_label_name[1]);
459   text_section ();
460   ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Ltext", 0);
461 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
462
463 #ifdef DBX_OUTPUT_GCC_MARKER
464   DBX_OUTPUT_GCC_MARKER (asmfile);
465 #else
466   /* Emit an N_OPT stab to indicate that this file was compiled by GCC.  */
467   fprintf (asmfile, "%s\"%s\",%d,0,0,0\n",
468            ASM_STABS_OP, STABS_GCC_MARKER, N_OPT);
469 #endif
470
471   lastfile = input_file_name;
472
473   next_type_number = 1;
474
475 #ifdef DBX_USE_BINCL
476   current_file = (struct dbx_file *) xmalloc (sizeof *current_file);
477   current_file->next = NULL;
478   current_file->file_number = 0;
479   current_file->next_type_number = 1;
480   next_file_number = 1;
481 #endif
482
483   /* Make sure that types `int' and `char' have numbers 1 and 2.
484      Definitions of other integer types will refer to those numbers.
485      (Actually it should no longer matter what their numbers are.
486      Also, if any types with tags have been defined, dbxout_symbol
487      will output them first, so the numbers won't be 1 and 2.  That
488      happens in C++.  So it's a good thing it should no longer matter).  */
489
490 #ifdef DBX_OUTPUT_STANDARD_TYPES
491   DBX_OUTPUT_STANDARD_TYPES (syms);
492 #else
493   dbxout_symbol (TYPE_NAME (integer_type_node), 0);
494   dbxout_symbol (TYPE_NAME (char_type_node), 0);
495 #endif
496
497   /* Get all permanent types that have typedef names,
498      and output them all, except for those already output.  */
499
500   dbxout_typedefs (syms);
501 }
502
503 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
504    in the reverse order from that which is found in SYMS.  */
505
506 static void
507 dbxout_typedefs (syms)
508      tree syms;
509 {
510   if (syms)
511     {
512       dbxout_typedefs (TREE_CHAIN (syms));
513       if (TREE_CODE (syms) == TYPE_DECL)
514         {
515           tree type = TREE_TYPE (syms);
516           if (TYPE_NAME (type)
517               && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
518               && COMPLETE_TYPE_P (type)
519               && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
520             dbxout_symbol (TYPE_NAME (type), 0);
521         }
522     }
523 }
524
525 /* Change to reading from a new source file.  Generate a N_BINCL stab.  */
526
527 static void
528 dbxout_start_source_file (line, filename)
529      unsigned int line ATTRIBUTE_UNUSED;
530      const char *filename ATTRIBUTE_UNUSED;
531 {
532 #ifdef DBX_USE_BINCL
533   struct dbx_file *n = (struct dbx_file *) xmalloc (sizeof *n);
534
535   n->next = current_file;
536   n->file_number = next_file_number++;
537   n->next_type_number = 1;
538   current_file = n;
539   fprintf (asmfile, "%s", ASM_STABS_OP);
540   output_quoted_string (asmfile, filename);
541   fprintf (asmfile, ",%d,0,0,0\n", N_BINCL);
542 #endif
543 }
544
545 /* Revert to reading a previous source file.  Generate a N_EINCL stab.  */
546
547 static void
548 dbxout_end_source_file (line)
549      unsigned int line ATTRIBUTE_UNUSED;
550 {
551 #ifdef DBX_USE_BINCL
552   struct dbx_file *next;
553
554   fprintf (asmfile, "%s%d,0,0,0\n", ASM_STABN_OP, N_EINCL);
555   next = current_file->next;
556   free (current_file);
557   current_file = next;
558 #endif
559 }
560
561 #if defined (DBX_DEBUGGING_INFO)
562 /* Output debugging info to FILE to switch to sourcefile FILENAME.  */
563
564 static void
565 dbxout_source_file (file, filename)
566      FILE *file;
567      const char *filename;
568 {
569   if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
570     {
571 #ifdef DBX_OUTPUT_SOURCE_FILENAME
572       DBX_OUTPUT_SOURCE_FILENAME (file, filename);
573 #else
574       char ltext_label_name[100];
575
576       ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext",
577                                    source_label_number);
578       fprintf (file, "%s", ASM_STABS_OP);
579       output_quoted_string (file, filename);
580       fprintf (file, ",%d,0,0,%s\n", N_SOL, &ltext_label_name[1]);
581       if (current_function_decl != NULL_TREE
582           && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
583         ; /* Don't change section amid function.  */
584       else
585         text_section ();
586       ASM_OUTPUT_INTERNAL_LABEL (file, "Ltext", source_label_number);
587       source_label_number++;
588 #endif
589       lastfile = filename;
590     }
591 }
592
593 /* Output a line number symbol entry for source file FILENAME and line
594    number LINENO.  */
595
596 static void
597 dbxout_source_line (lineno, filename)
598      unsigned int lineno;
599      const char *filename;
600 {
601   dbxout_source_file (asmfile, filename);
602
603 #ifdef ASM_OUTPUT_SOURCE_LINE
604   ASM_OUTPUT_SOURCE_LINE (asmfile, lineno);
605 #else
606   fprintf (asmfile, "%s%d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno);
607 #endif
608 }
609
610 /* Describe the beginning of an internal block within a function.  */
611
612 static void
613 dbxout_begin_block (line, n)
614      unsigned int line ATTRIBUTE_UNUSED;
615      unsigned int n;
616 {
617   ASM_OUTPUT_INTERNAL_LABEL (asmfile, "LBB", n);
618 }
619
620 /* Describe the end line-number of an internal block within a function.  */
621
622 static void
623 dbxout_end_block (line, n)
624      unsigned int line ATTRIBUTE_UNUSED;
625      unsigned int n;
626 {
627   ASM_OUTPUT_INTERNAL_LABEL (asmfile, "LBE", n);
628 }
629
630 /* Output dbx data for a function definition.
631    This includes a definition of the function name itself (a symbol),
632    definitions of the parameters (locating them in the parameter list)
633    and then output the block that makes up the function's body
634    (including all the auto variables of the function).  */
635
636 static void
637 dbxout_function_decl (decl)
638      tree decl;
639 {
640 #ifndef DBX_FUNCTION_FIRST
641   dbxout_begin_function (decl);
642 #endif
643   dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
644 #ifdef DBX_OUTPUT_FUNCTION_END
645   DBX_OUTPUT_FUNCTION_END (asmfile, decl);
646 #endif
647   if (use_gnu_debug_info_extensions
648 #if defined(NO_DBX_FUNCTION_END)
649       && ! NO_DBX_FUNCTION_END
650 #endif
651       && targetm.have_named_sections)
652     dbxout_function_end ();
653 }
654
655 #endif /* DBX_DEBUGGING_INFO  */
656
657 /* Debug information for a global DECL.  Called from toplev.c after
658    compilation proper has finished.  */
659 static void
660 dbxout_global_decl (decl)
661      tree decl;
662 {
663   if (TREE_CODE (decl) == VAR_DECL
664       && ! DECL_EXTERNAL (decl)
665       && DECL_RTL_SET_P (decl)) /* Not necessary?  */
666     dbxout_symbol (decl, 0);
667
668
669 /* At the end of compilation, finish writing the symbol table.
670    Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
671    to do nothing.  */
672
673 static void
674 dbxout_finish (filename)
675      const char *filename ATTRIBUTE_UNUSED;
676 {
677 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
678   DBX_OUTPUT_MAIN_SOURCE_FILE_END (asmfile, filename);
679 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
680 }
681
682 /* Output the index of a type.  */
683
684 static void
685 dbxout_type_index (type)
686      tree type;
687 {
688 #ifndef DBX_USE_BINCL
689   fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
690   CHARS (3);
691 #else
692   struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
693   fprintf (asmfile, "(%d,%d)", t->file_number, t->type_number);
694   CHARS (9);
695 #endif
696 }
697
698 #if DBX_CONTIN_LENGTH > 0
699 /* Continue a symbol-description that gets too big.
700    End one symbol table entry with a double-backslash
701    and start a new one, eventually producing something like
702    .stabs "start......\\",code,0,value
703    .stabs "...rest",code,0,value   */
704
705 static void
706 dbxout_continue ()
707 {
708 #ifdef DBX_CONTIN_CHAR
709   fprintf (asmfile, "%c", DBX_CONTIN_CHAR);
710 #else
711   fprintf (asmfile, "\\\\");
712 #endif
713   dbxout_finish_symbol (NULL_TREE);
714   fprintf (asmfile, "%s\"", ASM_STABS_OP);
715   current_sym_nchars = 0;
716 }
717 #endif /* DBX_CONTIN_LENGTH > 0 */
718 \f
719 /* Subroutine of `dbxout_type'.  Output the type fields of TYPE.
720    This must be a separate function because anonymous unions require
721    recursive calls.  */
722
723 static void
724 dbxout_type_fields (type)
725      tree type;
726 {
727   tree tem;
728
729   /* Output the name, type, position (in bits), size (in bits) of each
730      field that we can support.  */
731   for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
732     {
733       /* Omit here local type decls until we know how to support them.  */
734       if (TREE_CODE (tem) == TYPE_DECL
735           /* Omit fields whose position or size are variable or too large to
736              represent.  */
737           || (TREE_CODE (tem) == FIELD_DECL
738               && (! host_integerp (bit_position (tem), 0)
739                   || ! DECL_SIZE (tem)
740                   || ! host_integerp (DECL_SIZE (tem), 1)))
741           /* Omit here the nameless fields that are used to skip bits.  */
742            || DECL_IGNORED_P (tem))
743         continue;
744
745       else if (TREE_CODE (tem) != CONST_DECL)
746         {
747           /* Continue the line if necessary,
748              but not before the first field.  */
749           if (tem != TYPE_FIELDS (type))
750             CONTIN;
751
752           if (DECL_NAME (tem))
753             {
754               fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
755               CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem)));
756             }
757           else
758             {
759               fprintf (asmfile, ":");
760               CHARS (1);
761             }
762
763           if (use_gnu_debug_info_extensions
764               && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
765                   || TREE_CODE (tem) != FIELD_DECL))
766             {
767               have_used_extensions = 1;
768               putc ('/', asmfile);
769               putc ((TREE_PRIVATE (tem) ? '0'
770                      : TREE_PROTECTED (tem) ? '1' : '2'),
771                     asmfile);
772               CHARS (2);
773             }
774
775           dbxout_type ((TREE_CODE (tem) == FIELD_DECL
776                         && DECL_BIT_FIELD_TYPE (tem))
777                        ? DECL_BIT_FIELD_TYPE (tem) : TREE_TYPE (tem), 0);
778
779           if (TREE_CODE (tem) == VAR_DECL)
780             {
781               if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
782                 {
783                   tree name = DECL_ASSEMBLER_NAME (tem);
784
785                   have_used_extensions = 1;
786                   fprintf (asmfile, ":%s;", IDENTIFIER_POINTER (name));
787                   CHARS (IDENTIFIER_LENGTH (name) + 2);
788                 }
789               else
790                 {
791                   /* If TEM is non-static, GDB won't understand it.  */
792                   fprintf (asmfile, ",0,0;");
793                   CHARS (5);
794                 }
795             }
796           else
797             {
798               putc (',', asmfile);
799               print_wide_int (int_bit_position (tem));
800               putc (',', asmfile);
801               print_wide_int (tree_low_cst (DECL_SIZE (tem), 1));
802               putc (';', asmfile);
803               CHARS (3);
804             }
805         }
806     }
807 }
808 \f
809 /* Subroutine of `dbxout_type_methods'.  Output debug info about the
810    method described DECL.  DEBUG_NAME is an encoding of the method's
811    type signature.  ??? We may be able to do without DEBUG_NAME altogether
812    now.  */
813
814 static void
815 dbxout_type_method_1 (decl, debug_name)
816      tree decl;
817      const char *debug_name;
818 {
819   char c1 = 'A', c2;
820
821   if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
822     c2 = '?';
823   else /* it's a METHOD_TYPE.  */
824     {
825       tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
826       /* A for normal functions.
827          B for `const' member functions.
828          C for `volatile' member functions.
829          D for `const volatile' member functions.  */
830       if (TYPE_READONLY (TREE_TYPE (firstarg)))
831         c1 += 1;
832       if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
833         c1 += 2;
834
835       if (DECL_VINDEX (decl))
836         c2 = '*';
837       else
838         c2 = '.';
839     }
840
841   fprintf (asmfile, ":%s;%c%c%c", debug_name,
842            TREE_PRIVATE (decl) ? '0'
843            : TREE_PROTECTED (decl) ? '1' : '2', c1, c2);
844   CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)) + 6
845          - (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
846
847   if (DECL_VINDEX (decl) && host_integerp (DECL_VINDEX (decl), 0))
848     {
849       print_wide_int (tree_low_cst (DECL_VINDEX (decl), 0));
850       putc (';', asmfile);
851       CHARS (1);
852       dbxout_type (DECL_CONTEXT (decl), 0);
853       fprintf (asmfile, ";");
854       CHARS (1);
855     }
856 }
857 \f
858 /* Subroutine of `dbxout_type'.  Output debug info about the methods defined
859    in TYPE.  */
860
861 static void
862 dbxout_type_methods (type)
863      tree type;
864 {
865   /* C++: put out the method names and their parameter lists */
866   tree methods = TYPE_METHODS (type);
867   tree type_encoding;
868   tree fndecl;
869   tree last;
870   char formatted_type_identifier_length[16];
871   int type_identifier_length;
872
873   if (methods == NULL_TREE)
874     return;
875
876   type_encoding = DECL_NAME (TYPE_NAME (type));
877
878 #if 0
879   /* C++: Template classes break some assumptions made by this code about
880      the class names, constructor names, and encodings for assembler
881      label names.  For now, disable output of dbx info for them.  */
882   {
883     const char *ptr = IDENTIFIER_POINTER (type_encoding);
884     /* This should use index.  (mrs) */
885     while (*ptr && *ptr != '<') ptr++;
886     if (*ptr != 0)
887       {
888         static int warned;
889         if (!warned)
890             warned = 1;
891         return;
892       }
893   }
894 #endif
895
896   type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
897
898   sprintf (formatted_type_identifier_length, "%d", type_identifier_length);
899
900   if (TREE_CODE (methods) != TREE_VEC)
901     fndecl = methods;
902   else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
903     fndecl = TREE_VEC_ELT (methods, 0);
904   else
905     fndecl = TREE_VEC_ELT (methods, 1);
906
907   while (fndecl)
908     {
909       int need_prefix = 1;
910
911       /* Group together all the methods for the same operation.
912          These differ in the types of the arguments.  */
913       for (last = NULL_TREE;
914            fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
915            fndecl = TREE_CHAIN (fndecl))
916         /* Output the name of the field (after overloading), as
917            well as the name of the field before overloading, along
918            with its parameter list */
919         {
920           /* This is the "mangled" name of the method.
921              It encodes the argument types.  */
922           const char *debug_name;
923
924           /* Skip methods that aren't FUNCTION_DECLs.  (In C++, these
925              include TEMPLATE_DECLs.)  The debugger doesn't know what
926              to do with such entities anyhow.  */
927           if (TREE_CODE (fndecl) != FUNCTION_DECL)
928             continue;
929
930           debug_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
931
932           CONTIN;
933
934           last = fndecl;
935
936           /* Also ignore abstract methods; those are only interesting to
937              the DWARF backends.  */
938           if (DECL_IGNORED_P (fndecl) || DECL_ABSTRACT (fndecl))
939             continue;
940
941           /* Redundantly output the plain name, since that's what gdb
942              expects.  */
943           if (need_prefix)
944             {
945               tree name = DECL_NAME (fndecl);
946               fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
947               CHARS (IDENTIFIER_LENGTH (name) + 2);
948               need_prefix = 0;
949             }
950
951           dbxout_type (TREE_TYPE (fndecl), 0);
952
953           dbxout_type_method_1 (fndecl, debug_name);
954         }
955       if (!need_prefix)
956         {
957           putc (';', asmfile);
958           CHARS (1);
959         }
960     }
961 }
962
963 /* Emit a "range" type specification, which has the form:
964    "r<index type>;<lower bound>;<upper bound>;".
965    TYPE is an INTEGER_TYPE.  */
966
967 static void
968 dbxout_range_type (type)
969      tree type;
970 {
971   fprintf (asmfile, "r");
972   if (TREE_TYPE (type))
973     dbxout_type (TREE_TYPE (type), 0);
974   else if (TREE_CODE (type) != INTEGER_TYPE)
975     dbxout_type (type, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
976   else
977     {
978       /* Traditionally, we made sure 'int' was type 1, and builtin types
979          were defined to be sub-ranges of int.  Unfortunately, this
980          does not allow us to distinguish true sub-ranges from integer
981          types.  So, instead we define integer (non-sub-range) types as
982          sub-ranges of themselves.  This matters for Chill.  If this isn't
983          a subrange type, then we want to define it in terms of itself.
984          However, in C, this may be an anonymous integer type, and we don't
985          want to emit debug info referring to it.  Just calling
986          dbxout_type_index won't work anyways, because the type hasn't been
987          defined yet.  We make this work for both cases by checked to see
988          whether this is a defined type, referring to it if it is, and using
989          'int' otherwise.  */
990       if (TYPE_SYMTAB_ADDRESS (type) != 0)
991         dbxout_type_index (type);
992       else
993         dbxout_type_index (integer_type_node);
994     }
995
996   if (TYPE_MIN_VALUE (type) != 0
997       && host_integerp (TYPE_MIN_VALUE (type), 0))
998     {
999       putc (';', asmfile);
1000       CHARS (1);
1001       print_wide_int (tree_low_cst (TYPE_MIN_VALUE (type), 0));
1002     }
1003   else
1004     {
1005       fprintf (asmfile, ";0");
1006       CHARS (2);
1007     }
1008
1009   if (TYPE_MAX_VALUE (type) != 0
1010       && host_integerp (TYPE_MAX_VALUE (type), 0))
1011     {
1012       putc (';', asmfile);
1013       CHARS (1);
1014       print_wide_int (tree_low_cst (TYPE_MAX_VALUE (type), 0));
1015       putc (';', asmfile);
1016       CHARS (1);
1017     }
1018   else
1019     {
1020       fprintf (asmfile, ";-1;");
1021       CHARS (4);
1022     }
1023 }
1024 \f
1025 /* Output a reference to a type.  If the type has not yet been
1026    described in the dbx output, output its definition now.
1027    For a type already defined, just refer to its definition
1028    using the type number.
1029
1030    If FULL is nonzero, and the type has been described only with
1031    a forward-reference, output the definition now.
1032    If FULL is zero in this case, just refer to the forward-reference
1033    using the number previously allocated.  */
1034
1035 static void
1036 dbxout_type (type, full)
1037      tree type;
1038      int full;
1039 {
1040   tree tem;
1041   static int anonymous_type_number = 0;
1042
1043   if (TREE_CODE (type) == VECTOR_TYPE)
1044     type = TYPE_DEBUG_REPRESENTATION_TYPE (type);
1045
1046   /* If there was an input error and we don't really have a type,
1047      avoid crashing and write something that is at least valid
1048      by assuming `int'.  */
1049   if (type == error_mark_node)
1050     type = integer_type_node;
1051   else
1052     {
1053       /* Try to find the "main variant" with the same name but not const
1054          or volatile.  (Since stabs does not distinguish const and volatile,
1055          there is no need to make them separate types.  But types with
1056          different names are usefully distinguished.) */
1057          
1058       for (tem = TYPE_MAIN_VARIANT (type); tem; tem = TYPE_NEXT_VARIANT (tem))
1059         if (!TYPE_READONLY (tem) && !TYPE_VOLATILE (tem)
1060             && TYPE_NAME (tem) == TYPE_NAME (type))
1061           {
1062             type = tem;
1063             break;
1064           }
1065       if (TYPE_NAME (type)
1066           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1067           && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
1068         full = 0;
1069     }
1070
1071   if (TYPE_SYMTAB_ADDRESS (type) == 0)
1072     {
1073       /* Type has no dbx number assigned.  Assign next available number.  */
1074       TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
1075
1076       /* Make sure type vector is long enough to record about this type.  */
1077
1078       if (next_type_number == typevec_len)
1079         {
1080           typevec
1081             = (struct typeinfo *) xrealloc (typevec,
1082                                             typevec_len * 2 * sizeof typevec[0]);
1083           memset ((char *) (typevec + typevec_len), 0,
1084                  typevec_len * sizeof typevec[0]);
1085           typevec_len *= 2;
1086         }
1087
1088 #ifdef DBX_USE_BINCL
1089       typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
1090         = current_file->file_number;
1091       typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
1092         = current_file->next_type_number++;
1093 #endif
1094     }
1095
1096   /* Output the number of this type, to refer to it.  */
1097   dbxout_type_index (type);
1098
1099 #ifdef DBX_TYPE_DEFINED
1100   if (DBX_TYPE_DEFINED (type))
1101     return;
1102 #endif
1103
1104   /* If this type's definition has been output or is now being output,
1105      that is all.  */
1106
1107   switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
1108     {
1109     case TYPE_UNSEEN:
1110       break;
1111     case TYPE_XREF:
1112       /* If we have already had a cross reference,
1113          and either that's all we want or that's the best we could do,
1114          don't repeat the cross reference.
1115          Sun dbx crashes if we do.  */
1116       if (! full || !COMPLETE_TYPE_P (type)
1117           /* No way in DBX fmt to describe a variable size.  */
1118           || ! host_integerp (TYPE_SIZE (type), 1))
1119         return;
1120       break;
1121     case TYPE_DEFINED:
1122       return;
1123     }
1124
1125 #ifdef DBX_NO_XREFS
1126   /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1127      leave the type-number completely undefined rather than output
1128      a cross-reference.  If we have already used GNU debug info extensions,
1129      then it is OK to output a cross reference.  This is necessary to get
1130      proper C++ debug output.  */
1131   if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
1132        || TREE_CODE (type) == QUAL_UNION_TYPE
1133        || TREE_CODE (type) == ENUMERAL_TYPE)
1134       && ! use_gnu_debug_info_extensions)
1135     /* We must use the same test here as we use twice below when deciding
1136        whether to emit a cross-reference.  */
1137     if ((TYPE_NAME (type) != 0
1138          && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1139                && DECL_IGNORED_P (TYPE_NAME (type)))
1140          && !full)
1141         || !COMPLETE_TYPE_P (type)
1142         /* No way in DBX fmt to describe a variable size.  */
1143         || ! host_integerp (TYPE_SIZE (type), 1))
1144       {
1145         typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1146         return;
1147       }
1148 #endif
1149
1150   /* Output a definition now.  */
1151
1152   fprintf (asmfile, "=");
1153   CHARS (1);
1154
1155   /* Mark it as defined, so that if it is self-referent
1156      we will not get into an infinite recursion of definitions.  */
1157
1158   typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
1159
1160   if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1161       && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1162     { 
1163       dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0);
1164       return;
1165     }
1166
1167   switch (TREE_CODE (type))
1168     {
1169     case VOID_TYPE:
1170     case LANG_TYPE:
1171       /* For a void type, just define it as itself; ie, "5=5".
1172          This makes us consider it defined
1173          without saying what it is.  The debugger will make it
1174          a void type when the reference is seen, and nothing will
1175          ever override that default.  */
1176       dbxout_type_index (type);
1177       break;
1178
1179     case INTEGER_TYPE:
1180       if (type == char_type_node && ! TREE_UNSIGNED (type))
1181         {
1182           /* Output the type `char' as a subrange of itself!
1183              I don't understand this definition, just copied it
1184              from the output of pcc.
1185              This used to use `r2' explicitly and we used to
1186              take care to make sure that `char' was type number 2.  */
1187           fprintf (asmfile, "r");
1188           CHARS (1);
1189           dbxout_type_index (type);
1190           fprintf (asmfile, ";0;127;");
1191           CHARS (7);
1192         }
1193
1194       /* If this is a subtype of another integer type, always prefer to
1195          write it as a subtype.  */
1196       else if (TREE_TYPE (type) != 0
1197                && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
1198         dbxout_range_type (type);
1199
1200       else
1201         {
1202           /* If the size is non-standard, say what it is if we can use
1203              GDB extensions.  */
1204
1205           if (use_gnu_debug_info_extensions
1206               && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1207             {
1208               have_used_extensions = 1;
1209               fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1210               CHARS (5);
1211             }
1212
1213           /* If we can use GDB extensions and the size is wider than a
1214              long (the size used by GDB to read them) or we may have
1215              trouble writing the bounds the usual way, write them in
1216              octal.  Note the test is for the *target's* size of "long",
1217              not that of the host.  The host test is just to make sure we
1218              can write it out in case the host wide int is narrower than the
1219              target "long".  */
1220
1221           /* For unsigned types, we use octal if they are the same size or
1222              larger.  This is because we print the bounds as signed decimal,
1223              and hence they can't span same size unsigned types.  */
1224
1225           if (use_gnu_debug_info_extensions
1226               && TYPE_MIN_VALUE (type) != 0
1227               && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
1228               && TYPE_MAX_VALUE (type) != 0
1229               && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
1230               && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
1231                   || ((TYPE_PRECISION (type)
1232                        == TYPE_PRECISION (integer_type_node))
1233                       && TREE_UNSIGNED (type))
1234                   || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
1235                   || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
1236                       && TREE_UNSIGNED (type))))
1237             {
1238               fprintf (asmfile, "r");
1239               CHARS (1);
1240               dbxout_type_index (type);
1241               fprintf (asmfile, ";");
1242               CHARS (1);
1243               print_int_cst_octal (TYPE_MIN_VALUE (type));
1244               fprintf (asmfile, ";");
1245               CHARS (1);
1246               print_int_cst_octal (TYPE_MAX_VALUE (type));
1247               fprintf (asmfile, ";");
1248               CHARS (1);
1249             }
1250
1251           else
1252             /* Output other integer types as subranges of `int'.  */
1253             dbxout_range_type (type);
1254         }
1255
1256       break;
1257
1258     case REAL_TYPE:
1259       /* This used to say `r1' and we used to take care
1260          to make sure that `int' was type number 1.  */
1261       fprintf (asmfile, "r");
1262       CHARS (1);
1263       dbxout_type_index (integer_type_node);
1264       putc (';', asmfile);
1265       CHARS (1);
1266       print_wide_int (int_size_in_bytes (type));
1267       fputs (";0;", asmfile);
1268       CHARS (3);
1269       break;
1270
1271     case CHAR_TYPE:
1272       if (use_gnu_debug_info_extensions)
1273         {
1274           have_used_extensions = 1;
1275           fputs ("@s", asmfile);
1276           CHARS (2);
1277           print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
1278           fputs (";-20;", asmfile);
1279           CHARS (4);
1280         }
1281       else
1282         {
1283           /* Output the type `char' as a subrange of itself.
1284              That is what pcc seems to do.  */
1285           fprintf (asmfile, "r");
1286           CHARS (1);
1287           dbxout_type_index (char_type_node);
1288           fprintf (asmfile, ";0;%d;", TREE_UNSIGNED (type) ? 255 : 127);
1289           CHARS (7);
1290         }
1291       break;
1292
1293     case BOOLEAN_TYPE:
1294       if (use_gnu_debug_info_extensions)
1295         {
1296           have_used_extensions = 1;
1297           fputs ("@s", asmfile);
1298           CHARS (2);
1299           print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
1300           fputs (";-16;", asmfile);
1301           CHARS (4);
1302         }
1303       else /* Define as enumeral type (False, True) */
1304         {
1305           fprintf (asmfile, "eFalse:0,True:1,;");
1306           CHARS (17);
1307         }
1308       break;
1309
1310     case FILE_TYPE:
1311       putc ('d', asmfile);
1312       CHARS (1);
1313       dbxout_type (TREE_TYPE (type), 0);
1314       break;
1315
1316     case COMPLEX_TYPE:
1317       /* Differs from the REAL_TYPE by its new data type number */
1318
1319       if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1320         {
1321           fprintf (asmfile, "r");
1322           CHARS (1);
1323           dbxout_type_index (type);
1324           putc (';', asmfile);
1325           CHARS (1);
1326           print_wide_int (2 * int_size_in_bytes (TREE_TYPE (type)));
1327           fputs (";0;", asmfile);
1328           CHARS (3);
1329         }
1330       else
1331         {
1332           /* Output a complex integer type as a structure,
1333              pending some other way to do it.  */
1334           putc ('s', asmfile);
1335           CHARS (1);
1336           print_wide_int (int_size_in_bytes (type));
1337           fprintf (asmfile, "real:");
1338           CHARS (5);
1339
1340           dbxout_type (TREE_TYPE (type), 0);
1341           fprintf (asmfile, ",0,%d;", TYPE_PRECISION (TREE_TYPE (type)));
1342           CHARS (7);
1343           fprintf (asmfile, "imag:");
1344           CHARS (5);
1345           dbxout_type (TREE_TYPE (type), 0);
1346           fprintf (asmfile, ",%d,%d;;", TYPE_PRECISION (TREE_TYPE (type)),
1347                    TYPE_PRECISION (TREE_TYPE (type)));
1348           CHARS (10);
1349         }
1350       break;
1351
1352     case SET_TYPE:
1353       if (use_gnu_debug_info_extensions)
1354         {
1355           have_used_extensions = 1;
1356           fputs ("@s", asmfile);
1357           CHARS (2);
1358           print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
1359           putc (';', asmfile);
1360           CHARS (1);
1361
1362           /* Check if a bitstring type, which in Chill is
1363              different from a [power]set.  */
1364           if (TYPE_STRING_FLAG (type))
1365             {
1366               fprintf (asmfile, "@S;");
1367               CHARS (3);
1368             }
1369         }
1370       putc ('S', asmfile);
1371       CHARS (1);
1372       dbxout_type (TYPE_DOMAIN (type), 0);
1373       break;
1374
1375     case ARRAY_TYPE:
1376       /* Make arrays of packed bits look like bitstrings for chill.  */
1377       if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
1378         {
1379           have_used_extensions = 1;
1380           fputs ("@s", asmfile);
1381           CHARS (2);
1382           print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
1383           fprintf (asmfile, ";@S;S");
1384           CHARS (5);
1385           dbxout_type (TYPE_DOMAIN (type), 0);
1386           break;
1387         }
1388
1389       /* Output "a" followed by a range type definition
1390          for the index type of the array
1391          followed by a reference to the target-type.
1392          ar1;0;N;M for a C array of type M and size N+1.  */
1393       /* Check if a character string type, which in Chill is
1394          different from an array of characters.  */
1395       if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
1396         {
1397           have_used_extensions = 1;
1398           fprintf (asmfile, "@S;");
1399           CHARS (3);
1400         }
1401       tem = TYPE_DOMAIN (type);
1402       if (tem == NULL)
1403         {
1404           fprintf (asmfile, "ar");
1405           CHARS (2);
1406           dbxout_type_index (integer_type_node);
1407           fprintf (asmfile, ";0;-1;");
1408           CHARS (6);
1409         }
1410       else
1411         {
1412           fprintf (asmfile, "a");
1413           CHARS (1);
1414           dbxout_range_type (tem);
1415         }
1416
1417       dbxout_type (TREE_TYPE (type), 0);
1418       break;
1419
1420     case RECORD_TYPE:
1421     case UNION_TYPE:
1422     case QUAL_UNION_TYPE:
1423       {
1424         int i, n_baseclasses = 0;
1425
1426         if (TYPE_BINFO (type) != 0
1427             && TREE_CODE (TYPE_BINFO (type)) == TREE_VEC
1428             && TYPE_BINFO_BASETYPES (type) != 0)
1429           n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
1430
1431         /* Output a structure type.  We must use the same test here as we
1432            use in the DBX_NO_XREFS case above.  */
1433         if ((TYPE_NAME (type) != 0
1434              && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1435                    && DECL_IGNORED_P (TYPE_NAME (type)))
1436              && !full)
1437             || !COMPLETE_TYPE_P (type)
1438             /* No way in DBX fmt to describe a variable size.  */
1439             || ! host_integerp (TYPE_SIZE (type), 1))
1440           {
1441             /* If the type is just a cross reference, output one
1442                and mark the type as partially described.
1443                If it later becomes defined, we will output
1444                its real definition.
1445                If the type has a name, don't nest its definition within
1446                another type's definition; instead, output an xref
1447                and let the definition come when the name is defined.  */
1448             fputs ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu", asmfile);
1449             CHARS (2);
1450 #if 0 /* This assertion is legitimately false in C++.  */
1451             /* We shouldn't be outputting a reference to a type before its
1452                definition unless the type has a tag name.
1453                A typedef name without a tag name should be impossible.  */
1454             if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
1455               abort ();
1456 #endif
1457             if (TYPE_NAME (type) != 0)
1458               dbxout_type_name (type);
1459             else
1460               {
1461                 fprintf (asmfile, "$$%d", anonymous_type_number++);
1462                 CHARS (5);
1463               }
1464
1465             fprintf (asmfile, ":");
1466             CHARS (1);
1467             typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1468             break;
1469           }
1470
1471         /* Identify record or union, and print its size.  */
1472         putc (((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'), asmfile);
1473         CHARS (1);
1474         print_wide_int (int_size_in_bytes (type));
1475
1476         if (use_gnu_debug_info_extensions)
1477           {
1478             if (n_baseclasses)
1479               {
1480                 have_used_extensions = 1;
1481                 fprintf (asmfile, "!%d,", n_baseclasses);
1482                 CHARS (8);
1483               }
1484           }
1485         for (i = 0; i < n_baseclasses; i++)
1486           {
1487             tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i);
1488
1489             if (use_gnu_debug_info_extensions)
1490               {
1491                 have_used_extensions = 1;
1492                 putc (TREE_VIA_VIRTUAL (child) ? '1' : '0', asmfile);
1493                 putc (TREE_VIA_PUBLIC (child) ? '2' : '0', asmfile);
1494                 CHARS (2);
1495                 if (TREE_VIA_VIRTUAL (child) && strcmp (lang_hooks.name, "GNU C++") == 0)
1496                   /* For a virtual base, print the (negative) offset within
1497                      the vtable where we must look to find the necessary
1498                      adjustment.  */
1499                   print_wide_int (tree_low_cst (BINFO_VPTR_FIELD (child), 0)
1500                                   * BITS_PER_UNIT);
1501                 else
1502                   print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
1503                                   * BITS_PER_UNIT);
1504                 putc (',', asmfile);
1505                 CHARS (1);
1506                 dbxout_type (BINFO_TYPE (child), 0);
1507                 putc (';', asmfile);
1508                 CHARS (1);
1509               }
1510             else
1511               {
1512                 /* Print out the base class information with fields
1513                    which have the same names at the types they hold.  */
1514                 dbxout_type_name (BINFO_TYPE (child));
1515                 putc (':', asmfile);
1516                 CHARS (1);
1517                 dbxout_type (BINFO_TYPE (child), full);
1518                 putc (',', asmfile);
1519                 CHARS (1);
1520                 print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
1521                                 * BITS_PER_UNIT);
1522                 putc (',', asmfile);
1523                 CHARS (1);
1524                 print_wide_int (tree_low_cst (DECL_SIZE
1525                                               (TYPE_NAME
1526                                                (BINFO_TYPE (child))),
1527                                               0)
1528                                 * BITS_PER_UNIT);
1529                 putc (';', asmfile);
1530                 CHARS (1);
1531               }
1532           }
1533       }
1534
1535       /* Write out the field declarations.  */
1536       dbxout_type_fields (type);
1537       if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
1538         {
1539           have_used_extensions = 1;
1540           dbxout_type_methods (type);
1541         }
1542
1543       putc (';', asmfile);
1544       CHARS (1);
1545
1546       if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
1547           /* Avoid the ~ if we don't really need it--it confuses dbx.  */
1548           && TYPE_VFIELD (type))
1549         {
1550           have_used_extensions = 1;
1551
1552           /* Tell GDB+ that it may keep reading.  */
1553           putc ('~', asmfile);
1554           CHARS (1);
1555
1556           /* We need to write out info about what field this class
1557              uses as its "main" vtable pointer field, because if this
1558              field is inherited from a base class, GDB cannot necessarily
1559              figure out which field it's using in time.  */
1560           if (TYPE_VFIELD (type))
1561             {
1562               putc ('%', asmfile);
1563               CHARS (1);
1564               dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
1565             }
1566
1567           putc (';', asmfile);
1568           CHARS (1);
1569         }
1570       break;
1571
1572     case ENUMERAL_TYPE:
1573       /* We must use the same test here as we use in the DBX_NO_XREFS case
1574          above.  We simplify it a bit since an enum will never have a variable
1575          size.  */
1576       if ((TYPE_NAME (type) != 0
1577            && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1578                  && DECL_IGNORED_P (TYPE_NAME (type)))
1579            && !full)
1580           || !COMPLETE_TYPE_P (type))
1581         {
1582           fprintf (asmfile, "xe");
1583           CHARS (2);
1584           dbxout_type_name (type);
1585           typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1586           putc (':', asmfile);
1587           CHARS (1);
1588           return;
1589         }
1590 #ifdef DBX_OUTPUT_ENUM
1591       DBX_OUTPUT_ENUM (asmfile, type);
1592 #else
1593       if (use_gnu_debug_info_extensions
1594           && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1595         {
1596           fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1597           CHARS (5);
1598         }
1599
1600       putc ('e', asmfile);
1601       CHARS (1);
1602       for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
1603         {
1604           fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1605           CHARS (IDENTIFIER_LENGTH (TREE_PURPOSE (tem)) + 1);
1606           if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
1607             print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem)));
1608           else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
1609                    && (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
1610             print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem)));
1611           else
1612             print_int_cst_octal (TREE_VALUE (tem));
1613
1614           putc (',', asmfile);
1615           CHARS (1);
1616           if (TREE_CHAIN (tem) != 0)
1617             CONTIN;
1618         }
1619
1620       putc (';', asmfile);
1621       CHARS (1);
1622 #endif
1623       break;
1624
1625     case POINTER_TYPE:
1626       putc ('*', asmfile);
1627       CHARS (1);
1628       dbxout_type (TREE_TYPE (type), 0);
1629       break;
1630
1631     case METHOD_TYPE:
1632       if (use_gnu_debug_info_extensions)
1633         {
1634           have_used_extensions = 1;
1635           putc ('#', asmfile);
1636           CHARS (1);
1637
1638           /* Write the argument types out longhand.  */
1639           dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
1640           putc (',', asmfile);
1641           CHARS (1);
1642           dbxout_type (TREE_TYPE (type), 0);
1643           dbxout_args (TYPE_ARG_TYPES (type));
1644           putc (';', asmfile);
1645           CHARS (1);
1646         }
1647       else
1648         /* Treat it as a function type.  */
1649         dbxout_type (TREE_TYPE (type), 0);
1650       break;
1651
1652     case OFFSET_TYPE:
1653       if (use_gnu_debug_info_extensions)
1654         {
1655           have_used_extensions = 1;
1656           putc ('@', asmfile);
1657           CHARS (1);
1658           dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
1659           putc (',', asmfile);
1660           CHARS (1);
1661           dbxout_type (TREE_TYPE (type), 0);
1662         }
1663       else
1664         /* Should print as an int, because it is really just an offset.  */
1665         dbxout_type (integer_type_node, 0);
1666       break;
1667
1668     case REFERENCE_TYPE:
1669       if (use_gnu_debug_info_extensions)
1670         have_used_extensions = 1;
1671       putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
1672       CHARS (1);
1673       dbxout_type (TREE_TYPE (type), 0);
1674       break;
1675
1676     case FUNCTION_TYPE:
1677       putc ('f', asmfile);
1678       CHARS (1);
1679       dbxout_type (TREE_TYPE (type), 0);
1680       break;
1681
1682     default:
1683       abort ();
1684     }
1685 }
1686
1687 /* Print the value of integer constant C, in octal,
1688    handling double precision.  */
1689
1690 static void
1691 print_int_cst_octal (c)
1692      tree c;
1693 {
1694   unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
1695   unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
1696   int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
1697   unsigned int width = TYPE_PRECISION (TREE_TYPE (c));
1698
1699   /* GDB wants constants with no extra leading "1" bits, so
1700      we need to remove any sign-extension that might be
1701      present.  */
1702   if (width == HOST_BITS_PER_WIDE_INT * 2)
1703     ;
1704   else if (width > HOST_BITS_PER_WIDE_INT)
1705     high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
1706   else if (width == HOST_BITS_PER_WIDE_INT)
1707     high = 0;
1708   else
1709     high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
1710
1711   fprintf (asmfile, "0");
1712   CHARS (1);
1713
1714   if (excess == 3)
1715     {
1716       print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
1717       print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
1718     }
1719   else
1720     {
1721       unsigned HOST_WIDE_INT beg = high >> excess;
1722       unsigned HOST_WIDE_INT middle
1723         = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
1724            | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
1725       unsigned HOST_WIDE_INT end
1726         = low & (((unsigned HOST_WIDE_INT) 1
1727                   << (HOST_BITS_PER_WIDE_INT / 3 * 3))
1728                  - 1);
1729
1730       fprintf (asmfile, "%o%01o", (int) beg, (int) middle);
1731       CHARS (2);
1732       print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
1733     }
1734 }
1735
1736 static void
1737 print_octal (value, digits)
1738      unsigned HOST_WIDE_INT value;
1739      int digits;
1740 {
1741   int i;
1742
1743   for (i = digits - 1; i >= 0; i--)
1744     fprintf (asmfile, "%01o", (int) ((value >> (3 * i)) & 7));
1745
1746   CHARS (digits);
1747 }
1748
1749 /* Output C in decimal while adjusting the number of digits written.  */
1750
1751 static void
1752 print_wide_int (c)
1753      HOST_WIDE_INT c;
1754 {
1755   int digs = 0;
1756
1757   fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, c);
1758
1759   if (c < 0)
1760     digs++, c = -c;
1761
1762   while (c > 0)
1763     c /= 10; digs++;
1764
1765   CHARS (digs);
1766 }
1767       
1768 /* Output the name of type TYPE, with no punctuation.
1769    Such names can be set up either by typedef declarations
1770    or by struct, enum and union tags.  */
1771
1772 static void
1773 dbxout_type_name (type)
1774      tree type;
1775 {
1776   tree t;
1777   if (TYPE_NAME (type) == 0)
1778     abort ();
1779   if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
1780     {
1781       t = TYPE_NAME (type);
1782     }
1783   else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1784     {
1785       t = DECL_NAME (TYPE_NAME (type));
1786     }
1787   else
1788     abort ();
1789
1790   fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
1791   CHARS (IDENTIFIER_LENGTH (t));
1792 }
1793 \f
1794 /* Output a .stabs for the symbol defined by DECL,
1795    which must be a ..._DECL node in the normal namespace.
1796    It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1797    LOCAL is nonzero if the scope is less than the entire file.
1798    Return 1 if a stabs might have been emitted.  */
1799
1800 int
1801 dbxout_symbol (decl, local)
1802      tree decl;
1803      int local ATTRIBUTE_UNUSED;
1804 {
1805   tree type = TREE_TYPE (decl);
1806   tree context = NULL_TREE;
1807   int result = 0;
1808
1809   /* Cast avoids warning in old compilers.  */
1810   current_sym_code = (STAB_CODE_TYPE) 0;
1811   current_sym_value = 0;
1812   current_sym_addr = 0;
1813
1814   /* Ignore nameless syms, but don't ignore type tags.  */
1815
1816   if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
1817       || DECL_IGNORED_P (decl))
1818     return 0;
1819
1820   dbxout_prepare_symbol (decl);
1821
1822   /* The output will always start with the symbol name,
1823      so always count that in the length-output-so-far.  */
1824
1825   if (DECL_NAME (decl) != 0)
1826     current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
1827
1828   switch (TREE_CODE (decl))
1829     {
1830     case CONST_DECL:
1831       /* Enum values are defined by defining the enum type.  */
1832       break;
1833
1834     case FUNCTION_DECL:
1835       if (DECL_RTL (decl) == 0)
1836         return 0;
1837       if (DECL_EXTERNAL (decl))
1838         break;
1839       /* Don't mention a nested function under its parent.  */
1840       context = decl_function_context (decl);
1841       if (context == current_function_decl)
1842         break;
1843       if (GET_CODE (DECL_RTL (decl)) != MEM
1844           || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
1845         break;
1846       FORCE_TEXT;
1847
1848       fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
1849                IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1850                TREE_PUBLIC (decl) ? 'F' : 'f');
1851       result = 1;
1852
1853       current_sym_code = N_FUN;
1854       current_sym_addr = XEXP (DECL_RTL (decl), 0);
1855
1856       if (TREE_TYPE (type))
1857         dbxout_type (TREE_TYPE (type), 0);
1858       else
1859         dbxout_type (void_type_node, 0);
1860
1861       /* For a nested function, when that function is compiled,
1862          mention the containing function name
1863          as well as (since dbx wants it) our own assembler-name.  */
1864       if (context != 0)
1865         fprintf (asmfile, ",%s,%s",
1866                  IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1867                  IDENTIFIER_POINTER (DECL_NAME (context)));
1868
1869       dbxout_finish_symbol (decl);
1870       break;
1871
1872     case TYPE_DECL:
1873 #if 0
1874       /* This seems all wrong.  Outputting most kinds of types gives no name
1875          at all.  A true definition gives no name; a cross-ref for a
1876          structure can give the tag name, but not a type name.
1877          It seems that no typedef name is defined by outputting a type.  */
1878
1879       /* If this typedef name was defined by outputting the type,
1880          don't duplicate it.  */
1881       if (typevec[TYPE_SYMTAB_ADDRESS (type)].status == TYPE_DEFINED
1882           && TYPE_NAME (TREE_TYPE (decl)) == decl)
1883         return 0;
1884 #endif
1885       /* Don't output the same typedef twice.
1886          And don't output what language-specific stuff doesn't want output.  */
1887       if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
1888         return 0;
1889
1890       FORCE_TEXT;
1891       result = 1;
1892       {
1893         int tag_needed = 1;
1894         int did_output = 0;
1895
1896         if (DECL_NAME (decl))
1897           {
1898             /* Nonzero means we must output a tag as well as a typedef.  */
1899             tag_needed = 0;
1900
1901             /* Handle the case of a C++ structure or union
1902                where the TYPE_NAME is a TYPE_DECL
1903                which gives both a typedef name and a tag.  */
1904             /* dbx requires the tag first and the typedef second.  */
1905             if ((TREE_CODE (type) == RECORD_TYPE
1906                  || TREE_CODE (type) == UNION_TYPE
1907                  || TREE_CODE (type) == QUAL_UNION_TYPE)
1908                 && TYPE_NAME (type) == decl
1909                 && !(use_gnu_debug_info_extensions && have_used_extensions)
1910                 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
1911                 /* Distinguish the implicit typedefs of C++
1912                    from explicit ones that might be found in C.  */
1913                 && DECL_ARTIFICIAL (decl)
1914                 /* Do not generate a tag for records of variable size,
1915                    since this type can not be properly described in the
1916                    DBX format, and it confuses some tools such as objdump.  */
1917                 && host_integerp (TYPE_SIZE (type), 1))
1918               {
1919                 tree name = TYPE_NAME (type);
1920                 if (TREE_CODE (name) == TYPE_DECL)
1921                   name = DECL_NAME (name);
1922
1923                 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1924                 current_sym_value = 0;
1925                 current_sym_addr = 0;
1926                 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1927
1928                 fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
1929                          IDENTIFIER_POINTER (name));
1930                 dbxout_type (type, 1);
1931                 dbxout_finish_symbol (NULL_TREE);
1932               }
1933
1934             /* Output typedef name.  */
1935             fprintf (asmfile, "%s\"%s:", ASM_STABS_OP,
1936                      IDENTIFIER_POINTER (DECL_NAME (decl)));
1937
1938             /* Short cut way to output a tag also.  */
1939             if ((TREE_CODE (type) == RECORD_TYPE
1940                  || TREE_CODE (type) == UNION_TYPE
1941                  || TREE_CODE (type) == QUAL_UNION_TYPE)
1942                 && TYPE_NAME (type) == decl
1943                 /* Distinguish the implicit typedefs of C++
1944                    from explicit ones that might be found in C.  */
1945                 && DECL_ARTIFICIAL (decl))
1946               {
1947                 if (use_gnu_debug_info_extensions && have_used_extensions)
1948                   {
1949                     putc ('T', asmfile);
1950                     TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
1951                   }
1952 #if 0 /* Now we generate the tag for this case up above.  */
1953                 else
1954                   tag_needed = 1;
1955 #endif
1956               }
1957
1958             putc ('t', asmfile);
1959             current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1960
1961             dbxout_type (type, 1);
1962             dbxout_finish_symbol (decl);
1963             did_output = 1;
1964           }
1965
1966         /* Don't output a tag if this is an incomplete type.  This prevents
1967            the sun4 Sun OS 4.x dbx from crashing.  */
1968
1969         if (tag_needed && TYPE_NAME (type) != 0
1970             && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
1971                 || (DECL_NAME (TYPE_NAME (type)) != 0))
1972             && COMPLETE_TYPE_P (type)
1973             && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
1974           {
1975             /* For a TYPE_DECL with no name, but the type has a name,
1976                output a tag.
1977                This is what represents `struct foo' with no typedef.  */
1978             /* In C++, the name of a type is the corresponding typedef.
1979                In C, it is an IDENTIFIER_NODE.  */
1980             tree name = TYPE_NAME (type);
1981             if (TREE_CODE (name) == TYPE_DECL)
1982               name = DECL_NAME (name);
1983
1984             current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1985             current_sym_value = 0;
1986             current_sym_addr = 0;
1987             current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1988
1989             fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
1990                      IDENTIFIER_POINTER (name));
1991             dbxout_type (type, 1);
1992             dbxout_finish_symbol (NULL_TREE);
1993             did_output = 1;
1994           }
1995
1996         /* If an enum type has no name, it cannot be referred to,
1997            but we must output it anyway, since the enumeration constants
1998            can be referred to.  */
1999         if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
2000           {
2001             current_sym_code = DBX_TYPE_DECL_STABS_CODE;
2002             current_sym_value = 0;
2003             current_sym_addr = 0;
2004             current_sym_nchars = 2;
2005
2006             /* Some debuggers fail when given NULL names, so give this a
2007                harmless name of ` '.  */
2008             fprintf (asmfile, "%s\" :T", ASM_STABS_OP);
2009             dbxout_type (type, 1);
2010             dbxout_finish_symbol (NULL_TREE);
2011           }
2012
2013         /* Prevent duplicate output of a typedef.  */
2014         TREE_ASM_WRITTEN (decl) = 1;
2015         break;
2016       }
2017
2018     case PARM_DECL:
2019       /* Parm decls go in their own separate chains
2020          and are output by dbxout_reg_parms and dbxout_parms.  */
2021       abort ();
2022
2023     case RESULT_DECL:
2024       /* Named return value, treat like a VAR_DECL.  */
2025     case VAR_DECL:
2026       if (! DECL_RTL_SET_P (decl))
2027         return 0;
2028       /* Don't mention a variable that is external.
2029          Let the file that defines it describe it.  */
2030       if (DECL_EXTERNAL (decl))
2031         break;
2032
2033       /* If the variable is really a constant
2034          and not written in memory, inform the debugger.  */
2035       if (TREE_STATIC (decl) && TREE_READONLY (decl)
2036           && DECL_INITIAL (decl) != 0
2037           && host_integerp (DECL_INITIAL (decl), 0)
2038           && ! TREE_ASM_WRITTEN (decl)
2039           && (DECL_CONTEXT (decl) == NULL_TREE
2040               || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK))
2041         {
2042           if (TREE_PUBLIC (decl) == 0)
2043             {
2044               /* The sun4 assembler does not grok this.  */
2045               const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
2046
2047               if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
2048                   || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
2049                 {
2050                   HOST_WIDE_INT ival = tree_low_cst (DECL_INITIAL (decl), 0);
2051 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
2052                   DBX_OUTPUT_CONSTANT_SYMBOL (asmfile, name, ival);
2053 #else
2054                   fprintf (asmfile, "%s\"%s:c=i", ASM_STABS_OP, name);
2055
2056                   fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, ival);
2057                   fprintf (asmfile, "\",0x%x,0,0,0\n", N_LSYM);
2058 #endif
2059                   return 1;
2060                 }
2061               else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
2062                 {
2063                   /* don't know how to do this yet.  */
2064                 }
2065               break;
2066             }
2067           /* else it is something we handle like a normal variable.  */
2068         }
2069
2070       SET_DECL_RTL (decl, eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
2071 #ifdef LEAF_REG_REMAP
2072       if (current_function_uses_only_leaf_regs)
2073         leaf_renumber_regs_insn (DECL_RTL (decl));
2074 #endif
2075
2076       result = dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
2077       break;
2078       
2079     default:
2080       break;
2081     }
2082   return result;
2083 }
2084 \f
2085 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2086    Add SUFFIX to its name, if SUFFIX is not 0.
2087    Describe the variable as residing in HOME
2088    (usually HOME is DECL_RTL (DECL), but not always).
2089    Returns 1 if the stab was really emitted.  */
2090
2091 static int
2092 dbxout_symbol_location (decl, type, suffix, home)
2093      tree decl, type;
2094      const char *suffix;
2095      rtx home;
2096 {
2097   int letter = 0;
2098   int regno = -1;
2099
2100   /* Don't mention a variable at all
2101      if it was completely optimized into nothingness.
2102      
2103      If the decl was from an inline function, then its rtl
2104      is not identically the rtl that was used in this
2105      particular compilation.  */
2106   if (GET_CODE (home) == SUBREG)
2107     {
2108       rtx value = home;
2109
2110       while (GET_CODE (value) == SUBREG)
2111         value = SUBREG_REG (value);
2112       if (GET_CODE (value) == REG)
2113         {
2114           if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
2115             return 0;
2116         }
2117       home = alter_subreg (&home);
2118     }
2119   if (GET_CODE (home) == REG)
2120     {
2121       regno = REGNO (home);
2122       if (regno >= FIRST_PSEUDO_REGISTER)
2123         return 0;
2124     }
2125
2126   /* The kind-of-variable letter depends on where
2127      the variable is and on the scope of its name:
2128      G and N_GSYM for static storage and global scope,
2129      S for static storage and file scope,
2130      V for static storage and local scope,
2131      for those two, use N_LCSYM if data is in bss segment,
2132      N_STSYM if in data segment, N_FUN otherwise.
2133      (We used N_FUN originally, then changed to N_STSYM
2134      to please GDB.  However, it seems that confused ld.
2135      Now GDB has been fixed to like N_FUN, says Kingdon.)
2136      no letter at all, and N_LSYM, for auto variable,
2137      r and N_RSYM for register variable.  */
2138
2139   if (GET_CODE (home) == MEM
2140       && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
2141     {
2142       if (TREE_PUBLIC (decl))
2143         {
2144           letter = 'G';
2145           current_sym_code = N_GSYM;
2146         }
2147       else
2148         {
2149           current_sym_addr = XEXP (home, 0);
2150
2151           letter = decl_function_context (decl) ? 'V' : 'S';
2152
2153           /* This should be the same condition as in assemble_variable, but
2154              we don't have access to dont_output_data here.  So, instead,
2155              we rely on the fact that error_mark_node initializers always
2156              end up in bss for C++ and never end up in bss for C.  */
2157           if (DECL_INITIAL (decl) == 0
2158               || (!strcmp (lang_hooks.name, "GNU C++")
2159                   && DECL_INITIAL (decl) == error_mark_node))
2160             current_sym_code = N_LCSYM;
2161           else if (DECL_IN_TEXT_SECTION (decl))
2162             /* This is not quite right, but it's the closest
2163                of all the codes that Unix defines.  */
2164             current_sym_code = DBX_STATIC_CONST_VAR_CODE;
2165           else
2166             {
2167               /* Some ports can transform a symbol ref into a label ref,
2168                  because the symbol ref is too far away and has to be
2169                  dumped into a constant pool.  Alternatively, the symbol
2170                  in the constant pool might be referenced by a different
2171                  symbol.  */
2172               if (GET_CODE (current_sym_addr) == SYMBOL_REF
2173                   && CONSTANT_POOL_ADDRESS_P (current_sym_addr))
2174                 {
2175                   rtx tmp = get_pool_constant (current_sym_addr);
2176
2177                   if (GET_CODE (tmp) == SYMBOL_REF)
2178                     current_sym_addr = tmp;
2179                 }
2180   
2181               /* Ultrix `as' seems to need this.  */
2182 #ifdef DBX_STATIC_STAB_DATA_SECTION
2183               data_section ();
2184 #endif
2185               current_sym_code = N_STSYM;
2186             }
2187         }
2188     }
2189   else if (regno >= 0)
2190     {
2191       letter = 'r';
2192       current_sym_code = N_RSYM;
2193       current_sym_value = DBX_REGISTER_NUMBER (regno);
2194     }
2195   else if (GET_CODE (home) == MEM
2196            && (GET_CODE (XEXP (home, 0)) == MEM
2197                || (GET_CODE (XEXP (home, 0)) == REG
2198                    && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
2199                    && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
2200 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2201                    && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
2202 #endif
2203                    )))
2204     /* If the value is indirect by memory or by a register
2205        that isn't the frame pointer
2206        then it means the object is variable-sized and address through
2207        that register or stack slot.  DBX has no way to represent this
2208        so all we can do is output the variable as a pointer.
2209        If it's not a parameter, ignore it.
2210        (VAR_DECLs like this can be made by integrate.c.)  */
2211     {
2212       if (GET_CODE (XEXP (home, 0)) == REG)
2213         {
2214           letter = 'r';
2215           current_sym_code = N_RSYM;
2216           if (REGNO (XEXP (home, 0)) >= FIRST_PSEUDO_REGISTER)
2217             return 0;
2218           current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
2219         }
2220       else
2221         {
2222           current_sym_code = N_LSYM;
2223           /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2224              We want the value of that CONST_INT.  */
2225           current_sym_value
2226             = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
2227         }
2228
2229       /* Effectively do build_pointer_type, but don't cache this type,
2230          since it might be temporary whereas the type it points to
2231          might have been saved for inlining.  */
2232       /* Don't use REFERENCE_TYPE because dbx can't handle that.  */
2233       type = make_node (POINTER_TYPE);
2234       TREE_TYPE (type) = TREE_TYPE (decl);
2235     }
2236   else if (GET_CODE (home) == MEM
2237            && GET_CODE (XEXP (home, 0)) == REG)
2238     {
2239       current_sym_code = N_LSYM;
2240       current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2241     }
2242   else if (GET_CODE (home) == MEM
2243            && GET_CODE (XEXP (home, 0)) == PLUS
2244            && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
2245     {
2246       current_sym_code = N_LSYM;
2247       /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2248          We want the value of that CONST_INT.  */
2249       current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2250     }
2251   else if (GET_CODE (home) == MEM
2252            && GET_CODE (XEXP (home, 0)) == CONST)
2253     {
2254       /* Handle an obscure case which can arise when optimizing and
2255          when there are few available registers.  (This is *always*
2256          the case for i386/i486 targets).  The RTL looks like
2257          (MEM (CONST ...)) even though this variable is a local `auto'
2258          or a local `register' variable.  In effect, what has happened
2259          is that the reload pass has seen that all assignments and
2260          references for one such a local variable can be replaced by
2261          equivalent assignments and references to some static storage
2262          variable, thereby avoiding the need for a register.  In such
2263          cases we're forced to lie to debuggers and tell them that
2264          this variable was itself `static'.  */
2265       current_sym_code = N_LCSYM;
2266       letter = 'V';
2267       current_sym_addr = XEXP (XEXP (home, 0), 0);
2268     }
2269   else if (GET_CODE (home) == CONCAT)
2270     {
2271       tree subtype;
2272
2273       /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
2274          for example), then there is no easy way to figure out
2275          what SUBTYPE should be.  So, we give up.  */
2276       if (TREE_CODE (type) != COMPLEX_TYPE)
2277         return 0;
2278
2279       subtype = TREE_TYPE (type);
2280
2281       /* If the variable's storage is in two parts,
2282          output each as a separate stab with a modified name.  */
2283       if (WORDS_BIG_ENDIAN)
2284         dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
2285       else
2286         dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
2287
2288       /* Cast avoids warning in old compilers.  */
2289       current_sym_code = (STAB_CODE_TYPE) 0;
2290       current_sym_value = 0;
2291       current_sym_addr = 0;
2292       dbxout_prepare_symbol (decl);
2293
2294       if (WORDS_BIG_ENDIAN)
2295         dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
2296       else
2297         dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
2298       return 1;
2299     }
2300   else
2301     /* Address might be a MEM, when DECL is a variable-sized object.
2302        Or it might be const0_rtx, meaning previous passes
2303        want us to ignore this variable.  */
2304     return 0;
2305
2306   /* Ok, start a symtab entry and output the variable name.  */
2307   FORCE_TEXT;
2308
2309 #ifdef DBX_STATIC_BLOCK_START
2310   DBX_STATIC_BLOCK_START (asmfile, current_sym_code);
2311 #endif
2312
2313   dbxout_symbol_name (decl, suffix, letter);
2314   dbxout_type (type, 0);
2315   dbxout_finish_symbol (decl);
2316
2317 #ifdef DBX_STATIC_BLOCK_END
2318   DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
2319 #endif
2320   return 1;
2321 }
2322 \f
2323 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2324    Then output LETTER to indicate the kind of location the symbol has.  */
2325
2326 static void
2327 dbxout_symbol_name (decl, suffix, letter)
2328      tree decl;
2329      const char *suffix;
2330      int letter;
2331 {
2332   const char *name;
2333
2334   if (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)))
2335     /* One slight hitch: if this is a VAR_DECL which is a static
2336        class member, we must put out the mangled name instead of the
2337        DECL_NAME.  Note also that static member (variable) names DO NOT begin
2338        with underscores in .stabs directives.  */
2339     name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2340   else
2341     /* ...but if we're function-local, we don't want to include the junk
2342        added by ASM_FORMAT_PRIVATE_NAME.  */
2343     name = IDENTIFIER_POINTER (DECL_NAME (decl));
2344
2345   if (name == 0)
2346     name = "(anon)";
2347   fprintf (asmfile, "%s\"%s%s:", ASM_STABS_OP, name,
2348            (suffix ? suffix : ""));
2349
2350   if (letter)
2351     putc (letter, asmfile);
2352 }
2353
2354 static void
2355 dbxout_prepare_symbol (decl)
2356      tree decl ATTRIBUTE_UNUSED;
2357 {
2358 #ifdef WINNING_GDB
2359   const char *filename = DECL_SOURCE_FILE (decl);
2360
2361   dbxout_source_file (asmfile, filename);
2362 #endif
2363 }
2364
2365 static void
2366 dbxout_finish_symbol (sym)
2367      tree sym;
2368 {
2369 #ifdef DBX_FINISH_SYMBOL
2370   DBX_FINISH_SYMBOL (sym);
2371 #else
2372   int line = 0;
2373   if (use_gnu_debug_info_extensions && sym != 0)
2374     line = DECL_SOURCE_LINE (sym);
2375
2376   fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line);
2377   if (current_sym_addr)
2378     output_addr_const (asmfile, current_sym_addr);
2379   else
2380     fprintf (asmfile, "%d", current_sym_value);
2381   putc ('\n', asmfile);
2382 #endif
2383 }
2384
2385 /* Output definitions of all the decls in a chain. Return non-zero if
2386    anything was output */
2387
2388 int
2389 dbxout_syms (syms)
2390      tree syms;
2391 {
2392   int result = 0;
2393   while (syms)
2394     {
2395       result += dbxout_symbol (syms, 1);
2396       syms = TREE_CHAIN (syms);
2397     }
2398   return result;
2399 }
2400 \f
2401 /* The following two functions output definitions of function parameters.
2402    Each parameter gets a definition locating it in the parameter list.
2403    Each parameter that is a register variable gets a second definition
2404    locating it in the register.
2405
2406    Printing or argument lists in gdb uses the definitions that
2407    locate in the parameter list.  But reference to the variable in
2408    expressions uses preferentially the definition as a register.  */
2409
2410 /* Output definitions, referring to storage in the parmlist,
2411    of all the parms in PARMS, which is a chain of PARM_DECL nodes.  */
2412
2413 void
2414 dbxout_parms (parms)
2415      tree parms;
2416 {
2417   for (; parms; parms = TREE_CHAIN (parms))
2418     if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node)
2419       {
2420         dbxout_prepare_symbol (parms);
2421
2422         /* Perform any necessary register eliminations on the parameter's rtl,
2423            so that the debugging output will be accurate.  */
2424         DECL_INCOMING_RTL (parms)
2425           = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
2426         SET_DECL_RTL (parms, eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
2427 #ifdef LEAF_REG_REMAP
2428         if (current_function_uses_only_leaf_regs)
2429           {
2430             leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
2431             leaf_renumber_regs_insn (DECL_RTL (parms));
2432           }
2433 #endif
2434
2435         if (PARM_PASSED_IN_MEMORY (parms))
2436           {
2437             rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
2438
2439             /* ??? Here we assume that the parm address is indexed
2440                off the frame pointer or arg pointer.
2441                If that is not true, we produce meaningless results,
2442                but do not crash.  */
2443             if (GET_CODE (addr) == PLUS
2444                 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
2445               current_sym_value = INTVAL (XEXP (addr, 1));
2446             else
2447               current_sym_value = 0;
2448
2449             current_sym_code = N_PSYM;
2450             current_sym_addr = 0;
2451
2452             FORCE_TEXT;
2453             if (DECL_NAME (parms))
2454               {
2455                 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2456
2457                 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2458                          IDENTIFIER_POINTER (DECL_NAME (parms)),
2459                          DBX_MEMPARM_STABS_LETTER);
2460               }
2461             else
2462               {
2463                 current_sym_nchars = 8;
2464                 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2465                          DBX_MEMPARM_STABS_LETTER);
2466               }
2467
2468             /* It is quite tempting to use:
2469                
2470                    dbxout_type (TREE_TYPE (parms), 0);
2471
2472                as the next statement, rather than using DECL_ARG_TYPE(), so
2473                that gcc reports the actual type of the parameter, rather
2474                than the promoted type.  This certainly makes GDB's life
2475                easier, at least for some ports.  The change is a bad idea
2476                however, since GDB expects to be able access the type without
2477                performing any conversions.  So for example, if we were
2478                passing a float to an unprototyped function, gcc will store a
2479                double on the stack, but if we emit a stab saying the type is a
2480                float, then gdb will only read in a single value, and this will
2481                produce an erroneous value.  */
2482             dbxout_type (DECL_ARG_TYPE (parms), 0);
2483             current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
2484             dbxout_finish_symbol (parms);
2485           }
2486         else if (GET_CODE (DECL_RTL (parms)) == REG)
2487           {
2488             rtx best_rtl;
2489             char regparm_letter;
2490             tree parm_type;
2491             /* Parm passed in registers and lives in registers or nowhere.  */
2492
2493             current_sym_code = DBX_REGPARM_STABS_CODE;
2494             regparm_letter = DBX_REGPARM_STABS_LETTER;
2495             current_sym_addr = 0;
2496
2497             /* If parm lives in a register, use that register;
2498                pretend the parm was passed there.  It would be more consistent
2499                to describe the register where the parm was passed,
2500                but in practice that register usually holds something else.
2501
2502                If we use DECL_RTL, then we must use the declared type of
2503                the variable, not the type that it arrived in.  */
2504             if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2505               {
2506                 best_rtl = DECL_RTL (parms);
2507                 parm_type = TREE_TYPE (parms);
2508               }
2509             /* If the parm lives nowhere, use the register where it was
2510                passed.  It is also better to use the declared type here.  */
2511             else
2512               {
2513                 best_rtl = DECL_INCOMING_RTL (parms);
2514                 parm_type = TREE_TYPE (parms);
2515               }
2516             current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
2517
2518             FORCE_TEXT;
2519             if (DECL_NAME (parms))
2520               {
2521                 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2522                 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2523                          IDENTIFIER_POINTER (DECL_NAME (parms)),
2524                          regparm_letter);
2525               }
2526             else
2527               {
2528                 current_sym_nchars = 8;
2529                 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2530                          regparm_letter);
2531               }
2532
2533             dbxout_type (parm_type, 0);
2534             dbxout_finish_symbol (parms);
2535           }
2536         else if (GET_CODE (DECL_RTL (parms)) == MEM
2537                  && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2538                  && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
2539                  && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
2540 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2541                  && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
2542 #endif
2543                  )
2544           {
2545             /* Parm was passed via invisible reference.
2546                That is, its address was passed in a register.
2547                Output it as if it lived in that register.
2548                The debugger will know from the type
2549                that it was actually passed by invisible reference.  */
2550
2551             char regparm_letter;
2552             /* Parm passed in registers and lives in registers or nowhere.  */
2553
2554             current_sym_code = DBX_REGPARM_STABS_CODE;
2555             if (use_gnu_debug_info_extensions)
2556               regparm_letter = GDB_INV_REF_REGPARM_STABS_LETTER;
2557             else
2558               regparm_letter = DBX_REGPARM_STABS_LETTER;
2559
2560             /* DECL_RTL looks like (MEM (REG...).  Get the register number.
2561                If it is an unallocated pseudo-reg, then use the register where
2562                it was passed instead.  */
2563             if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
2564               current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2565             else
2566               current_sym_value = REGNO (DECL_INCOMING_RTL (parms));
2567
2568             current_sym_addr = 0;
2569
2570             FORCE_TEXT;
2571             if (DECL_NAME (parms))
2572               {
2573                 current_sym_nchars
2574                   = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2575
2576                 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2577                          IDENTIFIER_POINTER (DECL_NAME (parms)),
2578                          regparm_letter);
2579               }
2580             else
2581               {
2582                 current_sym_nchars = 8;
2583                 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2584                          regparm_letter);
2585               }
2586
2587             dbxout_type (TREE_TYPE (parms), 0);
2588             dbxout_finish_symbol (parms);
2589           }
2590         else if (GET_CODE (DECL_RTL (parms)) == MEM
2591                  && GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
2592           {
2593             /* Parm was passed via invisible reference, with the reference
2594                living on the stack.  DECL_RTL looks like
2595                (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
2596                could look like (MEM (MEM (REG))).  */
2597             const char *const decl_name = (DECL_NAME (parms)
2598                                      ? IDENTIFIER_POINTER (DECL_NAME (parms))
2599                                      : "(anon)");
2600            if (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 0)) == REG)
2601               current_sym_value = 0;
2602             else
2603               current_sym_value
2604                 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
2605             current_sym_addr = 0;
2606               
2607             FORCE_TEXT;
2608             fprintf (asmfile, "%s\"%s:v", ASM_STABS_OP, decl_name);
2609             dbxout_type (TREE_TYPE (parms), 0);
2610             dbxout_finish_symbol (parms);
2611           }
2612         else if (GET_CODE (DECL_RTL (parms)) == MEM
2613                  && XEXP (DECL_RTL (parms), 0) != const0_rtx
2614                  /* ??? A constant address for a parm can happen
2615                     when the reg it lives in is equiv to a constant in memory.
2616                     Should make this not happen, after 2.4.  */
2617                  && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
2618           {
2619             /* Parm was passed in registers but lives on the stack.  */
2620
2621             current_sym_code = N_PSYM;
2622             /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2623                in which case we want the value of that CONST_INT,
2624                or (MEM (REG ...)),
2625                in which case we use a value of zero.  */
2626             if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG)
2627               current_sym_value = 0;
2628             else
2629                 current_sym_value
2630                   = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
2631
2632             current_sym_addr = 0;
2633
2634             /* Make a big endian correction if the mode of the type of the
2635                parameter is not the same as the mode of the rtl.  */
2636             if (BYTES_BIG_ENDIAN
2637                 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
2638                 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
2639               {
2640                 current_sym_value += 
2641                     GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
2642                     - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms)));
2643               }
2644
2645             FORCE_TEXT;
2646             if (DECL_NAME (parms))
2647               {
2648                 current_sym_nchars
2649                   = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2650
2651                 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2652                          IDENTIFIER_POINTER (DECL_NAME (parms)),
2653                          DBX_MEMPARM_STABS_LETTER);
2654               }
2655             else
2656               {
2657                 current_sym_nchars = 8;
2658                 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2659                 DBX_MEMPARM_STABS_LETTER);
2660               }
2661
2662             current_sym_value
2663               = DEBUGGER_ARG_OFFSET (current_sym_value,
2664                                      XEXP (DECL_RTL (parms), 0));
2665             dbxout_type (TREE_TYPE (parms), 0);
2666             dbxout_finish_symbol (parms);
2667           }
2668       }
2669 }
2670
2671 /* Output definitions for the places where parms live during the function,
2672    when different from where they were passed, when the parms were passed
2673    in memory.
2674
2675    It is not useful to do this for parms passed in registers
2676    that live during the function in different registers, because it is
2677    impossible to look in the passed register for the passed value,
2678    so we use the within-the-function register to begin with.
2679
2680    PARMS is a chain of PARM_DECL nodes.  */
2681
2682 void
2683 dbxout_reg_parms (parms)
2684      tree parms;
2685 {
2686   for (; parms; parms = TREE_CHAIN (parms))
2687     if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
2688       {
2689         dbxout_prepare_symbol (parms);
2690
2691         /* Report parms that live in registers during the function
2692            but were passed in memory.  */
2693         if (GET_CODE (DECL_RTL (parms)) == REG
2694             && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2695           dbxout_symbol_location (parms, TREE_TYPE (parms),
2696                                   0, DECL_RTL (parms));
2697         else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
2698           dbxout_symbol_location (parms, TREE_TYPE (parms),
2699                                   0, DECL_RTL (parms));
2700         /* Report parms that live in memory but not where they were passed.  */
2701         else if (GET_CODE (DECL_RTL (parms)) == MEM
2702                  && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
2703           dbxout_symbol_location (parms, TREE_TYPE (parms),
2704                                   0, DECL_RTL (parms));
2705       }
2706 }
2707 \f
2708 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2709    output definitions of those names, in raw form */
2710
2711 static void
2712 dbxout_args (args)
2713      tree args;
2714 {
2715   while (args)
2716     {
2717       putc (',', asmfile);
2718       dbxout_type (TREE_VALUE (args), 0);
2719       CHARS (1);
2720       args = TREE_CHAIN (args);
2721     }
2722 }
2723 \f
2724 /* Output everything about a symbol block (a BLOCK node
2725    that represents a scope level),
2726    including recursive output of contained blocks.
2727
2728    BLOCK is the BLOCK node.
2729    DEPTH is its depth within containing symbol blocks.
2730    ARGS is usually zero; but for the outermost block of the
2731    body of a function, it is a chain of PARM_DECLs for the function parameters.
2732    We output definitions of all the register parms
2733    as if they were local variables of that block.
2734
2735    If -g1 was used, we count blocks just the same, but output nothing
2736    except for the outermost block.
2737
2738    Actually, BLOCK may be several blocks chained together.
2739    We handle them all in sequence.  */
2740
2741 static void
2742 dbxout_block (block, depth, args)
2743      tree block;
2744      int depth;
2745      tree args;
2746 {
2747   int blocknum = -1;
2748
2749 #if DBX_BLOCKS_FUNCTION_RELATIVE
2750   const char *begin_label; 
2751   if (current_function_func_begin_label != NULL_TREE)
2752     begin_label = IDENTIFIER_POINTER (current_function_func_begin_label);
2753   else
2754     begin_label = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
2755 #endif
2756
2757   while (block)
2758     {
2759       /* Ignore blocks never expanded or otherwise marked as real.  */
2760       if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
2761         {
2762           int did_output;
2763
2764 #ifdef DBX_LBRAC_FIRST
2765           did_output = 1;
2766 #else
2767           /* In dbx format, the syms of a block come before the N_LBRAC.
2768              If nothing is output, we don't need the N_LBRAC, either.  */
2769           did_output = 0;
2770           if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2771             did_output = dbxout_syms (BLOCK_VARS (block));
2772           if (args)
2773             dbxout_reg_parms (args);
2774 #endif
2775
2776           /* Now output an N_LBRAC symbol to represent the beginning of
2777              the block.  Use the block's tree-walk order to generate
2778              the assembler symbols LBBn and LBEn
2779              that final will define around the code in this block.  */
2780           if (depth > 0 && did_output)
2781             {
2782               char buf[20];
2783               blocknum = BLOCK_NUMBER (block);
2784               ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
2785
2786               if (BLOCK_HANDLER_BLOCK (block))
2787                 {
2788                   /* A catch block.  Must precede N_LBRAC.  */
2789                   tree decl = BLOCK_VARS (block);
2790                   while (decl)
2791                     {
2792 #ifdef DBX_OUTPUT_CATCH
2793                       DBX_OUTPUT_CATCH (asmfile, decl, buf);
2794 #else
2795                       fprintf (asmfile, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP,
2796                                IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
2797                       assemble_name (asmfile, buf);
2798                       fprintf (asmfile, "\n");
2799 #endif
2800                       decl = TREE_CHAIN (decl);
2801                     }
2802                 }
2803
2804 #ifdef DBX_OUTPUT_LBRAC
2805               DBX_OUTPUT_LBRAC (asmfile, buf);
2806 #else
2807               fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_LBRAC);
2808               assemble_name (asmfile, buf);
2809 #if DBX_BLOCKS_FUNCTION_RELATIVE
2810               putc ('-', asmfile);
2811               assemble_name (asmfile, begin_label);
2812 #endif
2813               fprintf (asmfile, "\n");
2814 #endif
2815             }
2816
2817 #ifdef DBX_LBRAC_FIRST
2818           /* On some weird machines, the syms of a block
2819              come after the N_LBRAC.  */
2820           if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2821             dbxout_syms (BLOCK_VARS (block));
2822           if (args)
2823             dbxout_reg_parms (args);
2824 #endif
2825
2826           /* Output the subblocks.  */
2827           dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
2828
2829           /* Refer to the marker for the end of the block.  */
2830           if (depth > 0 && did_output)
2831             {
2832               char buf[20];
2833               ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
2834 #ifdef DBX_OUTPUT_RBRAC
2835               DBX_OUTPUT_RBRAC (asmfile, buf);
2836 #else
2837               fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_RBRAC);
2838               assemble_name (asmfile, buf);
2839 #if DBX_BLOCKS_FUNCTION_RELATIVE
2840               putc ('-', asmfile);
2841               assemble_name (asmfile, begin_label);
2842 #endif
2843               fprintf (asmfile, "\n");
2844 #endif
2845             }
2846         }
2847       block = BLOCK_CHAIN (block);
2848     }
2849 }
2850
2851 /* Output the information about a function and its arguments and result.
2852    Usually this follows the function's code,
2853    but on some systems, it comes before.  */
2854
2855 #if defined (DBX_DEBUGGING_INFO)
2856 static void
2857 dbxout_begin_function (decl)
2858      tree decl;
2859 {
2860   dbxout_symbol (decl, 0);
2861   dbxout_parms (DECL_ARGUMENTS (decl));
2862   if (DECL_NAME (DECL_RESULT (decl)) != 0)
2863     dbxout_symbol (DECL_RESULT (decl), 1);
2864 }
2865 #endif /* DBX_DEBUGGING_INFO */
2866
2867 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */