Daily bump.
[official-gcc.git] / gcc / dbxout.c
blobad1b3c76eddf13afe9acf08eb5c25a1dc4986aad
1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
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.
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.
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.
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".
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'.
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.
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.
66 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
67 output while in the text section.
69 For more on data type definitions, see `dbxout_type'. */
71 #include "config.h"
72 #include "system.h"
73 #include "coretypes.h"
74 #include "tm.h"
76 #include "tree.h"
77 #include "rtl.h"
78 #include "flags.h"
79 #include "regs.h"
80 #include "insn-config.h"
81 #include "reload.h"
82 #include "output.h"
83 #include "dbxout.h"
84 #include "toplev.h"
85 #include "tm_p.h"
86 #include "ggc.h"
87 #include "debug.h"
88 #include "function.h"
89 #include "target.h"
90 #include "langhooks.h"
91 #include "obstack.h"
92 #include "expr.h"
94 #ifdef XCOFF_DEBUGGING_INFO
95 #include "xcoffout.h"
96 #endif
98 #define DBXOUT_DECR_NESTING \
99 if (--debug_nesting == 0 && symbol_queue_index > 0) \
100 { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
102 #define DBXOUT_DECR_NESTING_AND_RETURN(x) \
103 do {--debug_nesting; return (x);} while (0)
105 #ifndef ASM_STABS_OP
106 # ifdef XCOFF_DEBUGGING_INFO
107 # define ASM_STABS_OP "\t.stabx\t"
108 # else
109 # define ASM_STABS_OP "\t.stabs\t"
110 # endif
111 #endif
113 #ifndef ASM_STABN_OP
114 #define ASM_STABN_OP "\t.stabn\t"
115 #endif
117 #ifndef ASM_STABD_OP
118 #define ASM_STABD_OP "\t.stabd\t"
119 #endif
121 #ifndef DBX_TYPE_DECL_STABS_CODE
122 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
123 #endif
125 #ifndef DBX_STATIC_CONST_VAR_CODE
126 #define DBX_STATIC_CONST_VAR_CODE N_FUN
127 #endif
129 #ifndef DBX_REGPARM_STABS_CODE
130 #define DBX_REGPARM_STABS_CODE N_RSYM
131 #endif
133 #ifndef DBX_REGPARM_STABS_LETTER
134 #define DBX_REGPARM_STABS_LETTER 'P'
135 #endif
137 #ifndef NO_DBX_FUNCTION_END
138 #define NO_DBX_FUNCTION_END 0
139 #endif
141 #ifndef NO_DBX_BNSYM_ENSYM
142 #define NO_DBX_BNSYM_ENSYM 0
143 #endif
145 #ifndef NO_DBX_MAIN_SOURCE_DIRECTORY
146 #define NO_DBX_MAIN_SOURCE_DIRECTORY 0
147 #endif
149 #ifndef DBX_BLOCKS_FUNCTION_RELATIVE
150 #define DBX_BLOCKS_FUNCTION_RELATIVE 0
151 #endif
153 #ifndef DBX_LINES_FUNCTION_RELATIVE
154 #define DBX_LINES_FUNCTION_RELATIVE 0
155 #endif
157 #ifndef DBX_CONTIN_LENGTH
158 #define DBX_CONTIN_LENGTH 80
159 #endif
161 #ifndef DBX_CONTIN_CHAR
162 #define DBX_CONTIN_CHAR '\\'
163 #endif
165 enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
167 /* Structure recording information about a C data type.
168 The status element says whether we have yet output
169 the definition of the type. TYPE_XREF says we have
170 output it as a cross-reference only.
171 The file_number and type_number elements are used if DBX_USE_BINCL
172 is defined. */
174 struct typeinfo GTY(())
176 enum typestatus status;
177 int file_number;
178 int type_number;
181 /* Vector recording information about C data types.
182 When we first notice a data type (a tree node),
183 we assign it a number using next_type_number.
184 That is its index in this vector. */
186 static GTY ((length ("typevec_len"))) struct typeinfo *typevec;
188 /* Number of elements of space allocated in `typevec'. */
190 static GTY(()) int typevec_len;
192 /* In dbx output, each type gets a unique number.
193 This is the number for the next type output.
194 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
196 static GTY(()) int next_type_number;
198 /* The C front end may call dbxout_symbol before dbxout_init runs.
199 We save all such decls in this list and output them when we get
200 to dbxout_init. */
202 static GTY(()) tree preinit_symbols;
204 enum binclstatus {BINCL_NOT_REQUIRED, BINCL_PENDING, BINCL_PROCESSED};
206 /* When using N_BINCL in dbx output, each type number is actually a
207 pair of the file number and the type number within the file.
208 This is a stack of input files. */
210 struct dbx_file
212 struct dbx_file *next;
213 int file_number;
214 int next_type_number;
215 enum binclstatus bincl_status; /* Keep track of lazy bincl. */
216 const char *pending_bincl_name; /* Name of bincl. */
217 struct dbx_file *prev; /* Chain to traverse all pending bincls. */
220 /* This is the top of the stack.
222 This is not saved for PCH, because restoring a PCH should not change it.
223 next_file_number does have to be saved, because the PCH may use some
224 file numbers; however, just before restoring a PCH, next_file_number
225 should always be 0 because we should not have needed any file numbers
226 yet. */
228 #if (defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)) \
229 && defined (DBX_USE_BINCL)
230 static struct dbx_file *current_file;
231 #endif
233 /* This is the next file number to use. */
235 static GTY(()) int next_file_number;
237 /* A counter for dbxout_function_end. */
239 static GTY(()) int scope_labelno;
241 /* A counter for dbxout_source_line. */
243 static GTY(()) int dbxout_source_line_counter;
245 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
246 for the N_SO filename stabs label. */
248 static GTY(()) int source_label_number = 1;
250 /* Last source file name mentioned in a NOTE insn. */
252 static GTY(()) const char *lastfile;
254 /* Used by PCH machinery to detect if 'lastfile' should be reset to
255 base_input_file. */
256 static GTY(()) int lastfile_is_base;
258 /* Typical USG systems don't have stab.h, and they also have
259 no use for DBX-format debugging info. */
261 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
263 #ifdef DBX_USE_BINCL
264 /* If zero then there is no pending BINCL. */
265 static int pending_bincls = 0;
266 #endif
268 /* The original input file name. */
269 static const char *base_input_file;
271 #ifdef DEBUG_SYMS_TEXT
272 #define FORCE_TEXT switch_to_section (current_function_section ())
273 #else
274 #define FORCE_TEXT
275 #endif
277 #include "gstab.h"
279 #define STAB_CODE_TYPE enum __stab_debug_code
281 /* 1 if PARM is passed to this function in memory. */
283 #define PARM_PASSED_IN_MEMORY(PARM) \
284 (MEM_P (DECL_INCOMING_RTL (PARM)))
286 /* A C expression for the integer offset value of an automatic variable
287 (N_LSYM) having address X (an RTX). */
288 #ifndef DEBUGGER_AUTO_OFFSET
289 #define DEBUGGER_AUTO_OFFSET(X) \
290 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
291 #endif
293 /* A C expression for the integer offset value of an argument (N_PSYM)
294 having address X (an RTX). The nominal offset is OFFSET. */
295 #ifndef DEBUGGER_ARG_OFFSET
296 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
297 #endif
299 /* This obstack holds the stab string currently being constructed. We
300 build it up here, then write it out, so we can split long lines up
301 properly (see dbxout_finish_complex_stabs). */
302 static struct obstack stabstr_ob;
303 static size_t stabstr_last_contin_point;
305 #ifdef DBX_USE_BINCL
306 static void emit_bincl_stab (const char *c);
307 static void emit_pending_bincls (void);
308 #endif
309 static inline void emit_pending_bincls_if_required (void);
311 static void dbxout_init (const char *);
313 static void dbxout_finish (const char *);
314 static void dbxout_start_source_file (unsigned, const char *);
315 static void dbxout_end_source_file (unsigned);
316 static void dbxout_typedefs (tree);
317 static void dbxout_type_index (tree);
318 static void dbxout_args (tree);
319 static void dbxout_type_fields (tree);
320 static void dbxout_type_method_1 (tree);
321 static void dbxout_type_methods (tree);
322 static void dbxout_range_type (tree);
323 static void dbxout_type (tree, int);
324 static bool print_int_cst_bounds_in_octal_p (tree);
325 static void dbxout_type_name (tree);
326 static void dbxout_class_name_qualifiers (tree);
327 static int dbxout_symbol_location (tree, tree, const char *, rtx);
328 static void dbxout_symbol_name (tree, const char *, int);
329 static void dbxout_global_decl (tree);
330 static void dbxout_type_decl (tree, int);
331 static void dbxout_handle_pch (unsigned);
333 /* The debug hooks structure. */
334 #if defined (DBX_DEBUGGING_INFO)
336 static void dbxout_source_line (unsigned int, const char *);
337 static void dbxout_begin_prologue (unsigned int, const char *);
338 static void dbxout_source_file (const char *);
339 static void dbxout_function_end (tree);
340 static void dbxout_begin_function (tree);
341 static void dbxout_begin_block (unsigned, unsigned);
342 static void dbxout_end_block (unsigned, unsigned);
343 static void dbxout_function_decl (tree);
345 const struct gcc_debug_hooks dbx_debug_hooks =
347 dbxout_init,
348 dbxout_finish,
349 debug_nothing_int_charstar,
350 debug_nothing_int_charstar,
351 dbxout_start_source_file,
352 dbxout_end_source_file,
353 dbxout_begin_block,
354 dbxout_end_block,
355 debug_true_const_tree, /* ignore_block */
356 dbxout_source_line, /* source_line */
357 dbxout_begin_prologue, /* begin_prologue */
358 debug_nothing_int_charstar, /* end_prologue */
359 debug_nothing_int_charstar, /* end_epilogue */
360 #ifdef DBX_FUNCTION_FIRST
361 dbxout_begin_function,
362 #else
363 debug_nothing_tree, /* begin_function */
364 #endif
365 debug_nothing_int, /* end_function */
366 dbxout_function_decl,
367 dbxout_global_decl, /* global_decl */
368 dbxout_type_decl, /* type_decl */
369 debug_nothing_tree_tree, /* imported_module_or_decl */
370 debug_nothing_tree, /* deferred_inline_function */
371 debug_nothing_tree, /* outlining_inline_function */
372 debug_nothing_rtx, /* label */
373 dbxout_handle_pch, /* handle_pch */
374 debug_nothing_rtx, /* var_location */
375 debug_nothing_void, /* switch_text_section */
376 0 /* start_end_main_source_file */
378 #endif /* DBX_DEBUGGING_INFO */
380 #if defined (XCOFF_DEBUGGING_INFO)
381 const struct gcc_debug_hooks xcoff_debug_hooks =
383 dbxout_init,
384 dbxout_finish,
385 debug_nothing_int_charstar,
386 debug_nothing_int_charstar,
387 dbxout_start_source_file,
388 dbxout_end_source_file,
389 xcoffout_begin_block,
390 xcoffout_end_block,
391 debug_true_const_tree, /* ignore_block */
392 xcoffout_source_line,
393 xcoffout_begin_prologue, /* begin_prologue */
394 debug_nothing_int_charstar, /* end_prologue */
395 xcoffout_end_epilogue,
396 debug_nothing_tree, /* begin_function */
397 xcoffout_end_function,
398 debug_nothing_tree, /* function_decl */
399 dbxout_global_decl, /* global_decl */
400 dbxout_type_decl, /* type_decl */
401 debug_nothing_tree_tree, /* imported_module_or_decl */
402 debug_nothing_tree, /* deferred_inline_function */
403 debug_nothing_tree, /* outlining_inline_function */
404 debug_nothing_rtx, /* label */
405 dbxout_handle_pch, /* handle_pch */
406 debug_nothing_rtx, /* var_location */
407 debug_nothing_void, /* switch_text_section */
408 0 /* start_end_main_source_file */
410 #endif /* XCOFF_DEBUGGING_INFO */
412 /* Numeric formatting helper macro. Note that this does not handle
413 hexadecimal. */
414 #define NUMBER_FMT_LOOP(P, NUM, BASE) \
415 do \
417 int digit = NUM % BASE; \
418 NUM /= BASE; \
419 *--P = digit + '0'; \
421 while (NUM > 0)
423 /* Utility: write a decimal integer NUM to asm_out_file. */
424 void
425 dbxout_int (int num)
427 char buf[64];
428 char *p = buf + sizeof buf;
429 unsigned int unum;
431 if (num == 0)
433 putc ('0', asm_out_file);
434 return;
436 if (num < 0)
438 putc ('-', asm_out_file);
439 unum = -num;
441 else
442 unum = num;
444 NUMBER_FMT_LOOP (p, unum, 10);
446 while (p < buf + sizeof buf)
448 putc (*p, asm_out_file);
449 p++;
454 /* Primitives for emitting simple stabs directives. All other stabs
455 routines should use these functions instead of directly emitting
456 stabs. They are exported because machine-dependent code may need
457 to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
458 forwards to code in CPU.c. */
460 /* The following functions should all be called immediately after one
461 of the dbxout_begin_stab* functions (below). They write out
462 various things as the value of a stab. */
464 /* Write out a literal zero as the value of a stab. */
465 void
466 dbxout_stab_value_zero (void)
468 fputs ("0\n", asm_out_file);
471 /* Write out the label LABEL as the value of a stab. */
472 void
473 dbxout_stab_value_label (const char *label)
475 assemble_name (asm_out_file, label);
476 putc ('\n', asm_out_file);
479 /* Write out the difference of two labels, LABEL - BASE, as the value
480 of a stab. */
481 void
482 dbxout_stab_value_label_diff (const char *label, const char *base)
484 assemble_name (asm_out_file, label);
485 putc ('-', asm_out_file);
486 assemble_name (asm_out_file, base);
487 putc ('\n', asm_out_file);
490 /* Write out an internal label as the value of a stab, and immediately
491 emit that internal label. This should be used only when
492 dbxout_stabd will not work. STEM is the name stem of the label,
493 COUNTERP is a pointer to a counter variable which will be used to
494 guarantee label uniqueness. */
495 void
496 dbxout_stab_value_internal_label (const char *stem, int *counterp)
498 char label[100];
499 int counter = counterp ? (*counterp)++ : 0;
501 ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
502 dbxout_stab_value_label (label);
503 targetm.asm_out.internal_label (asm_out_file, stem, counter);
506 /* Write out the difference between BASE and an internal label as the
507 value of a stab, and immediately emit that internal label. STEM and
508 COUNTERP are as for dbxout_stab_value_internal_label. */
509 void
510 dbxout_stab_value_internal_label_diff (const char *stem, int *counterp,
511 const char *base)
513 char label[100];
514 int counter = counterp ? (*counterp)++ : 0;
516 ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
517 dbxout_stab_value_label_diff (label, base);
518 targetm.asm_out.internal_label (asm_out_file, stem, counter);
521 /* The following functions produce specific kinds of stab directives. */
523 /* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file. */
524 void
525 dbxout_stabd (int stype, int sdesc)
527 fputs (ASM_STABD_OP, asm_out_file);
528 dbxout_int (stype);
529 fputs (",0,", asm_out_file);
530 dbxout_int (sdesc);
531 putc ('\n', asm_out_file);
534 /* Write a .stabn directive with type STYPE. This function stops
535 short of emitting the value field, which is the responsibility of
536 the caller (normally it will be either a symbol or the difference
537 of two symbols). */
539 void
540 dbxout_begin_stabn (int stype)
542 fputs (ASM_STABN_OP, asm_out_file);
543 dbxout_int (stype);
544 fputs (",0,0,", asm_out_file);
547 /* Write a .stabn directive with type N_SLINE and desc LINE. As above,
548 the value field is the responsibility of the caller. */
549 void
550 dbxout_begin_stabn_sline (int lineno)
552 fputs (ASM_STABN_OP, asm_out_file);
553 dbxout_int (N_SLINE);
554 fputs (",0,", asm_out_file);
555 dbxout_int (lineno);
556 putc (',', asm_out_file);
559 /* Begin a .stabs directive with string "", type STYPE, and desc and
560 other fields 0. The value field is the responsibility of the
561 caller. This function cannot be used for .stabx directives. */
562 void
563 dbxout_begin_empty_stabs (int stype)
565 fputs (ASM_STABS_OP, asm_out_file);
566 fputs ("\"\",", asm_out_file);
567 dbxout_int (stype);
568 fputs (",0,0,", asm_out_file);
571 /* Begin a .stabs directive with string STR, type STYPE, and desc 0.
572 The value field is the responsibility of the caller. */
573 void
574 dbxout_begin_simple_stabs (const char *str, int stype)
576 fputs (ASM_STABS_OP, asm_out_file);
577 output_quoted_string (asm_out_file, str);
578 putc (',', asm_out_file);
579 dbxout_int (stype);
580 fputs (",0,0,", asm_out_file);
583 /* As above but use SDESC for the desc field. */
584 void
585 dbxout_begin_simple_stabs_desc (const char *str, int stype, int sdesc)
587 fputs (ASM_STABS_OP, asm_out_file);
588 output_quoted_string (asm_out_file, str);
589 putc (',', asm_out_file);
590 dbxout_int (stype);
591 fputs (",0,", asm_out_file);
592 dbxout_int (sdesc);
593 putc (',', asm_out_file);
596 /* The next set of functions are entirely concerned with production of
597 "complex" .stabs directives: that is, .stabs directives whose
598 strings have to be constructed piecemeal. dbxout_type,
599 dbxout_symbol, etc. use these routines heavily. The string is queued
600 up in an obstack, then written out by dbxout_finish_complex_stabs, which
601 is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
602 (You might think it would be more efficient to go straight to stdio
603 when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
604 out not to be the case, and anyway this needs fewer #ifdefs.) */
606 /* Begin a complex .stabs directive. If we can, write the initial
607 ASM_STABS_OP to the asm_out_file. */
609 static void
610 dbxout_begin_complex_stabs (void)
612 emit_pending_bincls_if_required ();
613 FORCE_TEXT;
614 fputs (ASM_STABS_OP, asm_out_file);
615 putc ('"', asm_out_file);
616 gcc_assert (stabstr_last_contin_point == 0);
619 /* As above, but do not force text or emit pending bincls. This is
620 used by dbxout_symbol_location, which needs to do something else. */
621 static void
622 dbxout_begin_complex_stabs_noforcetext (void)
624 fputs (ASM_STABS_OP, asm_out_file);
625 putc ('"', asm_out_file);
626 gcc_assert (stabstr_last_contin_point == 0);
629 /* Add CHR, a single character, to the string being built. */
630 #define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
632 /* Add STR, a normal C string, to the string being built. */
633 #define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen(str))
635 /* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */
636 #define stabstr_I(id) obstack_grow (&stabstr_ob, \
637 IDENTIFIER_POINTER (id), \
638 IDENTIFIER_LENGTH (id))
640 /* Add NUM, a signed decimal number, to the string being built. */
641 static void
642 stabstr_D (HOST_WIDE_INT num)
644 char buf[64];
645 char *p = buf + sizeof buf;
646 unsigned int unum;
648 if (num == 0)
650 stabstr_C ('0');
651 return;
653 if (num < 0)
655 stabstr_C ('-');
656 unum = -num;
658 else
659 unum = num;
661 NUMBER_FMT_LOOP (p, unum, 10);
663 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
666 /* Add NUM, an unsigned decimal number, to the string being built. */
667 static void
668 stabstr_U (unsigned HOST_WIDE_INT num)
670 char buf[64];
671 char *p = buf + sizeof buf;
672 if (num == 0)
674 stabstr_C ('0');
675 return;
677 NUMBER_FMT_LOOP (p, num, 10);
678 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
681 /* Add CST, an INTEGER_CST tree, to the string being built as an
682 unsigned octal number. This routine handles values which are
683 larger than a single HOST_WIDE_INT. */
684 static void
685 stabstr_O (tree cst)
687 unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (cst);
688 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (cst);
690 char buf[128];
691 char *p = buf + sizeof buf;
693 /* GDB wants constants with no extra leading "1" bits, so
694 we need to remove any sign-extension that might be
695 present. */
697 const unsigned int width = TYPE_PRECISION (TREE_TYPE (cst));
698 if (width == HOST_BITS_PER_WIDE_INT * 2)
700 else if (width > HOST_BITS_PER_WIDE_INT)
701 high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
702 else if (width == HOST_BITS_PER_WIDE_INT)
703 high = 0;
704 else
705 high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
708 /* Leading zero for base indicator. */
709 stabstr_C ('0');
711 /* If the value is zero, the base indicator will serve as the value
712 all by itself. */
713 if (high == 0 && low == 0)
714 return;
716 /* If the high half is zero, we need only print the low half normally. */
717 if (high == 0)
718 NUMBER_FMT_LOOP (p, low, 8);
719 else
721 /* When high != 0, we need to print enough zeroes from low to
722 give the digits from high their proper place-values. Hence
723 NUMBER_FMT_LOOP cannot be used. */
724 const int n_digits = HOST_BITS_PER_WIDE_INT / 3;
725 int i;
727 for (i = 1; i <= n_digits; i++)
729 unsigned int digit = low % 8;
730 low /= 8;
731 *--p = '0' + digit;
734 /* Octal digits carry exactly three bits of information. The
735 width of a HOST_WIDE_INT is not normally a multiple of three.
736 Therefore, the next digit printed probably needs to carry
737 information from both low and high. */
738 if (HOST_BITS_PER_WIDE_INT % 3 != 0)
740 const int n_leftover_bits = HOST_BITS_PER_WIDE_INT % 3;
741 const int n_bits_from_high = 3 - n_leftover_bits;
743 const unsigned HOST_WIDE_INT
744 low_mask = (((unsigned HOST_WIDE_INT)1) << n_leftover_bits) - 1;
745 const unsigned HOST_WIDE_INT
746 high_mask = (((unsigned HOST_WIDE_INT)1) << n_bits_from_high) - 1;
748 unsigned int digit;
750 /* At this point, only the bottom n_leftover_bits bits of low
751 should be set. */
752 gcc_assert (!(low & ~low_mask));
754 digit = (low | ((high & high_mask) << n_leftover_bits));
755 high >>= n_bits_from_high;
757 *--p = '0' + digit;
760 /* Now we can format high in the normal manner. However, if
761 the only bits of high that were set were handled by the
762 digit split between low and high, high will now be zero, and
763 we don't want to print extra digits in that case. */
764 if (high)
765 NUMBER_FMT_LOOP (p, high, 8);
768 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
771 /* Called whenever it is safe to break a stabs string into multiple
772 .stabs directives. If the current string has exceeded the limit
773 set by DBX_CONTIN_LENGTH, mark the current position in the buffer
774 as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
775 it is a backslash) and a null character. */
776 static inline void
777 stabstr_continue (void)
779 if (DBX_CONTIN_LENGTH > 0
780 && obstack_object_size (&stabstr_ob) - stabstr_last_contin_point
781 > DBX_CONTIN_LENGTH)
783 if (DBX_CONTIN_CHAR == '\\')
784 obstack_1grow (&stabstr_ob, '\\');
785 obstack_1grow (&stabstr_ob, DBX_CONTIN_CHAR);
786 obstack_1grow (&stabstr_ob, '\0');
787 stabstr_last_contin_point = obstack_object_size (&stabstr_ob);
790 #define CONTIN stabstr_continue ()
792 /* Macro subroutine of dbxout_finish_complex_stabs, which emits
793 all of the arguments to the .stabs directive after the string.
794 Overridden by xcoffout.h. CODE is the stabs code for this symbol;
795 LINE is the source line to write into the desc field (in extended
796 mode); SYM is the symbol itself.
798 ADDR, LABEL, and NUMBER are three different ways to represent the
799 stabs value field. At most one of these should be nonzero.
801 ADDR is used most of the time; it represents the value as an
802 RTL address constant.
804 LABEL is used (currently) only for N_CATCH stabs; it represents
805 the value as a string suitable for assemble_name.
807 NUMBER is used when the value is an offset from an implicit base
808 pointer (e.g. for a stack variable), or an index (e.g. for a
809 register variable). It represents the value as a decimal integer. */
811 #ifndef DBX_FINISH_STABS
812 #define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER) \
813 do { \
814 int line_ = use_gnu_debug_info_extensions ? LINE : 0; \
816 dbxout_int (CODE); \
817 fputs (",0,", asm_out_file); \
818 dbxout_int (line_); \
819 putc (',', asm_out_file); \
820 if (ADDR) \
821 output_addr_const (asm_out_file, ADDR); \
822 else if (LABEL) \
823 assemble_name (asm_out_file, LABEL); \
824 else \
825 dbxout_int (NUMBER); \
826 putc ('\n', asm_out_file); \
827 } while (0)
828 #endif
830 /* Finish the emission of a complex .stabs directive. When DBX_CONTIN_LENGTH
831 is zero, this has only to emit the close quote and the remainder of
832 the arguments. When it is nonzero, the string has been marshalled in
833 stabstr_ob, and this routine is responsible for breaking it up into
834 DBX_CONTIN_LENGTH-sized chunks.
836 SYM is the DECL of the symbol under consideration; it is used only
837 for its DECL_SOURCE_LINE. The other arguments are all passed directly
838 to DBX_FINISH_STABS; see above for details. */
840 static void
841 dbxout_finish_complex_stabs (tree sym, STAB_CODE_TYPE code,
842 rtx addr, const char *label, int number)
844 int line ATTRIBUTE_UNUSED;
845 char *str;
846 size_t len;
848 line = sym ? DECL_SOURCE_LINE (sym) : 0;
849 if (DBX_CONTIN_LENGTH > 0)
851 char *chunk;
852 size_t chunklen;
854 /* Nul-terminate the growing string, then get its size and
855 address. */
856 obstack_1grow (&stabstr_ob, '\0');
858 len = obstack_object_size (&stabstr_ob);
859 chunk = str = XOBFINISH (&stabstr_ob, char *);
861 /* Within the buffer are a sequence of NUL-separated strings,
862 each of which is to be written out as a separate stab
863 directive. */
864 for (;;)
866 chunklen = strlen (chunk);
867 fwrite (chunk, 1, chunklen, asm_out_file);
868 fputs ("\",", asm_out_file);
870 /* Must add an extra byte to account for the NUL separator. */
871 chunk += chunklen + 1;
872 len -= chunklen + 1;
874 /* Only put a line number on the last stab in the sequence. */
875 DBX_FINISH_STABS (sym, code, len == 0 ? line : 0,
876 addr, label, number);
877 if (len == 0)
878 break;
880 fputs (ASM_STABS_OP, asm_out_file);
881 putc ('"', asm_out_file);
883 stabstr_last_contin_point = 0;
885 else
887 /* No continuations - we can put the whole string out at once.
888 It is faster to augment the string with the close quote and
889 comma than to do a two-character fputs. */
890 obstack_grow (&stabstr_ob, "\",", 2);
891 len = obstack_object_size (&stabstr_ob);
892 str = XOBFINISH (&stabstr_ob, char *);
894 fwrite (str, 1, len, asm_out_file);
895 DBX_FINISH_STABS (sym, code, line, addr, label, number);
897 obstack_free (&stabstr_ob, str);
900 #if defined (DBX_DEBUGGING_INFO)
902 static void
903 dbxout_function_end (tree decl)
905 char lscope_label_name[100];
907 /* The Lscope label must be emitted even if we aren't doing anything
908 else; dbxout_block needs it. */
909 switch_to_section (function_section (current_function_decl));
911 /* Convert Lscope into the appropriate format for local labels in case
912 the system doesn't insert underscores in front of user generated
913 labels. */
914 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
915 targetm.asm_out.internal_label (asm_out_file, "Lscope", scope_labelno);
917 /* The N_FUN tag at the end of the function is a GNU extension,
918 which may be undesirable, and is unnecessary if we do not have
919 named sections. */
920 if (!use_gnu_debug_info_extensions
921 || NO_DBX_FUNCTION_END
922 || !targetm.have_named_sections
923 || DECL_IGNORED_P (decl))
924 return;
926 /* By convention, GCC will mark the end of a function with an N_FUN
927 symbol and an empty string. */
928 if (flag_reorder_blocks_and_partition)
930 dbxout_begin_empty_stabs (N_FUN);
931 dbxout_stab_value_label_diff (cfun->hot_section_end_label,
932 cfun->hot_section_label);
933 dbxout_begin_empty_stabs (N_FUN);
934 dbxout_stab_value_label_diff (cfun->cold_section_end_label,
935 cfun->cold_section_label);
937 else
939 char begin_label[20];
940 /* Reference current function start using LFBB. */
941 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
942 dbxout_begin_empty_stabs (N_FUN);
943 dbxout_stab_value_label_diff (lscope_label_name, begin_label);
946 if (!NO_DBX_BNSYM_ENSYM && !flag_debug_only_used_symbols)
947 dbxout_stabd (N_ENSYM, 0);
949 #endif /* DBX_DEBUGGING_INFO */
951 /* Get lang description for N_SO stab. */
952 static unsigned int ATTRIBUTE_UNUSED
953 get_lang_number (void)
955 const char *language_string = lang_hooks.name;
957 if (strcmp (language_string, "GNU C") == 0)
958 return N_SO_C;
959 else if (strcmp (language_string, "GNU C++") == 0)
960 return N_SO_CC;
961 else if (strcmp (language_string, "GNU F77") == 0)
962 return N_SO_FORTRAN;
963 else if (strcmp (language_string, "GNU F95") == 0)
964 return N_SO_FORTRAN90; /* CHECKME */
965 else if (strcmp (language_string, "GNU Pascal") == 0)
966 return N_SO_PASCAL;
967 else if (strcmp (language_string, "GNU Objective-C") == 0)
968 return N_SO_OBJC;
969 else if (strcmp (language_string, "GNU Objective-C++") == 0)
970 return N_SO_OBJCPLUS;
971 else
972 return 0;
976 /* At the beginning of compilation, start writing the symbol table.
977 Initialize `typevec' and output the standard data types of C. */
979 static void
980 dbxout_init (const char *input_file_name)
982 char ltext_label_name[100];
983 bool used_ltext_label_name = false;
984 tree syms = lang_hooks.decls.getdecls ();
985 const char *mapped_name;
987 typevec_len = 100;
988 typevec = ggc_calloc (typevec_len, sizeof typevec[0]);
990 /* stabstr_ob contains one string, which will be just fine with
991 1-byte alignment. */
992 obstack_specify_allocation (&stabstr_ob, 0, 1, xmalloc, free);
994 /* Convert Ltext into the appropriate format for local labels in case
995 the system doesn't insert underscores in front of user generated
996 labels. */
997 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
999 /* Put the current working directory in an N_SO symbol. */
1000 if (use_gnu_debug_info_extensions && !NO_DBX_MAIN_SOURCE_DIRECTORY)
1002 static const char *cwd;
1004 if (!cwd)
1006 cwd = get_src_pwd ();
1007 if (cwd[0] == '\0')
1008 cwd = "/";
1009 else if (!IS_DIR_SEPARATOR (cwd[strlen (cwd) - 1]))
1010 cwd = concat (cwd, "/", NULL);
1011 cwd = remap_debug_filename (cwd);
1013 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
1014 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file, cwd);
1015 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1016 dbxout_begin_simple_stabs_desc (cwd, N_SO, get_lang_number ());
1017 dbxout_stab_value_label (ltext_label_name);
1018 used_ltext_label_name = true;
1019 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1022 mapped_name = remap_debug_filename (input_file_name);
1023 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
1024 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file, mapped_name);
1025 #else
1026 dbxout_begin_simple_stabs_desc (mapped_name, N_SO, get_lang_number ());
1027 dbxout_stab_value_label (ltext_label_name);
1028 used_ltext_label_name = true;
1029 #endif
1031 if (used_ltext_label_name)
1033 switch_to_section (text_section);
1034 targetm.asm_out.internal_label (asm_out_file, "Ltext", 0);
1037 /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
1038 The string used is historical. */
1039 #ifndef NO_DBX_GCC_MARKER
1040 dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT);
1041 dbxout_stab_value_zero ();
1042 #endif
1044 base_input_file = lastfile = input_file_name;
1046 next_type_number = 1;
1048 #ifdef DBX_USE_BINCL
1049 current_file = XNEW (struct dbx_file);
1050 current_file->next = NULL;
1051 current_file->file_number = 0;
1052 current_file->next_type_number = 1;
1053 next_file_number = 1;
1054 current_file->prev = NULL;
1055 current_file->bincl_status = BINCL_NOT_REQUIRED;
1056 current_file->pending_bincl_name = NULL;
1057 #endif
1059 /* Get all permanent types that have typedef names, and output them
1060 all, except for those already output. Some language front ends
1061 put these declarations in the top-level scope; some do not;
1062 the latter are responsible for calling debug_hooks->type_decl from
1063 their record_builtin_type function. */
1064 dbxout_typedefs (syms);
1066 if (preinit_symbols)
1068 tree t;
1069 for (t = nreverse (preinit_symbols); t; t = TREE_CHAIN (t))
1070 dbxout_symbol (TREE_VALUE (t), 0);
1071 preinit_symbols = 0;
1075 /* Output any typedef names for types described by TYPE_DECLs in SYMS. */
1077 static void
1078 dbxout_typedefs (tree syms)
1080 for (; syms != NULL_TREE; syms = TREE_CHAIN (syms))
1082 if (TREE_CODE (syms) == TYPE_DECL)
1084 tree type = TREE_TYPE (syms);
1085 if (TYPE_NAME (type)
1086 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1087 && COMPLETE_OR_VOID_TYPE_P (type)
1088 && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
1089 dbxout_symbol (TYPE_NAME (type), 0);
1094 #ifdef DBX_USE_BINCL
1095 /* Emit BINCL stab using given name. */
1096 static void
1097 emit_bincl_stab (const char *name)
1099 dbxout_begin_simple_stabs (name, N_BINCL);
1100 dbxout_stab_value_zero ();
1103 /* If there are pending bincls then it is time to emit all of them. */
1105 static inline void
1106 emit_pending_bincls_if_required (void)
1108 if (pending_bincls)
1109 emit_pending_bincls ();
1112 /* Emit all pending bincls. */
1114 static void
1115 emit_pending_bincls (void)
1117 struct dbx_file *f = current_file;
1119 /* Find first pending bincl. */
1120 while (f->bincl_status == BINCL_PENDING)
1121 f = f->next;
1123 /* Now emit all bincls. */
1124 f = f->prev;
1126 while (f)
1128 if (f->bincl_status == BINCL_PENDING)
1130 emit_bincl_stab (f->pending_bincl_name);
1132 /* Update file number and status. */
1133 f->file_number = next_file_number++;
1134 f->bincl_status = BINCL_PROCESSED;
1136 if (f == current_file)
1137 break;
1138 f = f->prev;
1141 /* All pending bincls have been emitted. */
1142 pending_bincls = 0;
1145 #else
1147 static inline void
1148 emit_pending_bincls_if_required (void) {}
1149 #endif
1151 /* Change to reading from a new source file. Generate a N_BINCL stab. */
1153 static void
1154 dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED,
1155 const char *filename ATTRIBUTE_UNUSED)
1157 #ifdef DBX_USE_BINCL
1158 struct dbx_file *n = XNEW (struct dbx_file);
1160 n->next = current_file;
1161 n->next_type_number = 1;
1162 /* Do not assign file number now.
1163 Delay it until we actually emit BINCL. */
1164 n->file_number = 0;
1165 n->prev = NULL;
1166 current_file->prev = n;
1167 n->bincl_status = BINCL_PENDING;
1168 n->pending_bincl_name = remap_debug_filename (filename);
1169 pending_bincls = 1;
1170 current_file = n;
1171 #endif
1174 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
1176 static void
1177 dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED)
1179 #ifdef DBX_USE_BINCL
1180 /* Emit EINCL stab only if BINCL is not pending. */
1181 if (current_file->bincl_status == BINCL_PROCESSED)
1183 dbxout_begin_stabn (N_EINCL);
1184 dbxout_stab_value_zero ();
1186 current_file->bincl_status = BINCL_NOT_REQUIRED;
1187 current_file = current_file->next;
1188 #endif
1191 /* Handle a few odd cases that occur when trying to make PCH files work. */
1193 static void
1194 dbxout_handle_pch (unsigned at_end)
1196 if (! at_end)
1198 /* When using the PCH, this file will be included, so we need to output
1199 a BINCL. */
1200 dbxout_start_source_file (0, lastfile);
1202 /* The base file when using the PCH won't be the same as
1203 the base file when it's being generated. */
1204 lastfile = NULL;
1206 else
1208 /* ... and an EINCL. */
1209 dbxout_end_source_file (0);
1211 /* Deal with cases where 'lastfile' was never actually changed. */
1212 lastfile_is_base = lastfile == NULL;
1216 #if defined (DBX_DEBUGGING_INFO)
1218 static void dbxout_block (tree, int, tree);
1220 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
1222 static void
1223 dbxout_source_file (const char *filename)
1225 if (lastfile == 0 && lastfile_is_base)
1227 lastfile = base_input_file;
1228 lastfile_is_base = 0;
1231 if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
1233 /* Don't change section amid function. */
1234 if (current_function_decl == NULL_TREE)
1235 switch_to_section (text_section);
1237 dbxout_begin_simple_stabs (remap_debug_filename (filename), N_SOL);
1238 dbxout_stab_value_internal_label ("Ltext", &source_label_number);
1239 lastfile = filename;
1243 /* Output N_BNSYM, line number symbol entry, and local symbol at
1244 function scope */
1246 static void
1247 dbxout_begin_prologue (unsigned int lineno, const char *filename)
1249 if (use_gnu_debug_info_extensions
1250 && !NO_DBX_FUNCTION_END
1251 && !NO_DBX_BNSYM_ENSYM
1252 && !flag_debug_only_used_symbols)
1253 dbxout_stabd (N_BNSYM, 0);
1255 /* pre-increment the scope counter */
1256 scope_labelno++;
1258 dbxout_source_line (lineno, filename);
1259 /* Output function begin block at function scope, referenced
1260 by dbxout_block, dbxout_source_line and dbxout_function_end. */
1261 emit_pending_bincls_if_required ();
1262 targetm.asm_out.internal_label (asm_out_file, "LFBB", scope_labelno);
1265 /* Output a line number symbol entry for source file FILENAME and line
1266 number LINENO. */
1268 static void
1269 dbxout_source_line (unsigned int lineno, const char *filename)
1271 dbxout_source_file (filename);
1273 #ifdef DBX_OUTPUT_SOURCE_LINE
1274 DBX_OUTPUT_SOURCE_LINE (asm_out_file, lineno, dbxout_source_line_counter);
1275 #else
1276 if (DBX_LINES_FUNCTION_RELATIVE)
1278 char begin_label[20];
1279 dbxout_begin_stabn_sline (lineno);
1280 /* Reference current function start using LFBB. */
1281 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
1282 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter,
1283 begin_label);
1285 else
1286 dbxout_stabd (N_SLINE, lineno);
1287 #endif
1290 /* Describe the beginning of an internal block within a function. */
1292 static void
1293 dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
1295 emit_pending_bincls_if_required ();
1296 targetm.asm_out.internal_label (asm_out_file, "LBB", n);
1299 /* Describe the end line-number of an internal block within a function. */
1301 static void
1302 dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
1304 emit_pending_bincls_if_required ();
1305 targetm.asm_out.internal_label (asm_out_file, "LBE", n);
1308 /* Output dbx data for a function definition.
1309 This includes a definition of the function name itself (a symbol),
1310 definitions of the parameters (locating them in the parameter list)
1311 and then output the block that makes up the function's body
1312 (including all the auto variables of the function). */
1314 static void
1315 dbxout_function_decl (tree decl)
1317 emit_pending_bincls_if_required ();
1318 #ifndef DBX_FUNCTION_FIRST
1319 dbxout_begin_function (decl);
1320 #endif
1321 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
1322 dbxout_function_end (decl);
1325 #endif /* DBX_DEBUGGING_INFO */
1327 /* Debug information for a global DECL. Called from toplev.c after
1328 compilation proper has finished. */
1329 static void
1330 dbxout_global_decl (tree decl)
1332 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
1334 int saved_tree_used = TREE_USED (decl);
1335 TREE_USED (decl) = 1;
1336 dbxout_symbol (decl, 0);
1337 TREE_USED (decl) = saved_tree_used;
1341 /* This is just a function-type adapter; dbxout_symbol does exactly
1342 what we want but returns an int. */
1343 static void
1344 dbxout_type_decl (tree decl, int local)
1346 dbxout_symbol (decl, local);
1349 /* At the end of compilation, finish writing the symbol table.
1350 The default is to call debug_free_queue but do nothing else. */
1352 static void
1353 dbxout_finish (const char *filename ATTRIBUTE_UNUSED)
1355 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1356 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file, filename);
1357 #elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
1359 switch_to_section (text_section);
1360 dbxout_begin_empty_stabs (N_SO);
1361 dbxout_stab_value_internal_label ("Letext", 0);
1363 #endif
1364 debug_free_queue ();
1367 /* Output the index of a type. */
1369 static void
1370 dbxout_type_index (tree type)
1372 #ifndef DBX_USE_BINCL
1373 stabstr_D (TYPE_SYMTAB_ADDRESS (type));
1374 #else
1375 struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
1376 stabstr_C ('(');
1377 stabstr_D (t->file_number);
1378 stabstr_C (',');
1379 stabstr_D (t->type_number);
1380 stabstr_C (')');
1381 #endif
1386 /* Used in several places: evaluates to '0' for a private decl,
1387 '1' for a protected decl, '2' for a public decl. */
1388 #define DECL_ACCESSIBILITY_CHAR(DECL) \
1389 (TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
1391 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
1392 This must be a separate function because anonymous unions require
1393 recursive calls. */
1395 static void
1396 dbxout_type_fields (tree type)
1398 tree tem;
1400 /* Output the name, type, position (in bits), size (in bits) of each
1401 field that we can support. */
1402 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1404 /* If one of the nodes is an error_mark or its type is then
1405 return early. */
1406 if (tem == error_mark_node || TREE_TYPE (tem) == error_mark_node)
1407 return;
1409 /* Omit here local type decls until we know how to support them. */
1410 if (TREE_CODE (tem) == TYPE_DECL
1411 /* Omit here the nameless fields that are used to skip bits. */
1412 || DECL_IGNORED_P (tem)
1413 /* Omit fields whose position or size are variable or too large to
1414 represent. */
1415 || (TREE_CODE (tem) == FIELD_DECL
1416 && (! host_integerp (bit_position (tem), 0)
1417 || ! DECL_SIZE (tem)
1418 || ! host_integerp (DECL_SIZE (tem), 1))))
1419 continue;
1421 else if (TREE_CODE (tem) != CONST_DECL)
1423 /* Continue the line if necessary,
1424 but not before the first field. */
1425 if (tem != TYPE_FIELDS (type))
1426 CONTIN;
1428 if (DECL_NAME (tem))
1429 stabstr_I (DECL_NAME (tem));
1430 stabstr_C (':');
1432 if (use_gnu_debug_info_extensions
1433 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
1434 || TREE_CODE (tem) != FIELD_DECL))
1436 stabstr_C ('/');
1437 stabstr_C (DECL_ACCESSIBILITY_CHAR (tem));
1440 dbxout_type ((TREE_CODE (tem) == FIELD_DECL
1441 && DECL_BIT_FIELD_TYPE (tem))
1442 ? DECL_BIT_FIELD_TYPE (tem) : TREE_TYPE (tem), 0);
1444 if (TREE_CODE (tem) == VAR_DECL)
1446 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
1448 tree name = DECL_ASSEMBLER_NAME (tem);
1450 stabstr_C (':');
1451 stabstr_I (name);
1452 stabstr_C (';');
1454 else
1455 /* If TEM is non-static, GDB won't understand it. */
1456 stabstr_S (",0,0;");
1458 else
1460 stabstr_C (',');
1461 stabstr_D (int_bit_position (tem));
1462 stabstr_C (',');
1463 stabstr_D (tree_low_cst (DECL_SIZE (tem), 1));
1464 stabstr_C (';');
1470 /* Subroutine of `dbxout_type_methods'. Output debug info about the
1471 method described DECL. */
1473 static void
1474 dbxout_type_method_1 (tree decl)
1476 char c1 = 'A', c2;
1478 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
1479 c2 = '?';
1480 else /* it's a METHOD_TYPE. */
1482 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
1483 /* A for normal functions.
1484 B for `const' member functions.
1485 C for `volatile' member functions.
1486 D for `const volatile' member functions. */
1487 if (TYPE_READONLY (TREE_TYPE (firstarg)))
1488 c1 += 1;
1489 if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
1490 c1 += 2;
1492 if (DECL_VINDEX (decl))
1493 c2 = '*';
1494 else
1495 c2 = '.';
1498 /* ??? Output the mangled name, which contains an encoding of the
1499 method's type signature. May not be necessary anymore. */
1500 stabstr_C (':');
1501 stabstr_I (DECL_ASSEMBLER_NAME (decl));
1502 stabstr_C (';');
1503 stabstr_C (DECL_ACCESSIBILITY_CHAR (decl));
1504 stabstr_C (c1);
1505 stabstr_C (c2);
1507 if (DECL_VINDEX (decl) && host_integerp (DECL_VINDEX (decl), 0))
1509 stabstr_D (tree_low_cst (DECL_VINDEX (decl), 0));
1510 stabstr_C (';');
1511 dbxout_type (DECL_CONTEXT (decl), 0);
1512 stabstr_C (';');
1516 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
1517 in TYPE. */
1519 static void
1520 dbxout_type_methods (tree type)
1522 /* C++: put out the method names and their parameter lists */
1523 tree methods = TYPE_METHODS (type);
1524 tree fndecl;
1525 tree last;
1527 if (methods == NULL_TREE)
1528 return;
1530 if (TREE_CODE (methods) != TREE_VEC)
1531 fndecl = methods;
1532 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
1533 fndecl = TREE_VEC_ELT (methods, 0);
1534 else
1535 fndecl = TREE_VEC_ELT (methods, 1);
1537 while (fndecl)
1539 int need_prefix = 1;
1541 /* Group together all the methods for the same operation.
1542 These differ in the types of the arguments. */
1543 for (last = NULL_TREE;
1544 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
1545 fndecl = TREE_CHAIN (fndecl))
1546 /* Output the name of the field (after overloading), as
1547 well as the name of the field before overloading, along
1548 with its parameter list */
1550 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
1551 include TEMPLATE_DECLs.) The debugger doesn't know what
1552 to do with such entities anyhow. */
1553 if (TREE_CODE (fndecl) != FUNCTION_DECL)
1554 continue;
1556 CONTIN;
1558 last = fndecl;
1560 /* Also ignore abstract methods; those are only interesting to
1561 the DWARF backends. */
1562 if (DECL_IGNORED_P (fndecl) || DECL_ABSTRACT (fndecl))
1563 continue;
1565 /* Redundantly output the plain name, since that's what gdb
1566 expects. */
1567 if (need_prefix)
1569 stabstr_I (DECL_NAME (fndecl));
1570 stabstr_S ("::");
1571 need_prefix = 0;
1574 dbxout_type (TREE_TYPE (fndecl), 0);
1575 dbxout_type_method_1 (fndecl);
1577 if (!need_prefix)
1578 stabstr_C (';');
1582 /* Emit a "range" type specification, which has the form:
1583 "r<index type>;<lower bound>;<upper bound>;".
1584 TYPE is an INTEGER_TYPE. */
1586 static void
1587 dbxout_range_type (tree type)
1589 stabstr_C ('r');
1590 if (TREE_TYPE (type))
1591 dbxout_type (TREE_TYPE (type), 0);
1592 else if (TREE_CODE (type) != INTEGER_TYPE)
1593 dbxout_type (type, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1594 else
1596 /* Traditionally, we made sure 'int' was type 1, and builtin types
1597 were defined to be sub-ranges of int. Unfortunately, this
1598 does not allow us to distinguish true sub-ranges from integer
1599 types. So, instead we define integer (non-sub-range) types as
1600 sub-ranges of themselves. This matters for Chill. If this isn't
1601 a subrange type, then we want to define it in terms of itself.
1602 However, in C, this may be an anonymous integer type, and we don't
1603 want to emit debug info referring to it. Just calling
1604 dbxout_type_index won't work anyways, because the type hasn't been
1605 defined yet. We make this work for both cases by checked to see
1606 whether this is a defined type, referring to it if it is, and using
1607 'int' otherwise. */
1608 if (TYPE_SYMTAB_ADDRESS (type) != 0)
1609 dbxout_type_index (type);
1610 else
1611 dbxout_type_index (integer_type_node);
1614 stabstr_C (';');
1615 if (TYPE_MIN_VALUE (type) != 0
1616 && host_integerp (TYPE_MIN_VALUE (type), 0))
1618 if (print_int_cst_bounds_in_octal_p (type))
1619 stabstr_O (TYPE_MIN_VALUE (type));
1620 else
1621 stabstr_D (tree_low_cst (TYPE_MIN_VALUE (type), 0));
1623 else
1624 stabstr_C ('0');
1626 stabstr_C (';');
1627 if (TYPE_MAX_VALUE (type) != 0
1628 && host_integerp (TYPE_MAX_VALUE (type), 0))
1630 if (print_int_cst_bounds_in_octal_p (type))
1631 stabstr_O (TYPE_MAX_VALUE (type));
1632 else
1633 stabstr_D (tree_low_cst (TYPE_MAX_VALUE (type), 0));
1634 stabstr_C (';');
1636 else
1637 stabstr_S ("-1;");
1641 /* Output a reference to a type. If the type has not yet been
1642 described in the dbx output, output its definition now.
1643 For a type already defined, just refer to its definition
1644 using the type number.
1646 If FULL is nonzero, and the type has been described only with
1647 a forward-reference, output the definition now.
1648 If FULL is zero in this case, just refer to the forward-reference
1649 using the number previously allocated. */
1651 static void
1652 dbxout_type (tree type, int full)
1654 tree tem;
1655 tree main_variant;
1656 static int anonymous_type_number = 0;
1657 bool vector_type = false;
1659 if (TREE_CODE (type) == VECTOR_TYPE)
1661 /* The frontend feeds us a representation for the vector as a struct
1662 containing an array. Pull out the array type. */
1663 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
1664 vector_type = true;
1667 /* If there was an input error and we don't really have a type,
1668 avoid crashing and write something that is at least valid
1669 by assuming `int'. */
1670 if (type == error_mark_node)
1671 type = integer_type_node;
1672 else
1674 if (TYPE_NAME (type)
1675 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1676 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
1677 full = 0;
1680 /* Try to find the "main variant" with the same name. */
1681 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1682 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1683 main_variant = TREE_TYPE (TYPE_NAME (type));
1684 else
1685 main_variant = TYPE_MAIN_VARIANT (type);
1687 /* If we are not using extensions, stabs does not distinguish const and
1688 volatile, so there is no need to make them separate types. */
1689 if (!use_gnu_debug_info_extensions)
1690 type = main_variant;
1692 if (TYPE_SYMTAB_ADDRESS (type) == 0)
1694 /* Type has no dbx number assigned. Assign next available number. */
1695 TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
1697 /* Make sure type vector is long enough to record about this type. */
1699 if (next_type_number == typevec_len)
1701 typevec
1702 = ggc_realloc (typevec, (typevec_len * 2 * sizeof typevec[0]));
1703 memset (typevec + typevec_len, 0, typevec_len * sizeof typevec[0]);
1704 typevec_len *= 2;
1707 #ifdef DBX_USE_BINCL
1708 emit_pending_bincls_if_required ();
1709 typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
1710 = current_file->file_number;
1711 typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
1712 = current_file->next_type_number++;
1713 #endif
1716 if (flag_debug_only_used_symbols)
1718 if ((TREE_CODE (type) == RECORD_TYPE
1719 || TREE_CODE (type) == UNION_TYPE
1720 || TREE_CODE (type) == QUAL_UNION_TYPE
1721 || TREE_CODE (type) == ENUMERAL_TYPE)
1722 && TYPE_STUB_DECL (type)
1723 && DECL_P (TYPE_STUB_DECL (type))
1724 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
1725 debug_queue_symbol (TYPE_STUB_DECL (type));
1726 else if (TYPE_NAME (type)
1727 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1728 debug_queue_symbol (TYPE_NAME (type));
1731 /* Output the number of this type, to refer to it. */
1732 dbxout_type_index (type);
1734 #ifdef DBX_TYPE_DEFINED
1735 if (DBX_TYPE_DEFINED (type))
1736 return;
1737 #endif
1739 /* If this type's definition has been output or is now being output,
1740 that is all. */
1742 switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
1744 case TYPE_UNSEEN:
1745 break;
1746 case TYPE_XREF:
1747 /* If we have already had a cross reference,
1748 and either that's all we want or that's the best we could do,
1749 don't repeat the cross reference.
1750 Sun dbx crashes if we do. */
1751 if (! full || !COMPLETE_TYPE_P (type)
1752 /* No way in DBX fmt to describe a variable size. */
1753 || ! host_integerp (TYPE_SIZE (type), 1))
1754 return;
1755 break;
1756 case TYPE_DEFINED:
1757 return;
1760 #ifdef DBX_NO_XREFS
1761 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1762 leave the type-number completely undefined rather than output
1763 a cross-reference. If we have already used GNU debug info extensions,
1764 then it is OK to output a cross reference. This is necessary to get
1765 proper C++ debug output. */
1766 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
1767 || TREE_CODE (type) == QUAL_UNION_TYPE
1768 || TREE_CODE (type) == ENUMERAL_TYPE)
1769 && ! use_gnu_debug_info_extensions)
1770 /* We must use the same test here as we use twice below when deciding
1771 whether to emit a cross-reference. */
1772 if ((TYPE_NAME (type) != 0
1773 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1774 && DECL_IGNORED_P (TYPE_NAME (type)))
1775 && !full)
1776 || !COMPLETE_TYPE_P (type)
1777 /* No way in DBX fmt to describe a variable size. */
1778 || ! host_integerp (TYPE_SIZE (type), 1))
1780 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1781 return;
1783 #endif
1785 /* Output a definition now. */
1786 stabstr_C ('=');
1788 /* Mark it as defined, so that if it is self-referent
1789 we will not get into an infinite recursion of definitions. */
1791 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
1793 /* If this type is a variant of some other, hand off. Types with
1794 different names are usefully distinguished. We only distinguish
1795 cv-qualified types if we're using extensions. */
1796 if (TYPE_READONLY (type) > TYPE_READONLY (main_variant))
1798 stabstr_C ('k');
1799 dbxout_type (build_type_variant (type, 0, TYPE_VOLATILE (type)), 0);
1800 return;
1802 else if (TYPE_VOLATILE (type) > TYPE_VOLATILE (main_variant))
1804 stabstr_C ('B');
1805 dbxout_type (build_type_variant (type, TYPE_READONLY (type), 0), 0);
1806 return;
1808 else if (main_variant != TYPE_MAIN_VARIANT (type))
1810 if (flag_debug_only_used_symbols)
1812 tree orig_type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
1814 if ((TREE_CODE (orig_type) == RECORD_TYPE
1815 || TREE_CODE (orig_type) == UNION_TYPE
1816 || TREE_CODE (orig_type) == QUAL_UNION_TYPE
1817 || TREE_CODE (orig_type) == ENUMERAL_TYPE)
1818 && TYPE_STUB_DECL (orig_type)
1819 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type)))
1820 debug_queue_symbol (TYPE_STUB_DECL (orig_type));
1822 /* 'type' is a typedef; output the type it refers to. */
1823 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0);
1824 return;
1826 /* else continue. */
1828 switch (TREE_CODE (type))
1830 case VOID_TYPE:
1831 case LANG_TYPE:
1832 /* For a void type, just define it as itself; i.e., "5=5".
1833 This makes us consider it defined
1834 without saying what it is. The debugger will make it
1835 a void type when the reference is seen, and nothing will
1836 ever override that default. */
1837 dbxout_type_index (type);
1838 break;
1840 case INTEGER_TYPE:
1841 if (type == char_type_node && ! TYPE_UNSIGNED (type))
1843 /* Output the type `char' as a subrange of itself!
1844 I don't understand this definition, just copied it
1845 from the output of pcc.
1846 This used to use `r2' explicitly and we used to
1847 take care to make sure that `char' was type number 2. */
1848 stabstr_C ('r');
1849 dbxout_type_index (type);
1850 stabstr_S (";0;127;");
1853 /* If this is a subtype of another integer type, always prefer to
1854 write it as a subtype. */
1855 else if (TREE_TYPE (type) != 0
1856 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
1858 /* If the size is non-standard, say what it is if we can use
1859 GDB extensions. */
1861 if (use_gnu_debug_info_extensions
1862 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1864 stabstr_S ("@s");
1865 stabstr_D (TYPE_PRECISION (type));
1866 stabstr_C (';');
1869 dbxout_range_type (type);
1872 else
1874 /* If the size is non-standard, say what it is if we can use
1875 GDB extensions. */
1877 if (use_gnu_debug_info_extensions
1878 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1880 stabstr_S ("@s");
1881 stabstr_D (TYPE_PRECISION (type));
1882 stabstr_C (';');
1885 if (print_int_cst_bounds_in_octal_p (type))
1887 stabstr_C ('r');
1889 /* If this type derives from another type, output type index of
1890 parent type. This is particularly important when parent type
1891 is an enumerated type, because not generating the parent type
1892 index would transform the definition of this enumerated type
1893 into a plain unsigned type. */
1894 if (TREE_TYPE (type) != 0)
1895 dbxout_type_index (TREE_TYPE (type));
1896 else
1897 dbxout_type_index (type);
1899 stabstr_C (';');
1900 stabstr_O (TYPE_MIN_VALUE (type));
1901 stabstr_C (';');
1902 stabstr_O (TYPE_MAX_VALUE (type));
1903 stabstr_C (';');
1906 else
1907 /* Output other integer types as subranges of `int'. */
1908 dbxout_range_type (type);
1911 break;
1913 case REAL_TYPE:
1914 case FIXED_POINT_TYPE:
1915 /* This used to say `r1' and we used to take care
1916 to make sure that `int' was type number 1. */
1917 stabstr_C ('r');
1918 dbxout_type_index (integer_type_node);
1919 stabstr_C (';');
1920 stabstr_D (int_size_in_bytes (type));
1921 stabstr_S (";0;");
1922 break;
1924 case BOOLEAN_TYPE:
1925 if (use_gnu_debug_info_extensions)
1927 stabstr_S ("@s");
1928 stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
1929 stabstr_S (";-16;");
1931 else /* Define as enumeral type (False, True) */
1932 stabstr_S ("eFalse:0,True:1,;");
1933 break;
1935 case COMPLEX_TYPE:
1936 /* Differs from the REAL_TYPE by its new data type number.
1937 R3 is NF_COMPLEX. We don't try to use any of the other NF_*
1938 codes since gdb doesn't care anyway. */
1940 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1942 stabstr_S ("R3;");
1943 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type)));
1944 stabstr_S (";0;");
1946 else
1948 /* Output a complex integer type as a structure,
1949 pending some other way to do it. */
1950 stabstr_C ('s');
1951 stabstr_D (int_size_in_bytes (type));
1953 stabstr_S ("real:");
1954 dbxout_type (TREE_TYPE (type), 0);
1955 stabstr_S (",0,");
1956 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
1958 stabstr_S (";imag:");
1959 dbxout_type (TREE_TYPE (type), 0);
1960 stabstr_C (',');
1961 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
1962 stabstr_C (',');
1963 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
1964 stabstr_S (";;");
1966 break;
1968 case ARRAY_TYPE:
1969 /* Make arrays of packed bits look like bitstrings for chill. */
1970 if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
1972 stabstr_S ("@s");
1973 stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
1974 stabstr_S (";@S;S");
1975 dbxout_type (TYPE_DOMAIN (type), 0);
1976 break;
1979 if (use_gnu_debug_info_extensions && vector_type)
1980 stabstr_S ("@V;");
1982 /* Output "a" followed by a range type definition
1983 for the index type of the array
1984 followed by a reference to the target-type.
1985 ar1;0;N;M for a C array of type M and size N+1. */
1986 /* Check if a character string type, which in Chill is
1987 different from an array of characters. */
1988 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
1990 stabstr_S ("@S;");
1992 tem = TYPE_DOMAIN (type);
1993 if (tem == NULL)
1995 stabstr_S ("ar");
1996 dbxout_type_index (integer_type_node);
1997 stabstr_S (";0;-1;");
1999 else
2001 stabstr_C ('a');
2002 dbxout_range_type (tem);
2005 dbxout_type (TREE_TYPE (type), 0);
2006 break;
2008 case RECORD_TYPE:
2009 case UNION_TYPE:
2010 case QUAL_UNION_TYPE:
2012 tree binfo = TYPE_BINFO (type);
2014 /* Output a structure type. We must use the same test here as we
2015 use in the DBX_NO_XREFS case above. */
2016 if ((TYPE_NAME (type) != 0
2017 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
2018 && DECL_IGNORED_P (TYPE_NAME (type)))
2019 && !full)
2020 || !COMPLETE_TYPE_P (type)
2021 /* No way in DBX fmt to describe a variable size. */
2022 || ! host_integerp (TYPE_SIZE (type), 1))
2024 /* If the type is just a cross reference, output one
2025 and mark the type as partially described.
2026 If it later becomes defined, we will output
2027 its real definition.
2028 If the type has a name, don't nest its definition within
2029 another type's definition; instead, output an xref
2030 and let the definition come when the name is defined. */
2031 stabstr_S ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
2032 if (TYPE_NAME (type) != 0
2033 /* The C frontend creates for anonymous variable length
2034 records/unions TYPE_NAME with DECL_NAME NULL. */
2035 && (TREE_CODE (TYPE_NAME (type)) != TYPE_DECL
2036 || DECL_NAME (TYPE_NAME (type))))
2037 dbxout_type_name (type);
2038 else
2040 stabstr_S ("$$");
2041 stabstr_D (anonymous_type_number++);
2044 stabstr_C (':');
2045 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
2046 break;
2049 /* Identify record or union, and print its size. */
2050 stabstr_C ((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u');
2051 stabstr_D (int_size_in_bytes (type));
2053 if (binfo)
2055 int i;
2056 tree child;
2057 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
2059 if (use_gnu_debug_info_extensions)
2061 if (BINFO_N_BASE_BINFOS (binfo))
2063 stabstr_C ('!');
2064 stabstr_U (BINFO_N_BASE_BINFOS (binfo));
2065 stabstr_C (',');
2068 for (i = 0; BINFO_BASE_ITERATE (binfo, i, child); i++)
2070 tree access = (accesses ? VEC_index (tree, accesses, i)
2071 : access_public_node);
2073 if (use_gnu_debug_info_extensions)
2075 stabstr_C (BINFO_VIRTUAL_P (child) ? '1' : '0');
2076 stabstr_C (access == access_public_node ? '2' :
2077 access == access_protected_node
2078 ? '1' :'0');
2079 if (BINFO_VIRTUAL_P (child)
2080 && (strcmp (lang_hooks.name, "GNU C++") == 0
2081 || strcmp (lang_hooks.name, "GNU Objective-C++") == 0))
2082 /* For a virtual base, print the (negative)
2083 offset within the vtable where we must look
2084 to find the necessary adjustment. */
2085 stabstr_D
2086 (tree_low_cst (BINFO_VPTR_FIELD (child), 0)
2087 * BITS_PER_UNIT);
2088 else
2089 stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0)
2090 * BITS_PER_UNIT);
2091 stabstr_C (',');
2092 dbxout_type (BINFO_TYPE (child), 0);
2093 stabstr_C (';');
2095 else
2097 /* Print out the base class information with
2098 fields which have the same names at the types
2099 they hold. */
2100 dbxout_type_name (BINFO_TYPE (child));
2101 stabstr_C (':');
2102 dbxout_type (BINFO_TYPE (child), full);
2103 stabstr_C (',');
2104 stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0)
2105 * BITS_PER_UNIT);
2106 stabstr_C (',');
2107 stabstr_D
2108 (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child)), 0)
2109 * BITS_PER_UNIT);
2110 stabstr_C (';');
2116 /* Write out the field declarations. */
2117 dbxout_type_fields (type);
2118 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
2120 dbxout_type_methods (type);
2123 stabstr_C (';');
2125 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
2126 /* Avoid the ~ if we don't really need it--it confuses dbx. */
2127 && TYPE_VFIELD (type))
2130 /* We need to write out info about what field this class
2131 uses as its "main" vtable pointer field, because if this
2132 field is inherited from a base class, GDB cannot necessarily
2133 figure out which field it's using in time. */
2134 stabstr_S ("~%");
2135 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
2136 stabstr_C (';');
2138 break;
2140 case ENUMERAL_TYPE:
2141 /* We must use the same test here as we use in the DBX_NO_XREFS case
2142 above. We simplify it a bit since an enum will never have a variable
2143 size. */
2144 if ((TYPE_NAME (type) != 0
2145 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
2146 && DECL_IGNORED_P (TYPE_NAME (type)))
2147 && !full)
2148 || !COMPLETE_TYPE_P (type))
2150 stabstr_S ("xe");
2151 dbxout_type_name (type);
2152 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
2153 stabstr_C (':');
2154 return;
2156 if (use_gnu_debug_info_extensions
2157 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
2159 stabstr_S ("@s");
2160 stabstr_D (TYPE_PRECISION (type));
2161 stabstr_C (';');
2164 stabstr_C ('e');
2165 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
2167 stabstr_I (TREE_PURPOSE (tem));
2168 stabstr_C (':');
2170 if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
2171 stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem)));
2172 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
2173 && (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
2174 stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem)));
2175 else
2176 stabstr_O (TREE_VALUE (tem));
2178 stabstr_C (',');
2179 if (TREE_CHAIN (tem) != 0)
2180 CONTIN;
2183 stabstr_C (';');
2184 break;
2186 case POINTER_TYPE:
2187 stabstr_C ('*');
2188 dbxout_type (TREE_TYPE (type), 0);
2189 break;
2191 case METHOD_TYPE:
2192 if (use_gnu_debug_info_extensions)
2194 stabstr_C ('#');
2196 /* Write the argument types out longhand. */
2197 dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
2198 stabstr_C (',');
2199 dbxout_type (TREE_TYPE (type), 0);
2200 dbxout_args (TYPE_ARG_TYPES (type));
2201 stabstr_C (';');
2203 else
2204 /* Treat it as a function type. */
2205 dbxout_type (TREE_TYPE (type), 0);
2206 break;
2208 case OFFSET_TYPE:
2209 if (use_gnu_debug_info_extensions)
2211 stabstr_C ('@');
2212 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
2213 stabstr_C (',');
2214 dbxout_type (TREE_TYPE (type), 0);
2216 else
2217 /* Should print as an int, because it is really just an offset. */
2218 dbxout_type (integer_type_node, 0);
2219 break;
2221 case REFERENCE_TYPE:
2222 if (use_gnu_debug_info_extensions)
2224 stabstr_C ('&');
2226 else
2227 stabstr_C ('*');
2228 dbxout_type (TREE_TYPE (type), 0);
2229 break;
2231 case FUNCTION_TYPE:
2232 stabstr_C ('f');
2233 dbxout_type (TREE_TYPE (type), 0);
2234 break;
2236 default:
2237 gcc_unreachable ();
2241 /* Return nonzero if the given type represents an integer whose bounds
2242 should be printed in octal format. */
2244 static bool
2245 print_int_cst_bounds_in_octal_p (tree type)
2247 /* If we can use GDB extensions and the size is wider than a long
2248 (the size used by GDB to read them) or we may have trouble writing
2249 the bounds the usual way, write them in octal. Note the test is for
2250 the *target's* size of "long", not that of the host. The host test
2251 is just to make sure we can write it out in case the host wide int
2252 is narrower than the target "long".
2254 For unsigned types, we use octal if they are the same size or larger.
2255 This is because we print the bounds as signed decimal, and hence they
2256 can't span same size unsigned types. */
2258 if (use_gnu_debug_info_extensions
2259 && TYPE_MIN_VALUE (type) != 0
2260 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
2261 && TYPE_MAX_VALUE (type) != 0
2262 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
2263 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
2264 || ((TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2265 && TYPE_UNSIGNED (type))
2266 || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
2267 || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
2268 && TYPE_UNSIGNED (type))))
2269 return TRUE;
2270 else
2271 return FALSE;
2274 /* Output the name of type TYPE, with no punctuation.
2275 Such names can be set up either by typedef declarations
2276 or by struct, enum and union tags. */
2278 static void
2279 dbxout_type_name (tree type)
2281 tree t = TYPE_NAME (type);
2283 gcc_assert (t);
2284 switch (TREE_CODE (t))
2286 case IDENTIFIER_NODE:
2287 break;
2288 case TYPE_DECL:
2289 t = DECL_NAME (t);
2290 break;
2291 default:
2292 gcc_unreachable ();
2295 stabstr_I (t);
2298 /* Output leading leading struct or class names needed for qualifying
2299 type whose scope is limited to a struct or class. */
2301 static void
2302 dbxout_class_name_qualifiers (tree decl)
2304 tree context = decl_type_context (decl);
2306 if (context != NULL_TREE
2307 && TREE_CODE(context) == RECORD_TYPE
2308 && TYPE_NAME (context) != 0
2309 && (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE
2310 || (DECL_NAME (TYPE_NAME (context)) != 0)))
2312 tree name = TYPE_NAME (context);
2314 if (TREE_CODE (name) == TYPE_DECL)
2316 dbxout_class_name_qualifiers (name);
2317 name = DECL_NAME (name);
2319 stabstr_I (name);
2320 stabstr_S ("::");
2324 /* This is a specialized subset of expand_expr for use by dbxout_symbol in
2325 evaluating DECL_VALUE_EXPR. In particular, we stop if we find decls that
2326 havn't been expanded, or if the expression is getting so complex we won't
2327 be able to represent it in stabs anyway. Returns NULL on failure. */
2329 static rtx
2330 dbxout_expand_expr (tree expr)
2332 switch (TREE_CODE (expr))
2334 case VAR_DECL:
2335 case PARM_DECL:
2336 if (DECL_HAS_VALUE_EXPR_P (expr))
2337 return dbxout_expand_expr (DECL_VALUE_EXPR (expr));
2338 /* FALLTHRU */
2340 case CONST_DECL:
2341 case RESULT_DECL:
2342 return DECL_RTL_IF_SET (expr);
2344 case INTEGER_CST:
2345 return expand_expr (expr, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
2347 case COMPONENT_REF:
2348 case ARRAY_REF:
2349 case ARRAY_RANGE_REF:
2350 case BIT_FIELD_REF:
2352 enum machine_mode mode;
2353 HOST_WIDE_INT bitsize, bitpos;
2354 tree offset, tem;
2355 int volatilep = 0, unsignedp = 0;
2356 rtx x;
2358 tem = get_inner_reference (expr, &bitsize, &bitpos, &offset,
2359 &mode, &unsignedp, &volatilep, true);
2361 x = dbxout_expand_expr (tem);
2362 if (x == NULL || !MEM_P (x))
2363 return NULL;
2364 if (offset != NULL)
2366 if (!host_integerp (offset, 0))
2367 return NULL;
2368 x = adjust_address_nv (x, mode, tree_low_cst (offset, 0));
2370 if (bitpos != 0)
2371 x = adjust_address_nv (x, mode, bitpos / BITS_PER_UNIT);
2373 return x;
2376 default:
2377 return NULL;
2381 /* Helper function for output_used_types. Queue one entry from the
2382 used types hash to be output. */
2384 static int
2385 output_used_types_helper (void **slot, void *data)
2387 tree type = *slot;
2388 VEC(tree, heap) **types_p = data;
2390 if ((TREE_CODE (type) == RECORD_TYPE
2391 || TREE_CODE (type) == UNION_TYPE
2392 || TREE_CODE (type) == QUAL_UNION_TYPE
2393 || TREE_CODE (type) == ENUMERAL_TYPE)
2394 && TYPE_STUB_DECL (type)
2395 && DECL_P (TYPE_STUB_DECL (type))
2396 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
2397 VEC_quick_push (tree, *types_p, TYPE_STUB_DECL (type));
2398 else if (TYPE_NAME (type)
2399 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2400 VEC_quick_push (tree, *types_p, TYPE_NAME (type));
2402 return 1;
2405 /* This is a qsort callback which sorts types and declarations into a
2406 predictable order (types, then declarations, sorted by UID
2407 within). */
2409 static int
2410 output_types_sort (const void *pa, const void *pb)
2412 const tree lhs = *((const tree *)pa);
2413 const tree rhs = *((const tree *)pb);
2415 if (TYPE_P (lhs))
2417 if (TYPE_P (rhs))
2418 return TYPE_UID (lhs) - TYPE_UID (rhs);
2419 else
2420 return 1;
2422 else
2424 if (TYPE_P (rhs))
2425 return -1;
2426 else
2427 return DECL_UID (lhs) - DECL_UID (rhs);
2432 /* Force all types used by this function to be output in debug
2433 information. */
2435 static void
2436 output_used_types (void)
2438 if (cfun && cfun->used_types_hash)
2440 VEC(tree, heap) *types;
2441 int i;
2442 tree type;
2444 types = VEC_alloc (tree, heap, htab_elements (cfun->used_types_hash));
2445 htab_traverse (cfun->used_types_hash, output_used_types_helper, &types);
2447 /* Sort by UID to prevent dependence on hash table ordering. */
2448 qsort (VEC_address (tree, types), VEC_length (tree, types),
2449 sizeof (tree), output_types_sort);
2451 for (i = 0; VEC_iterate (tree, types, i, type); i++)
2452 debug_queue_symbol (type);
2454 VEC_free (tree, heap, types);
2458 /* Output a .stabs for the symbol defined by DECL,
2459 which must be a ..._DECL node in the normal namespace.
2460 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2461 LOCAL is nonzero if the scope is less than the entire file.
2462 Return 1 if a stabs might have been emitted. */
2465 dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
2467 tree type = TREE_TYPE (decl);
2468 tree context = NULL_TREE;
2469 int result = 0;
2470 rtx decl_rtl;
2472 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
2473 ++debug_nesting;
2475 /* Ignore nameless syms, but don't ignore type tags. */
2477 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
2478 || DECL_IGNORED_P (decl))
2479 DBXOUT_DECR_NESTING_AND_RETURN (0);
2481 /* If we are to generate only the symbols actually used then such
2482 symbol nodes are flagged with TREE_USED. Ignore any that
2483 aren't flaged as TREE_USED. */
2485 if (flag_debug_only_used_symbols
2486 && (!TREE_USED (decl)
2487 && (TREE_CODE (decl) != VAR_DECL || !DECL_INITIAL (decl))))
2488 DBXOUT_DECR_NESTING_AND_RETURN (0);
2490 /* If dbxout_init has not yet run, queue this symbol for later. */
2491 if (!typevec)
2493 preinit_symbols = tree_cons (0, decl, preinit_symbols);
2494 DBXOUT_DECR_NESTING_AND_RETURN (0);
2497 if (flag_debug_only_used_symbols)
2499 tree t;
2501 /* We now have a used symbol. We need to generate the info for
2502 the symbol's type in addition to the symbol itself. These
2503 type symbols are queued to be generated after were done with
2504 the symbol itself (otherwise they would fight over the
2505 stabstr obstack).
2507 Note, because the TREE_TYPE(type) might be something like a
2508 pointer to a named type we need to look for the first name
2509 we see following the TREE_TYPE chain. */
2511 t = type;
2512 while (POINTER_TYPE_P (t))
2513 t = TREE_TYPE (t);
2515 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2516 need special treatment. The TYPE_STUB_DECL field in these
2517 types generally represents the tag name type we want to
2518 output. In addition there could be a typedef type with
2519 a different name. In that case we also want to output
2520 that. */
2522 if (TREE_CODE (t) == RECORD_TYPE
2523 || TREE_CODE (t) == UNION_TYPE
2524 || TREE_CODE (t) == QUAL_UNION_TYPE
2525 || TREE_CODE (t) == ENUMERAL_TYPE)
2527 if (TYPE_STUB_DECL (t)
2528 && TYPE_STUB_DECL (t) != decl
2529 && DECL_P (TYPE_STUB_DECL (t))
2530 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t)))
2532 debug_queue_symbol (TYPE_STUB_DECL (t));
2533 if (TYPE_NAME (t)
2534 && TYPE_NAME (t) != TYPE_STUB_DECL (t)
2535 && TYPE_NAME (t) != decl
2536 && DECL_P (TYPE_NAME (t)))
2537 debug_queue_symbol (TYPE_NAME (t));
2540 else if (TYPE_NAME (t)
2541 && TYPE_NAME (t) != decl
2542 && DECL_P (TYPE_NAME (t)))
2543 debug_queue_symbol (TYPE_NAME (t));
2546 emit_pending_bincls_if_required ();
2548 switch (TREE_CODE (decl))
2550 case CONST_DECL:
2551 /* Enum values are defined by defining the enum type. */
2552 break;
2554 case FUNCTION_DECL:
2555 decl_rtl = DECL_RTL_IF_SET (decl);
2556 if (!decl_rtl)
2557 DBXOUT_DECR_NESTING_AND_RETURN (0);
2558 if (DECL_EXTERNAL (decl))
2559 break;
2560 /* Don't mention a nested function under its parent. */
2561 context = decl_function_context (decl);
2562 if (context == current_function_decl)
2563 break;
2564 /* Don't mention an inline instance of a nested function. */
2565 if (context && DECL_FROM_INLINE (decl))
2566 break;
2567 if (!MEM_P (decl_rtl)
2568 || GET_CODE (XEXP (decl_rtl, 0)) != SYMBOL_REF)
2569 break;
2571 if (flag_debug_only_used_symbols)
2572 output_used_types ();
2574 dbxout_begin_complex_stabs ();
2575 stabstr_I (DECL_ASSEMBLER_NAME (decl));
2576 stabstr_S (TREE_PUBLIC (decl) ? ":F" : ":f");
2577 result = 1;
2579 if (TREE_TYPE (type))
2580 dbxout_type (TREE_TYPE (type), 0);
2581 else
2582 dbxout_type (void_type_node, 0);
2584 /* For a nested function, when that function is compiled,
2585 mention the containing function name
2586 as well as (since dbx wants it) our own assembler-name. */
2587 if (context != 0)
2589 stabstr_C (',');
2590 stabstr_I (DECL_ASSEMBLER_NAME (decl));
2591 stabstr_C (',');
2592 stabstr_I (DECL_NAME (context));
2595 dbxout_finish_complex_stabs (decl, N_FUN, XEXP (decl_rtl, 0), 0, 0);
2596 break;
2598 case TYPE_DECL:
2599 /* Don't output the same typedef twice.
2600 And don't output what language-specific stuff doesn't want output. */
2601 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
2602 DBXOUT_DECR_NESTING_AND_RETURN (0);
2604 /* Don't output typedefs for types with magic type numbers (XCOFF). */
2605 #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2607 int fundamental_type_number =
2608 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl);
2610 if (fundamental_type_number != 0)
2612 TREE_ASM_WRITTEN (decl) = 1;
2613 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = fundamental_type_number;
2614 DBXOUT_DECR_NESTING_AND_RETURN (0);
2617 #endif
2618 FORCE_TEXT;
2619 result = 1;
2621 int tag_needed = 1;
2622 int did_output = 0;
2624 if (DECL_NAME (decl))
2626 /* Nonzero means we must output a tag as well as a typedef. */
2627 tag_needed = 0;
2629 /* Handle the case of a C++ structure or union
2630 where the TYPE_NAME is a TYPE_DECL
2631 which gives both a typedef name and a tag. */
2632 /* dbx requires the tag first and the typedef second. */
2633 if ((TREE_CODE (type) == RECORD_TYPE
2634 || TREE_CODE (type) == UNION_TYPE
2635 || TREE_CODE (type) == QUAL_UNION_TYPE)
2636 && TYPE_NAME (type) == decl
2637 && !use_gnu_debug_info_extensions
2638 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
2639 /* Distinguish the implicit typedefs of C++
2640 from explicit ones that might be found in C. */
2641 && DECL_ARTIFICIAL (decl)
2642 /* Do not generate a tag for incomplete records. */
2643 && COMPLETE_TYPE_P (type)
2644 /* Do not generate a tag for records of variable size,
2645 since this type can not be properly described in the
2646 DBX format, and it confuses some tools such as objdump. */
2647 && host_integerp (TYPE_SIZE (type), 1))
2649 tree name = TYPE_NAME (type);
2650 if (TREE_CODE (name) == TYPE_DECL)
2651 name = DECL_NAME (name);
2653 dbxout_begin_complex_stabs ();
2654 stabstr_I (name);
2655 stabstr_S (":T");
2656 dbxout_type (type, 1);
2657 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE,
2658 0, 0, 0);
2661 dbxout_begin_complex_stabs ();
2663 /* Output leading class/struct qualifiers. */
2664 if (use_gnu_debug_info_extensions)
2665 dbxout_class_name_qualifiers (decl);
2667 /* Output typedef name. */
2668 stabstr_I (DECL_NAME (decl));
2669 stabstr_C (':');
2671 /* Short cut way to output a tag also. */
2672 if ((TREE_CODE (type) == RECORD_TYPE
2673 || TREE_CODE (type) == UNION_TYPE
2674 || TREE_CODE (type) == QUAL_UNION_TYPE)
2675 && TYPE_NAME (type) == decl
2676 /* Distinguish the implicit typedefs of C++
2677 from explicit ones that might be found in C. */
2678 && DECL_ARTIFICIAL (decl))
2680 if (use_gnu_debug_info_extensions)
2682 stabstr_C ('T');
2683 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
2687 stabstr_C ('t');
2688 dbxout_type (type, 1);
2689 dbxout_finish_complex_stabs (decl, DBX_TYPE_DECL_STABS_CODE,
2690 0, 0, 0);
2691 did_output = 1;
2694 /* Don't output a tag if this is an incomplete type. This prevents
2695 the sun4 Sun OS 4.x dbx from crashing. */
2697 if (tag_needed && TYPE_NAME (type) != 0
2698 && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
2699 || (DECL_NAME (TYPE_NAME (type)) != 0))
2700 && COMPLETE_TYPE_P (type)
2701 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
2703 /* For a TYPE_DECL with no name, but the type has a name,
2704 output a tag.
2705 This is what represents `struct foo' with no typedef. */
2706 /* In C++, the name of a type is the corresponding typedef.
2707 In C, it is an IDENTIFIER_NODE. */
2708 tree name = TYPE_NAME (type);
2709 if (TREE_CODE (name) == TYPE_DECL)
2710 name = DECL_NAME (name);
2712 dbxout_begin_complex_stabs ();
2713 stabstr_I (name);
2714 stabstr_S (":T");
2715 dbxout_type (type, 1);
2716 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
2717 did_output = 1;
2720 /* If an enum type has no name, it cannot be referred to, but
2721 we must output it anyway, to record the enumeration
2722 constants. */
2724 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
2726 dbxout_begin_complex_stabs ();
2727 /* Some debuggers fail when given NULL names, so give this a
2728 harmless name of " " (Why not "(anon)"?). */
2729 stabstr_S (" :T");
2730 dbxout_type (type, 1);
2731 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
2734 /* Prevent duplicate output of a typedef. */
2735 TREE_ASM_WRITTEN (decl) = 1;
2736 break;
2739 case PARM_DECL:
2740 /* Parm decls go in their own separate chains
2741 and are output by dbxout_reg_parms and dbxout_parms. */
2742 gcc_unreachable ();
2744 case RESULT_DECL:
2745 case VAR_DECL:
2746 /* Don't mention a variable that is external.
2747 Let the file that defines it describe it. */
2748 if (DECL_EXTERNAL (decl))
2749 break;
2751 /* If the variable is really a constant
2752 and not written in memory, inform the debugger.
2754 ??? Why do we skip emitting the type and location in this case? */
2755 if (TREE_STATIC (decl) && TREE_READONLY (decl)
2756 && DECL_INITIAL (decl) != 0
2757 && host_integerp (DECL_INITIAL (decl), 0)
2758 && ! TREE_ASM_WRITTEN (decl)
2759 && (DECL_CONTEXT (decl) == NULL_TREE
2760 || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK
2761 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
2762 && TREE_PUBLIC (decl) == 0)
2764 /* The sun4 assembler does not grok this. */
2766 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
2767 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
2769 HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl));
2771 dbxout_begin_complex_stabs ();
2772 dbxout_symbol_name (decl, NULL, 'c');
2773 stabstr_S ("=i");
2774 stabstr_D (ival);
2775 dbxout_finish_complex_stabs (0, N_LSYM, 0, 0, 0);
2776 DBXOUT_DECR_NESTING;
2777 return 1;
2779 else
2780 break;
2782 /* else it is something we handle like a normal variable. */
2784 decl_rtl = dbxout_expand_expr (decl);
2785 if (!decl_rtl)
2786 DBXOUT_DECR_NESTING_AND_RETURN (0);
2788 decl_rtl = eliminate_regs (decl_rtl, 0, NULL_RTX);
2789 #ifdef LEAF_REG_REMAP
2790 if (current_function_uses_only_leaf_regs)
2791 leaf_renumber_regs_insn (decl_rtl);
2792 #endif
2794 result = dbxout_symbol_location (decl, type, 0, decl_rtl);
2795 break;
2797 default:
2798 break;
2800 DBXOUT_DECR_NESTING;
2801 return result;
2804 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2805 Add SUFFIX to its name, if SUFFIX is not 0.
2806 Describe the variable as residing in HOME
2807 (usually HOME is DECL_RTL (DECL), but not always).
2808 Returns 1 if the stab was really emitted. */
2810 static int
2811 dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
2813 int letter = 0;
2814 STAB_CODE_TYPE code;
2815 rtx addr = 0;
2816 int number = 0;
2817 int regno = -1;
2819 /* Don't mention a variable at all
2820 if it was completely optimized into nothingness.
2822 If the decl was from an inline function, then its rtl
2823 is not identically the rtl that was used in this
2824 particular compilation. */
2825 if (GET_CODE (home) == SUBREG)
2827 rtx value = home;
2829 while (GET_CODE (value) == SUBREG)
2830 value = SUBREG_REG (value);
2831 if (REG_P (value))
2833 if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
2834 return 0;
2836 home = alter_subreg (&home);
2838 if (REG_P (home))
2840 regno = REGNO (home);
2841 if (regno >= FIRST_PSEUDO_REGISTER)
2842 return 0;
2845 /* The kind-of-variable letter depends on where
2846 the variable is and on the scope of its name:
2847 G and N_GSYM for static storage and global scope,
2848 S for static storage and file scope,
2849 V for static storage and local scope,
2850 for those two, use N_LCSYM if data is in bss segment,
2851 N_STSYM if in data segment, N_FUN otherwise.
2852 (We used N_FUN originally, then changed to N_STSYM
2853 to please GDB. However, it seems that confused ld.
2854 Now GDB has been fixed to like N_FUN, says Kingdon.)
2855 no letter at all, and N_LSYM, for auto variable,
2856 r and N_RSYM for register variable. */
2858 if (MEM_P (home) && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
2860 if (TREE_PUBLIC (decl))
2862 letter = 'G';
2863 code = N_GSYM;
2865 else
2867 addr = XEXP (home, 0);
2869 letter = decl_function_context (decl) ? 'V' : 'S';
2871 /* Some ports can transform a symbol ref into a label ref,
2872 because the symbol ref is too far away and has to be
2873 dumped into a constant pool. Alternatively, the symbol
2874 in the constant pool might be referenced by a different
2875 symbol. */
2876 if (GET_CODE (addr) == SYMBOL_REF
2877 && CONSTANT_POOL_ADDRESS_P (addr))
2879 bool marked;
2880 rtx tmp = get_pool_constant_mark (addr, &marked);
2882 if (GET_CODE (tmp) == SYMBOL_REF)
2884 addr = tmp;
2885 if (CONSTANT_POOL_ADDRESS_P (addr))
2886 get_pool_constant_mark (addr, &marked);
2887 else
2888 marked = true;
2890 else if (GET_CODE (tmp) == LABEL_REF)
2892 addr = tmp;
2893 marked = true;
2896 /* If all references to the constant pool were optimized
2897 out, we just ignore the symbol. */
2898 if (!marked)
2899 return 0;
2902 /* This should be the same condition as in assemble_variable, but
2903 we don't have access to dont_output_data here. So, instead,
2904 we rely on the fact that error_mark_node initializers always
2905 end up in bss for C++ and never end up in bss for C. */
2906 if (DECL_INITIAL (decl) == 0
2907 || (!strcmp (lang_hooks.name, "GNU C++")
2908 && DECL_INITIAL (decl) == error_mark_node))
2909 code = N_LCSYM;
2910 else if (DECL_IN_TEXT_SECTION (decl))
2911 /* This is not quite right, but it's the closest
2912 of all the codes that Unix defines. */
2913 code = DBX_STATIC_CONST_VAR_CODE;
2914 else
2916 /* Ultrix `as' seems to need this. */
2917 #ifdef DBX_STATIC_STAB_DATA_SECTION
2918 switch_to_section (data_section);
2919 #endif
2920 code = N_STSYM;
2924 else if (regno >= 0)
2926 letter = 'r';
2927 code = N_RSYM;
2928 number = DBX_REGISTER_NUMBER (regno);
2930 else if (MEM_P (home)
2931 && (MEM_P (XEXP (home, 0))
2932 || (REG_P (XEXP (home, 0))
2933 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
2934 && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
2935 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2936 && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
2937 #endif
2939 /* If the value is indirect by memory or by a register
2940 that isn't the frame pointer
2941 then it means the object is variable-sized and address through
2942 that register or stack slot. DBX has no way to represent this
2943 so all we can do is output the variable as a pointer.
2944 If it's not a parameter, ignore it. */
2946 if (REG_P (XEXP (home, 0)))
2948 letter = 'r';
2949 code = N_RSYM;
2950 if (REGNO (XEXP (home, 0)) >= FIRST_PSEUDO_REGISTER)
2951 return 0;
2952 number = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
2954 else
2956 code = N_LSYM;
2957 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2958 We want the value of that CONST_INT. */
2959 number = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
2962 /* Effectively do build_pointer_type, but don't cache this type,
2963 since it might be temporary whereas the type it points to
2964 might have been saved for inlining. */
2965 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2966 type = make_node (POINTER_TYPE);
2967 TREE_TYPE (type) = TREE_TYPE (decl);
2969 else if (MEM_P (home)
2970 && REG_P (XEXP (home, 0)))
2972 code = N_LSYM;
2973 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2975 else if (MEM_P (home)
2976 && GET_CODE (XEXP (home, 0)) == PLUS
2977 && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
2979 code = N_LSYM;
2980 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2981 We want the value of that CONST_INT. */
2982 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2984 else if (MEM_P (home)
2985 && GET_CODE (XEXP (home, 0)) == CONST)
2987 /* Handle an obscure case which can arise when optimizing and
2988 when there are few available registers. (This is *always*
2989 the case for i386/i486 targets). The RTL looks like
2990 (MEM (CONST ...)) even though this variable is a local `auto'
2991 or a local `register' variable. In effect, what has happened
2992 is that the reload pass has seen that all assignments and
2993 references for one such a local variable can be replaced by
2994 equivalent assignments and references to some static storage
2995 variable, thereby avoiding the need for a register. In such
2996 cases we're forced to lie to debuggers and tell them that
2997 this variable was itself `static'. */
2998 code = N_LCSYM;
2999 letter = 'V';
3000 addr = XEXP (XEXP (home, 0), 0);
3002 else if (GET_CODE (home) == CONCAT)
3004 tree subtype;
3006 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
3007 for example), then there is no easy way to figure out
3008 what SUBTYPE should be. So, we give up. */
3009 if (TREE_CODE (type) != COMPLEX_TYPE)
3010 return 0;
3012 subtype = TREE_TYPE (type);
3014 /* If the variable's storage is in two parts,
3015 output each as a separate stab with a modified name. */
3016 if (WORDS_BIG_ENDIAN)
3017 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
3018 else
3019 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
3021 if (WORDS_BIG_ENDIAN)
3022 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
3023 else
3024 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
3025 return 1;
3027 else
3028 /* Address might be a MEM, when DECL is a variable-sized object.
3029 Or it might be const0_rtx, meaning previous passes
3030 want us to ignore this variable. */
3031 return 0;
3033 /* Ok, start a symtab entry and output the variable name. */
3034 emit_pending_bincls_if_required ();
3035 FORCE_TEXT;
3037 #ifdef DBX_STATIC_BLOCK_START
3038 DBX_STATIC_BLOCK_START (asm_out_file, code);
3039 #endif
3041 dbxout_begin_complex_stabs_noforcetext ();
3042 dbxout_symbol_name (decl, suffix, letter);
3043 dbxout_type (type, 0);
3044 dbxout_finish_complex_stabs (decl, code, addr, 0, number);
3046 #ifdef DBX_STATIC_BLOCK_END
3047 DBX_STATIC_BLOCK_END (asm_out_file, code);
3048 #endif
3049 return 1;
3052 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
3053 Then output LETTER to indicate the kind of location the symbol has. */
3055 static void
3056 dbxout_symbol_name (tree decl, const char *suffix, int letter)
3058 tree name;
3060 if (DECL_CONTEXT (decl)
3061 && (TYPE_P (DECL_CONTEXT (decl))
3062 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL))
3063 /* One slight hitch: if this is a VAR_DECL which is a class member
3064 or a namespace member, we must put out the mangled name instead of the
3065 DECL_NAME. Note also that static member (variable) names DO NOT begin
3066 with underscores in .stabs directives. */
3067 name = DECL_ASSEMBLER_NAME (decl);
3068 else
3069 /* ...but if we're function-local, we don't want to include the junk
3070 added by ASM_FORMAT_PRIVATE_NAME. */
3071 name = DECL_NAME (decl);
3073 if (name)
3074 stabstr_I (name);
3075 else
3076 stabstr_S ("(anon)");
3078 if (suffix)
3079 stabstr_S (suffix);
3080 stabstr_C (':');
3081 if (letter)
3082 stabstr_C (letter);
3085 /* Output definitions of all the decls in a chain. Return nonzero if
3086 anything was output */
3089 dbxout_syms (tree syms)
3091 int result = 0;
3092 while (syms)
3094 result += dbxout_symbol (syms, 1);
3095 syms = TREE_CHAIN (syms);
3097 return result;
3100 /* The following two functions output definitions of function parameters.
3101 Each parameter gets a definition locating it in the parameter list.
3102 Each parameter that is a register variable gets a second definition
3103 locating it in the register.
3105 Printing or argument lists in gdb uses the definitions that
3106 locate in the parameter list. But reference to the variable in
3107 expressions uses preferentially the definition as a register. */
3109 /* Output definitions, referring to storage in the parmlist,
3110 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
3112 void
3113 dbxout_parms (tree parms)
3115 ++debug_nesting;
3116 emit_pending_bincls_if_required ();
3118 for (; parms; parms = TREE_CHAIN (parms))
3119 if (DECL_NAME (parms)
3120 && TREE_TYPE (parms) != error_mark_node
3121 && DECL_RTL_SET_P (parms)
3122 && DECL_INCOMING_RTL (parms))
3124 tree eff_type;
3125 char letter;
3126 STAB_CODE_TYPE code;
3127 int number;
3129 /* Perform any necessary register eliminations on the parameter's rtl,
3130 so that the debugging output will be accurate. */
3131 DECL_INCOMING_RTL (parms)
3132 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
3133 SET_DECL_RTL (parms, eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
3134 #ifdef LEAF_REG_REMAP
3135 if (current_function_uses_only_leaf_regs)
3137 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
3138 leaf_renumber_regs_insn (DECL_RTL (parms));
3140 #endif
3142 if (PARM_PASSED_IN_MEMORY (parms))
3144 rtx inrtl = XEXP (DECL_INCOMING_RTL (parms), 0);
3146 /* ??? Here we assume that the parm address is indexed
3147 off the frame pointer or arg pointer.
3148 If that is not true, we produce meaningless results,
3149 but do not crash. */
3150 if (GET_CODE (inrtl) == PLUS
3151 && GET_CODE (XEXP (inrtl, 1)) == CONST_INT)
3152 number = INTVAL (XEXP (inrtl, 1));
3153 else
3154 number = 0;
3156 code = N_PSYM;
3157 number = DEBUGGER_ARG_OFFSET (number, inrtl);
3158 letter = 'p';
3160 /* It is quite tempting to use TREE_TYPE (parms) instead
3161 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
3162 reports the actual type of the parameter, rather than
3163 the promoted type. This certainly makes GDB's life
3164 easier, at least for some ports. The change is a bad
3165 idea however, since GDB expects to be able access the
3166 type without performing any conversions. So for
3167 example, if we were passing a float to an unprototyped
3168 function, gcc will store a double on the stack, but if
3169 we emit a stab saying the type is a float, then gdb
3170 will only read in a single value, and this will produce
3171 an erroneous value. */
3172 eff_type = DECL_ARG_TYPE (parms);
3174 else if (REG_P (DECL_RTL (parms)))
3176 rtx best_rtl;
3178 /* Parm passed in registers and lives in registers or nowhere. */
3179 code = DBX_REGPARM_STABS_CODE;
3180 letter = DBX_REGPARM_STABS_LETTER;
3182 /* For parms passed in registers, it is better to use the
3183 declared type of the variable, not the type it arrived in. */
3184 eff_type = TREE_TYPE (parms);
3186 /* If parm lives in a register, use that register; pretend
3187 the parm was passed there. It would be more consistent
3188 to describe the register where the parm was passed, but
3189 in practice that register usually holds something else.
3190 If the parm lives nowhere, use the register where it
3191 was passed. */
3192 if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
3193 best_rtl = DECL_RTL (parms);
3194 else
3195 best_rtl = DECL_INCOMING_RTL (parms);
3197 number = DBX_REGISTER_NUMBER (REGNO (best_rtl));
3199 else if (MEM_P (DECL_RTL (parms))
3200 && REG_P (XEXP (DECL_RTL (parms), 0))
3201 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
3202 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
3203 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
3204 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
3205 #endif
3208 /* Parm was passed via invisible reference.
3209 That is, its address was passed in a register.
3210 Output it as if it lived in that register.
3211 The debugger will know from the type
3212 that it was actually passed by invisible reference. */
3214 code = DBX_REGPARM_STABS_CODE;
3216 /* GDB likes this marked with a special letter. */
3217 letter = (use_gnu_debug_info_extensions
3218 ? 'a' : DBX_REGPARM_STABS_LETTER);
3219 eff_type = TREE_TYPE (parms);
3221 /* DECL_RTL looks like (MEM (REG...). Get the register number.
3222 If it is an unallocated pseudo-reg, then use the register where
3223 it was passed instead.
3224 ??? Why is DBX_REGISTER_NUMBER not used here? */
3226 if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
3227 number = REGNO (XEXP (DECL_RTL (parms), 0));
3228 else
3229 number = REGNO (DECL_INCOMING_RTL (parms));
3231 else if (MEM_P (DECL_RTL (parms))
3232 && MEM_P (XEXP (DECL_RTL (parms), 0)))
3234 /* Parm was passed via invisible reference, with the reference
3235 living on the stack. DECL_RTL looks like
3236 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3237 could look like (MEM (MEM (REG))). */
3239 code = N_PSYM;
3240 letter = 'v';
3241 eff_type = TREE_TYPE (parms);
3243 if (!REG_P (XEXP (XEXP (DECL_RTL (parms), 0), 0)))
3244 number = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
3245 else
3246 number = 0;
3248 number = DEBUGGER_ARG_OFFSET (number,
3249 XEXP (XEXP (DECL_RTL (parms), 0), 0));
3251 else if (MEM_P (DECL_RTL (parms))
3252 && XEXP (DECL_RTL (parms), 0) != const0_rtx
3253 /* ??? A constant address for a parm can happen
3254 when the reg it lives in is equiv to a constant in memory.
3255 Should make this not happen, after 2.4. */
3256 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
3258 /* Parm was passed in registers but lives on the stack. */
3260 code = N_PSYM;
3261 letter = 'p';
3262 eff_type = TREE_TYPE (parms);
3264 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3265 in which case we want the value of that CONST_INT,
3266 or (MEM (REG ...)),
3267 in which case we use a value of zero. */
3268 if (!REG_P (XEXP (DECL_RTL (parms), 0)))
3269 number = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
3270 else
3271 number = 0;
3273 /* Make a big endian correction if the mode of the type of the
3274 parameter is not the same as the mode of the rtl. */
3275 if (BYTES_BIG_ENDIAN
3276 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
3277 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
3278 number += (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
3279 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))));
3281 else
3282 /* ??? We don't know how to represent this argument. */
3283 continue;
3285 dbxout_begin_complex_stabs ();
3287 if (DECL_NAME (parms))
3289 stabstr_I (DECL_NAME (parms));
3290 stabstr_C (':');
3292 else
3293 stabstr_S ("(anon):");
3294 stabstr_C (letter);
3295 dbxout_type (eff_type, 0);
3296 dbxout_finish_complex_stabs (parms, code, 0, 0, number);
3298 DBXOUT_DECR_NESTING;
3301 /* Output definitions for the places where parms live during the function,
3302 when different from where they were passed, when the parms were passed
3303 in memory.
3305 It is not useful to do this for parms passed in registers
3306 that live during the function in different registers, because it is
3307 impossible to look in the passed register for the passed value,
3308 so we use the within-the-function register to begin with.
3310 PARMS is a chain of PARM_DECL nodes. */
3312 void
3313 dbxout_reg_parms (tree parms)
3315 ++debug_nesting;
3317 for (; parms; parms = TREE_CHAIN (parms))
3318 if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
3320 /* Report parms that live in registers during the function
3321 but were passed in memory. */
3322 if (REG_P (DECL_RTL (parms))
3323 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
3324 dbxout_symbol_location (parms, TREE_TYPE (parms),
3325 0, DECL_RTL (parms));
3326 else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
3327 dbxout_symbol_location (parms, TREE_TYPE (parms),
3328 0, DECL_RTL (parms));
3329 /* Report parms that live in memory but not where they were passed. */
3330 else if (MEM_P (DECL_RTL (parms))
3331 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
3332 dbxout_symbol_location (parms, TREE_TYPE (parms),
3333 0, DECL_RTL (parms));
3335 DBXOUT_DECR_NESTING;
3338 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
3339 output definitions of those names, in raw form */
3341 static void
3342 dbxout_args (tree args)
3344 while (args)
3346 stabstr_C (',');
3347 dbxout_type (TREE_VALUE (args), 0);
3348 args = TREE_CHAIN (args);
3352 #if defined (DBX_DEBUGGING_INFO)
3354 /* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
3355 BEGIN_LABEL is the name of the beginning of the function, which may
3356 be required. */
3357 static void
3358 dbx_output_lbrac (const char *label,
3359 const char *begin_label ATTRIBUTE_UNUSED)
3361 dbxout_begin_stabn (N_LBRAC);
3362 if (DBX_BLOCKS_FUNCTION_RELATIVE)
3363 dbxout_stab_value_label_diff (label, begin_label);
3364 else
3365 dbxout_stab_value_label (label);
3368 /* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
3369 BEGIN_LABEL is the name of the beginning of the function, which may
3370 be required. */
3371 static void
3372 dbx_output_rbrac (const char *label,
3373 const char *begin_label ATTRIBUTE_UNUSED)
3375 dbxout_begin_stabn (N_RBRAC);
3376 if (DBX_BLOCKS_FUNCTION_RELATIVE)
3377 dbxout_stab_value_label_diff (label, begin_label);
3378 else
3379 dbxout_stab_value_label (label);
3382 /* Output everything about a symbol block (a BLOCK node
3383 that represents a scope level),
3384 including recursive output of contained blocks.
3386 BLOCK is the BLOCK node.
3387 DEPTH is its depth within containing symbol blocks.
3388 ARGS is usually zero; but for the outermost block of the
3389 body of a function, it is a chain of PARM_DECLs for the function parameters.
3390 We output definitions of all the register parms
3391 as if they were local variables of that block.
3393 If -g1 was used, we count blocks just the same, but output nothing
3394 except for the outermost block.
3396 Actually, BLOCK may be several blocks chained together.
3397 We handle them all in sequence. */
3399 static void
3400 dbxout_block (tree block, int depth, tree args)
3402 char begin_label[20];
3403 /* Reference current function start using LFBB. */
3404 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
3406 while (block)
3408 /* Ignore blocks never expanded or otherwise marked as real. */
3409 if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
3411 int did_output;
3412 int blocknum = BLOCK_NUMBER (block);
3414 /* In dbx format, the syms of a block come before the N_LBRAC.
3415 If nothing is output, we don't need the N_LBRAC, either. */
3416 did_output = 0;
3417 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
3418 did_output = dbxout_syms (BLOCK_VARS (block));
3419 if (args)
3420 dbxout_reg_parms (args);
3422 /* Now output an N_LBRAC symbol to represent the beginning of
3423 the block. Use the block's tree-walk order to generate
3424 the assembler symbols LBBn and LBEn
3425 that final will define around the code in this block. */
3426 if (did_output)
3428 char buf[20];
3429 const char *scope_start;
3431 if (depth == 0)
3432 /* The outermost block doesn't get LBB labels; use
3433 the LFBB local symbol emitted by dbxout_begin_prologue. */
3434 scope_start = begin_label;
3435 else
3437 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
3438 scope_start = buf;
3441 if (BLOCK_HANDLER_BLOCK (block))
3443 /* A catch block. Must precede N_LBRAC. */
3444 tree decl = BLOCK_VARS (block);
3445 while (decl)
3447 dbxout_begin_complex_stabs ();
3448 stabstr_I (DECL_NAME (decl));
3449 stabstr_S (":C1");
3450 dbxout_finish_complex_stabs (0, N_CATCH, 0,
3451 scope_start, 0);
3452 decl = TREE_CHAIN (decl);
3455 dbx_output_lbrac (scope_start, begin_label);
3458 /* Output the subblocks. */
3459 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
3461 /* Refer to the marker for the end of the block. */
3462 if (did_output)
3464 char buf[100];
3465 if (depth == 0)
3466 /* The outermost block doesn't get LBE labels;
3467 use the "scope" label which will be emitted
3468 by dbxout_function_end. */
3469 ASM_GENERATE_INTERNAL_LABEL (buf, "Lscope", scope_labelno);
3470 else
3471 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
3473 dbx_output_rbrac (buf, begin_label);
3476 block = BLOCK_CHAIN (block);
3480 /* Output the information about a function and its arguments and result.
3481 Usually this follows the function's code,
3482 but on some systems, it comes before. */
3484 static void
3485 dbxout_begin_function (tree decl)
3487 int saved_tree_used1;
3489 if (DECL_IGNORED_P (decl))
3490 return;
3492 saved_tree_used1 = TREE_USED (decl);
3493 TREE_USED (decl) = 1;
3494 if (DECL_NAME (DECL_RESULT (decl)) != 0)
3496 int saved_tree_used2 = TREE_USED (DECL_RESULT (decl));
3497 TREE_USED (DECL_RESULT (decl)) = 1;
3498 dbxout_symbol (decl, 0);
3499 TREE_USED (DECL_RESULT (decl)) = saved_tree_used2;
3501 else
3502 dbxout_symbol (decl, 0);
3503 TREE_USED (decl) = saved_tree_used1;
3505 dbxout_parms (DECL_ARGUMENTS (decl));
3506 if (DECL_NAME (DECL_RESULT (decl)) != 0)
3507 dbxout_symbol (DECL_RESULT (decl), 1);
3509 #endif /* DBX_DEBUGGING_INFO */
3511 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3513 #include "gt-dbxout.h"