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 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
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
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.
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'. */
78 #include "insn-config.h"
80 #include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions. */
88 #include "langhooks.h"
90 #ifdef XCOFF_DEBUGGING_INFO
95 #define ASM_STABS_OP "\t.stabs\t"
99 #define ASM_STABN_OP "\t.stabn\t"
102 #ifndef DBX_TYPE_DECL_STABS_CODE
103 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
106 #ifndef DBX_STATIC_CONST_VAR_CODE
107 #define DBX_STATIC_CONST_VAR_CODE N_FUN
110 #ifndef DBX_REGPARM_STABS_CODE
111 #define DBX_REGPARM_STABS_CODE N_RSYM
114 #ifndef DBX_REGPARM_STABS_LETTER
115 #define DBX_REGPARM_STABS_LETTER 'P'
118 /* This is used for parameters passed by invisible reference in a register. */
119 #ifndef GDB_INV_REF_REGPARM_STABS_LETTER
120 #define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
123 #ifndef DBX_MEMPARM_STABS_LETTER
124 #define DBX_MEMPARM_STABS_LETTER 'p'
127 #ifndef FILE_NAME_JOINER
128 #define FILE_NAME_JOINER "/"
131 /* GDB needs to know that the stabs were generated by GCC. We emit an
132 N_OPT stab at the beginning of the source file to indicate this.
133 The string is historical, and different on a very few targets. */
134 #ifndef STABS_GCC_MARKER
135 #define STABS_GCC_MARKER "gcc2_compiled."
138 /* Typical USG systems don't have stab.h, and they also have
139 no use for DBX-format debugging info. */
141 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
143 /* Nonzero if we have actually used any of the GDB extensions
144 to the debugging format. The idea is that we use them for the
145 first time only if there's a strong reason, but once we have done that,
146 we use them whenever convenient. */
148 static int have_used_extensions
= 0;
150 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
151 for the N_SO filename stabs label. */
153 #if defined (DBX_DEBUGGING_INFO) && !defined (DBX_OUTPUT_SOURCE_FILENAME)
154 static int source_label_number
= 1;
157 #ifdef DEBUG_SYMS_TEXT
158 #define FORCE_TEXT function_section (current_function_decl);
165 #define STAB_CODE_TYPE enum __stab_debug_code
167 /* 1 if PARM is passed to this function in memory. */
169 #define PARM_PASSED_IN_MEMORY(PARM) \
170 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
172 /* A C expression for the integer offset value of an automatic variable
173 (N_LSYM) having address X (an RTX). */
174 #ifndef DEBUGGER_AUTO_OFFSET
175 #define DEBUGGER_AUTO_OFFSET(X) \
176 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
179 /* A C expression for the integer offset value of an argument (N_PSYM)
180 having address X (an RTX). The nominal offset is OFFSET. */
181 #ifndef DEBUGGER_ARG_OFFSET
182 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
185 /* Stream for writing to assembler file. */
187 static FILE *asmfile
;
189 /* Last source file name mentioned in a NOTE insn. */
191 static const char *lastfile
;
193 /* Current working directory. */
195 static const char *cwd
;
197 enum typestatus
{TYPE_UNSEEN
, TYPE_XREF
, TYPE_DEFINED
};
199 /* Structure recording information about a C data type.
200 The status element says whether we have yet output
201 the definition of the type. TYPE_XREF says we have
202 output it as a cross-reference only.
203 The file_number and type_number elements are used if DBX_USE_BINCL
208 enum typestatus status
;
215 /* Vector recording information about C data types.
216 When we first notice a data type (a tree node),
217 we assign it a number using next_type_number.
218 That is its index in this vector. */
220 struct typeinfo
*typevec
;
222 /* Number of elements of space allocated in `typevec'. */
224 static int typevec_len
;
226 /* In dbx output, each type gets a unique number.
227 This is the number for the next type output.
228 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
230 static int next_type_number
;
234 /* When using N_BINCL in dbx output, each type number is actually a
235 pair of the file number and the type number within the file.
236 This is a stack of input files. */
240 struct dbx_file
*next
;
242 int next_type_number
;
245 /* This is the top of the stack. */
247 static struct dbx_file
*current_file
;
249 /* This is the next file number to use. */
251 static int next_file_number
;
253 #endif /* DBX_USE_BINCL */
255 /* These variables are for dbxout_symbol to communicate to
256 dbxout_finish_symbol.
257 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
258 current_sym_value and current_sym_addr are two ways to address the
259 value to store in the symtab entry.
260 current_sym_addr if nonzero represents the value as an rtx.
261 If that is zero, current_sym_value is used. This is used
262 when the value is an offset (such as for auto variables,
263 register variables and parms). */
265 static STAB_CODE_TYPE current_sym_code
;
266 static int current_sym_value
;
267 static rtx current_sym_addr
;
269 /* Number of chars of symbol-description generated so far for the
270 current symbol. Used by CHARS and CONTIN. */
272 static int current_sym_nchars
;
274 /* Report having output N chars of the current symbol-description. */
276 #define CHARS(N) (current_sym_nchars += (N))
278 /* Break the current symbol-description, generating a continuation,
279 if it has become long. */
281 #ifndef DBX_CONTIN_LENGTH
282 #define DBX_CONTIN_LENGTH 80
285 #if DBX_CONTIN_LENGTH > 0
287 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
289 #define CONTIN do { } while (0)
292 static void dbxout_init
PARAMS ((const char *));
293 static void dbxout_finish
PARAMS ((const char *));
294 static void dbxout_start_source_file
PARAMS ((unsigned, const char *));
295 static void dbxout_end_source_file
PARAMS ((unsigned));
296 static void dbxout_typedefs
PARAMS ((tree
));
297 static void dbxout_fptype_value
PARAMS ((tree
));
298 static void dbxout_type_index
PARAMS ((tree
));
299 #if DBX_CONTIN_LENGTH > 0
300 static void dbxout_continue
PARAMS ((void));
302 static void dbxout_args
PARAMS ((tree
));
303 static void dbxout_type_fields
PARAMS ((tree
));
304 static void dbxout_type_method_1
PARAMS ((tree
, const char *));
305 static void dbxout_type_methods
PARAMS ((tree
));
306 static void dbxout_range_type
PARAMS ((tree
));
307 static void dbxout_type
PARAMS ((tree
, int));
308 static void print_int_cst_octal
PARAMS ((tree
));
309 static void print_octal
PARAMS ((unsigned HOST_WIDE_INT
, int));
310 static void print_wide_int
PARAMS ((HOST_WIDE_INT
));
311 static void dbxout_type_name
PARAMS ((tree
));
312 static void dbxout_class_name_qualifiers
PARAMS ((tree
));
313 static int dbxout_symbol_location
PARAMS ((tree
, tree
, const char *, rtx
));
314 static void dbxout_symbol_name
PARAMS ((tree
, const char *, int));
315 static void dbxout_prepare_symbol
PARAMS ((tree
));
316 static void dbxout_finish_symbol
PARAMS ((tree
));
317 static void dbxout_block
PARAMS ((tree
, int, tree
));
318 static void dbxout_global_decl
PARAMS ((tree
));
320 /* The debug hooks structure. */
321 #if defined (DBX_DEBUGGING_INFO)
323 static void dbxout_source_line
PARAMS ((unsigned int, const char *));
324 static void dbxout_source_file
PARAMS ((FILE *, const char *));
325 static void dbxout_function_end
PARAMS ((void));
326 static void dbxout_begin_function
PARAMS ((tree
));
327 static void dbxout_begin_block
PARAMS ((unsigned, unsigned));
328 static void dbxout_end_block
PARAMS ((unsigned, unsigned));
329 static void dbxout_function_decl
PARAMS ((tree
));
331 const struct gcc_debug_hooks dbx_debug_hooks
=
335 debug_nothing_int_charstar
,
336 debug_nothing_int_charstar
,
337 dbxout_start_source_file
,
338 dbxout_end_source_file
,
341 debug_true_tree
, /* ignore_block */
342 dbxout_source_line
, /* source_line */
343 dbxout_source_line
, /* begin_prologue: just output line info */
344 debug_nothing_int_charstar
, /* end_prologue */
345 debug_nothing_int_charstar
, /* end_epilogue */
346 #ifdef DBX_FUNCTION_FIRST
347 dbxout_begin_function
,
349 debug_nothing_tree
, /* begin_function */
351 debug_nothing_int
, /* end_function */
352 dbxout_function_decl
,
353 dbxout_global_decl
, /* global_decl */
354 debug_nothing_tree
, /* deferred_inline_function */
355 debug_nothing_tree
, /* outlining_inline_function */
356 debug_nothing_rtx
/* label */
358 #endif /* DBX_DEBUGGING_INFO */
360 #if defined (XCOFF_DEBUGGING_INFO)
361 const struct gcc_debug_hooks xcoff_debug_hooks
=
365 debug_nothing_int_charstar
,
366 debug_nothing_int_charstar
,
367 dbxout_start_source_file
,
368 dbxout_end_source_file
,
369 xcoffout_begin_block
,
371 debug_true_tree
, /* ignore_block */
372 xcoffout_source_line
,
373 xcoffout_begin_prologue
, /* begin_prologue */
374 debug_nothing_int_charstar
, /* end_prologue */
375 xcoffout_end_epilogue
,
376 debug_nothing_tree
, /* begin_function */
377 xcoffout_end_function
,
378 debug_nothing_tree
, /* function_decl */
379 dbxout_global_decl
, /* global_decl */
380 debug_nothing_tree
, /* deferred_inline_function */
381 debug_nothing_tree
, /* outlining_inline_function */
382 debug_nothing_rtx
/* label */
384 #endif /* XCOFF_DEBUGGING_INFO */
386 #if defined (DBX_DEBUGGING_INFO)
388 dbxout_function_end ()
390 static int scope_labelno
= 0;
391 char lscope_label_name
[100];
392 /* Convert Ltext into the appropriate format for local labels in case
393 the system doesn't insert underscores in front of user generated
395 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
396 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Lscope", scope_labelno
);
399 /* By convention, GCC will mark the end of a function with an N_FUN
400 symbol and an empty string. */
401 #ifdef DBX_OUTPUT_NFUN
402 DBX_OUTPUT_NFUN (asmfile
, lscope_label_name
, current_function_decl
);
404 fprintf (asmfile
, "%s\"\",%d,0,0,", ASM_STABS_OP
, N_FUN
);
405 assemble_name (asmfile
, lscope_label_name
);
407 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
408 fprintf (asmfile
, "\n");
411 #endif /* DBX_DEBUGGING_INFO */
413 /* At the beginning of compilation, start writing the symbol table.
414 Initialize `typevec' and output the standard data types of C. */
417 dbxout_init (input_file_name
)
418 const char *input_file_name
;
420 char ltext_label_name
[100];
421 tree syms
= (*lang_hooks
.decls
.getdecls
) ();
423 asmfile
= asm_out_file
;
426 typevec
= (struct typeinfo
*) xcalloc (typevec_len
, sizeof typevec
[0]);
428 /* Convert Ltext into the appropriate format for local labels in case
429 the system doesn't insert underscores in front of user generated
431 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
433 /* Put the current working directory in an N_SO symbol. */
434 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
435 but GDB always does. */
436 if (use_gnu_debug_info_extensions
)
439 if (!cwd
&& (cwd
= getpwd ()) && (!*cwd
|| cwd
[strlen (cwd
) - 1] != '/'))
440 cwd
= concat (cwd
, FILE_NAME_JOINER
, NULL
);
443 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
444 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile
, cwd
);
445 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
446 fprintf (asmfile
, "%s", ASM_STABS_OP
);
447 output_quoted_string (asmfile
, cwd
);
448 fprintf (asmfile
, ",%d,0,0,", N_SO
);
449 assemble_name (asmfile
, ltext_label_name
);
450 fputc ('\n', asmfile
);
451 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
455 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
456 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
457 would give us an N_SOL, and we want an N_SO. */
458 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile
, input_file_name
);
459 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
460 /* We include outputting `Ltext:' here,
461 because that gives you a way to override it. */
462 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
463 fprintf (asmfile
, "%s", ASM_STABS_OP
);
464 output_quoted_string (asmfile
, input_file_name
);
465 fprintf (asmfile
, ",%d,0,0,", N_SO
);
466 assemble_name (asmfile
, ltext_label_name
);
467 fputc ('\n', asmfile
);
469 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Ltext", 0);
470 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
472 #ifdef DBX_OUTPUT_GCC_MARKER
473 DBX_OUTPUT_GCC_MARKER (asmfile
);
475 /* Emit an N_OPT stab to indicate that this file was compiled by GCC. */
476 fprintf (asmfile
, "%s\"%s\",%d,0,0,0\n",
477 ASM_STABS_OP
, STABS_GCC_MARKER
, N_OPT
);
480 lastfile
= input_file_name
;
482 next_type_number
= 1;
485 current_file
= (struct dbx_file
*) xmalloc (sizeof *current_file
);
486 current_file
->next
= NULL
;
487 current_file
->file_number
= 0;
488 current_file
->next_type_number
= 1;
489 next_file_number
= 1;
492 /* Make sure that types `int' and `char' have numbers 1 and 2.
493 Definitions of other integer types will refer to those numbers.
494 (Actually it should no longer matter what their numbers are.
495 Also, if any types with tags have been defined, dbxout_symbol
496 will output them first, so the numbers won't be 1 and 2. That
497 happens in C++. So it's a good thing it should no longer matter). */
499 #ifdef DBX_OUTPUT_STANDARD_TYPES
500 DBX_OUTPUT_STANDARD_TYPES (syms
);
502 dbxout_symbol (TYPE_NAME (integer_type_node
), 0);
503 dbxout_symbol (TYPE_NAME (char_type_node
), 0);
506 /* Get all permanent types that have typedef names,
507 and output them all, except for those already output. */
509 dbxout_typedefs (syms
);
512 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
513 in the reverse order from that which is found in SYMS. */
516 dbxout_typedefs (syms
)
521 dbxout_typedefs (TREE_CHAIN (syms
));
522 if (TREE_CODE (syms
) == TYPE_DECL
)
524 tree type
= TREE_TYPE (syms
);
526 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
527 && COMPLETE_OR_VOID_TYPE_P (type
)
528 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
529 dbxout_symbol (TYPE_NAME (type
), 0);
534 /* Change to reading from a new source file. Generate a N_BINCL stab. */
537 dbxout_start_source_file (line
, filename
)
538 unsigned int line ATTRIBUTE_UNUSED
;
539 const char *filename ATTRIBUTE_UNUSED
;
542 struct dbx_file
*n
= (struct dbx_file
*) xmalloc (sizeof *n
);
544 n
->next
= current_file
;
545 n
->file_number
= next_file_number
++;
546 n
->next_type_number
= 1;
548 fprintf (asmfile
, "%s", ASM_STABS_OP
);
549 output_quoted_string (asmfile
, filename
);
550 fprintf (asmfile
, ",%d,0,0,0\n", N_BINCL
);
554 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
557 dbxout_end_source_file (line
)
558 unsigned int line ATTRIBUTE_UNUSED
;
561 struct dbx_file
*next
;
563 fprintf (asmfile
, "%s%d,0,0,0\n", ASM_STABN_OP
, N_EINCL
);
564 next
= current_file
->next
;
570 #if defined (DBX_DEBUGGING_INFO)
571 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
574 dbxout_source_file (file
, filename
)
576 const char *filename
;
578 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
580 #ifdef DBX_OUTPUT_SOURCE_FILENAME
581 DBX_OUTPUT_SOURCE_FILENAME (file
, filename
);
583 char ltext_label_name
[100];
585 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext",
586 source_label_number
);
587 fprintf (file
, "%s", ASM_STABS_OP
);
588 output_quoted_string (file
, filename
);
589 fprintf (asmfile
, ",%d,0,0,", N_SOL
);
590 assemble_name (asmfile
, ltext_label_name
);
591 fputc ('\n', asmfile
);
592 if (current_function_decl
!= NULL_TREE
593 && DECL_SECTION_NAME (current_function_decl
) != NULL_TREE
)
594 ; /* Don't change section amid function. */
597 ASM_OUTPUT_INTERNAL_LABEL (file
, "Ltext", source_label_number
);
598 source_label_number
++;
604 /* Output a line number symbol entry for source file FILENAME and line
608 dbxout_source_line (lineno
, filename
)
610 const char *filename
;
612 dbxout_source_file (asmfile
, filename
);
614 #ifdef ASM_OUTPUT_SOURCE_LINE
615 ASM_OUTPUT_SOURCE_LINE (asmfile
, lineno
);
617 fprintf (asmfile
, "%s%d,0,%d\n", ASM_STABD_OP
, N_SLINE
, lineno
);
621 /* Describe the beginning of an internal block within a function. */
624 dbxout_begin_block (line
, n
)
625 unsigned int line ATTRIBUTE_UNUSED
;
628 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "LBB", n
);
631 /* Describe the end line-number of an internal block within a function. */
634 dbxout_end_block (line
, n
)
635 unsigned int line ATTRIBUTE_UNUSED
;
638 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "LBE", n
);
641 /* Output dbx data for a function definition.
642 This includes a definition of the function name itself (a symbol),
643 definitions of the parameters (locating them in the parameter list)
644 and then output the block that makes up the function's body
645 (including all the auto variables of the function). */
648 dbxout_function_decl (decl
)
651 #ifndef DBX_FUNCTION_FIRST
652 dbxout_begin_function (decl
);
654 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
655 #ifdef DBX_OUTPUT_FUNCTION_END
656 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
658 if (use_gnu_debug_info_extensions
659 #if defined(NO_DBX_FUNCTION_END)
660 && ! NO_DBX_FUNCTION_END
662 && targetm
.have_named_sections
)
663 dbxout_function_end ();
666 #endif /* DBX_DEBUGGING_INFO */
668 /* Debug information for a global DECL. Called from toplev.c after
669 compilation proper has finished. */
671 dbxout_global_decl (decl
)
674 if (TREE_CODE (decl
) == VAR_DECL
675 && ! DECL_EXTERNAL (decl
)
676 && DECL_RTL_SET_P (decl
)) /* Not necessary? */
677 dbxout_symbol (decl
, 0);
680 /* At the end of compilation, finish writing the symbol table.
681 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
685 dbxout_finish (filename
)
686 const char *filename ATTRIBUTE_UNUSED
;
688 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
689 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asmfile
, filename
);
690 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
693 /* Output floating point type values used by the 'R' stab letter.
694 These numbers come from include/aout/stab_gnu.h in binutils/gdb.
696 There are only 3 real/complex types defined, and we need 7/6.
697 We use NF_SINGLE as a generic float type, and NF_COMPLEX as a generic
698 complex type. Since we have the type size anyways, we don't really need
699 to distinguish between different FP types, we only need to distinguish
700 between float and complex. This works fine with gdb.
702 We only use this for complex types, to avoid breaking backwards
703 compatibility for real types. complex types aren't in ISO C90, so it is
704 OK if old debuggers don't understand the debug info we emit for them. */
706 /* ??? These are supposed to be IEEE types, but we don't check for that.
707 We could perhaps add additional numbers for non-IEEE types if we need
711 dbxout_fptype_value (type
)
715 enum machine_mode mode
= TYPE_MODE (type
);
717 if (TREE_CODE (type
) == REAL_TYPE
)
721 else if (mode
== DFmode
)
723 else if (mode
== TFmode
|| mode
== XFmode
)
726 /* Use NF_SINGLE as a generic real type for other sizes. */
729 else if (TREE_CODE (type
) == COMPLEX_TYPE
)
733 else if (mode
== DCmode
)
735 else if (mode
== TCmode
|| mode
== XCmode
)
738 /* Use NF_COMPLEX as a generic complex type for other sizes. */
744 putc (value
, asmfile
);
748 /* Output the index of a type. */
751 dbxout_type_index (type
)
754 #ifndef DBX_USE_BINCL
755 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
758 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
759 fprintf (asmfile
, "(%d,%d)", t
->file_number
, t
->type_number
);
764 #if DBX_CONTIN_LENGTH > 0
765 /* Continue a symbol-description that gets too big.
766 End one symbol table entry with a double-backslash
767 and start a new one, eventually producing something like
768 .stabs "start......\\",code,0,value
769 .stabs "...rest",code,0,value */
774 #ifdef DBX_CONTIN_CHAR
775 fprintf (asmfile
, "%c", DBX_CONTIN_CHAR
);
777 fprintf (asmfile
, "\\\\");
779 dbxout_finish_symbol (NULL_TREE
);
780 fprintf (asmfile
, "%s\"", ASM_STABS_OP
);
781 current_sym_nchars
= 0;
783 #endif /* DBX_CONTIN_LENGTH > 0 */
785 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
786 This must be a separate function because anonymous unions require
790 dbxout_type_fields (type
)
795 /* Output the name, type, position (in bits), size (in bits) of each
796 field that we can support. */
797 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
799 /* Omit here local type decls until we know how to support them. */
800 if (TREE_CODE (tem
) == TYPE_DECL
801 /* Omit fields whose position or size are variable or too large to
803 || (TREE_CODE (tem
) == FIELD_DECL
804 && (! host_integerp (bit_position (tem
), 0)
806 || ! host_integerp (DECL_SIZE (tem
), 1)))
807 /* Omit here the nameless fields that are used to skip bits. */
808 || DECL_IGNORED_P (tem
))
811 else if (TREE_CODE (tem
) != CONST_DECL
)
813 /* Continue the line if necessary,
814 but not before the first field. */
815 if (tem
!= TYPE_FIELDS (type
))
820 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem
)));
821 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem
)));
825 fprintf (asmfile
, ":");
829 if (use_gnu_debug_info_extensions
830 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
831 || TREE_CODE (tem
) != FIELD_DECL
))
833 have_used_extensions
= 1;
835 putc ((TREE_PRIVATE (tem
) ? '0'
836 : TREE_PROTECTED (tem
) ? '1' : '2'),
841 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
842 && DECL_BIT_FIELD_TYPE (tem
))
843 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0);
845 if (TREE_CODE (tem
) == VAR_DECL
)
847 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
849 tree name
= DECL_ASSEMBLER_NAME (tem
);
851 have_used_extensions
= 1;
852 fprintf (asmfile
, ":%s;", IDENTIFIER_POINTER (name
));
853 CHARS (IDENTIFIER_LENGTH (name
) + 2);
857 /* If TEM is non-static, GDB won't understand it. */
858 fprintf (asmfile
, ",0,0;");
865 print_wide_int (int_bit_position (tem
));
867 print_wide_int (tree_low_cst (DECL_SIZE (tem
), 1));
875 /* Subroutine of `dbxout_type_methods'. Output debug info about the
876 method described DECL. DEBUG_NAME is an encoding of the method's
877 type signature. ??? We may be able to do without DEBUG_NAME altogether
881 dbxout_type_method_1 (decl
, debug_name
)
883 const char *debug_name
;
887 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
889 else /* it's a METHOD_TYPE. */
891 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
892 /* A for normal functions.
893 B for `const' member functions.
894 C for `volatile' member functions.
895 D for `const volatile' member functions. */
896 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
898 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
901 if (DECL_VINDEX (decl
))
907 fprintf (asmfile
, ":%s;%c%c%c", debug_name
,
908 TREE_PRIVATE (decl
) ? '0'
909 : TREE_PROTECTED (decl
) ? '1' : '2', c1
, c2
);
910 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
)) + 6
911 - (debug_name
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
913 if (DECL_VINDEX (decl
) && host_integerp (DECL_VINDEX (decl
), 0))
915 print_wide_int (tree_low_cst (DECL_VINDEX (decl
), 0));
918 dbxout_type (DECL_CONTEXT (decl
), 0);
919 fprintf (asmfile
, ";");
924 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
928 dbxout_type_methods (type
)
931 /* C++: put out the method names and their parameter lists */
932 tree methods
= TYPE_METHODS (type
);
936 char formatted_type_identifier_length
[16];
937 int type_identifier_length
;
939 if (methods
== NULL_TREE
)
942 type_encoding
= DECL_NAME (TYPE_NAME (type
));
945 /* C++: Template classes break some assumptions made by this code about
946 the class names, constructor names, and encodings for assembler
947 label names. For now, disable output of dbx info for them. */
949 const char *ptr
= IDENTIFIER_POINTER (type_encoding
);
950 /* This should use index. (mrs) */
951 while (*ptr
&& *ptr
!= '<') ptr
++;
962 type_identifier_length
= IDENTIFIER_LENGTH (type_encoding
);
964 sprintf (formatted_type_identifier_length
, "%d", type_identifier_length
);
966 if (TREE_CODE (methods
) != TREE_VEC
)
968 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
969 fndecl
= TREE_VEC_ELT (methods
, 0);
971 fndecl
= TREE_VEC_ELT (methods
, 1);
977 /* Group together all the methods for the same operation.
978 These differ in the types of the arguments. */
979 for (last
= NULL_TREE
;
980 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
981 fndecl
= TREE_CHAIN (fndecl
))
982 /* Output the name of the field (after overloading), as
983 well as the name of the field before overloading, along
984 with its parameter list */
986 /* This is the "mangled" name of the method.
987 It encodes the argument types. */
988 const char *debug_name
;
990 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
991 include TEMPLATE_DECLs.) The debugger doesn't know what
992 to do with such entities anyhow. */
993 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
996 debug_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
));
1002 /* Also ignore abstract methods; those are only interesting to
1003 the DWARF backends. */
1004 if (DECL_IGNORED_P (fndecl
) || DECL_ABSTRACT (fndecl
))
1007 /* Redundantly output the plain name, since that's what gdb
1011 tree name
= DECL_NAME (fndecl
);
1012 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (name
));
1013 CHARS (IDENTIFIER_LENGTH (name
) + 2);
1017 dbxout_type (TREE_TYPE (fndecl
), 0);
1019 dbxout_type_method_1 (fndecl
, debug_name
);
1023 putc (';', asmfile
);
1029 /* Emit a "range" type specification, which has the form:
1030 "r<index type>;<lower bound>;<upper bound>;".
1031 TYPE is an INTEGER_TYPE. */
1034 dbxout_range_type (type
)
1037 fprintf (asmfile
, "r");
1038 if (TREE_TYPE (type
))
1039 dbxout_type (TREE_TYPE (type
), 0);
1040 else if (TREE_CODE (type
) != INTEGER_TYPE
)
1041 dbxout_type (type
, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1044 /* Traditionally, we made sure 'int' was type 1, and builtin types
1045 were defined to be sub-ranges of int. Unfortunately, this
1046 does not allow us to distinguish true sub-ranges from integer
1047 types. So, instead we define integer (non-sub-range) types as
1048 sub-ranges of themselves. This matters for Chill. If this isn't
1049 a subrange type, then we want to define it in terms of itself.
1050 However, in C, this may be an anonymous integer type, and we don't
1051 want to emit debug info referring to it. Just calling
1052 dbxout_type_index won't work anyways, because the type hasn't been
1053 defined yet. We make this work for both cases by checked to see
1054 whether this is a defined type, referring to it if it is, and using
1056 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
1057 dbxout_type_index (type
);
1059 dbxout_type_index (integer_type_node
);
1062 if (TYPE_MIN_VALUE (type
) != 0
1063 && host_integerp (TYPE_MIN_VALUE (type
), 0))
1065 putc (';', asmfile
);
1067 print_wide_int (tree_low_cst (TYPE_MIN_VALUE (type
), 0));
1071 fprintf (asmfile
, ";0");
1075 if (TYPE_MAX_VALUE (type
) != 0
1076 && host_integerp (TYPE_MAX_VALUE (type
), 0))
1078 putc (';', asmfile
);
1080 print_wide_int (tree_low_cst (TYPE_MAX_VALUE (type
), 0));
1081 putc (';', asmfile
);
1086 fprintf (asmfile
, ";-1;");
1091 /* Output a reference to a type. If the type has not yet been
1092 described in the dbx output, output its definition now.
1093 For a type already defined, just refer to its definition
1094 using the type number.
1096 If FULL is nonzero, and the type has been described only with
1097 a forward-reference, output the definition now.
1098 If FULL is zero in this case, just refer to the forward-reference
1099 using the number previously allocated. */
1102 dbxout_type (type
, full
)
1108 static int anonymous_type_number
= 0;
1110 if (TREE_CODE (type
) == VECTOR_TYPE
)
1111 /* The frontend feeds us a representation for the vector as a struct
1112 containing an array. Pull out the array type. */
1113 type
= TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type
)));
1115 /* If there was an input error and we don't really have a type,
1116 avoid crashing and write something that is at least valid
1117 by assuming `int'. */
1118 if (type
== error_mark_node
)
1119 type
= integer_type_node
;
1122 if (TYPE_NAME (type
)
1123 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1124 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1128 /* Try to find the "main variant" with the same name. */
1129 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1130 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1131 main_variant
= TREE_TYPE (TYPE_NAME (type
));
1133 main_variant
= TYPE_MAIN_VARIANT (type
);
1135 /* If we are not using extensions, stabs does not distinguish const and
1136 volatile, so there is no need to make them separate types. */
1137 if (!use_gnu_debug_info_extensions
)
1138 type
= main_variant
;
1140 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1142 /* Type has no dbx number assigned. Assign next available number. */
1143 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1145 /* Make sure type vector is long enough to record about this type. */
1147 if (next_type_number
== typevec_len
)
1150 = (struct typeinfo
*) xrealloc (typevec
,
1151 typevec_len
* 2 * sizeof typevec
[0]);
1152 memset ((char *) (typevec
+ typevec_len
), 0,
1153 typevec_len
* sizeof typevec
[0]);
1157 #ifdef DBX_USE_BINCL
1158 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1159 = current_file
->file_number
;
1160 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1161 = current_file
->next_type_number
++;
1165 /* Output the number of this type, to refer to it. */
1166 dbxout_type_index (type
);
1168 #ifdef DBX_TYPE_DEFINED
1169 if (DBX_TYPE_DEFINED (type
))
1173 /* If this type's definition has been output or is now being output,
1176 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1181 /* If we have already had a cross reference,
1182 and either that's all we want or that's the best we could do,
1183 don't repeat the cross reference.
1184 Sun dbx crashes if we do. */
1185 if (! full
|| !COMPLETE_TYPE_P (type
)
1186 /* No way in DBX fmt to describe a variable size. */
1187 || ! host_integerp (TYPE_SIZE (type
), 1))
1195 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1196 leave the type-number completely undefined rather than output
1197 a cross-reference. If we have already used GNU debug info extensions,
1198 then it is OK to output a cross reference. This is necessary to get
1199 proper C++ debug output. */
1200 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1201 || TREE_CODE (type
) == QUAL_UNION_TYPE
1202 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1203 && ! use_gnu_debug_info_extensions
)
1204 /* We must use the same test here as we use twice below when deciding
1205 whether to emit a cross-reference. */
1206 if ((TYPE_NAME (type
) != 0
1207 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1208 && DECL_IGNORED_P (TYPE_NAME (type
)))
1210 || !COMPLETE_TYPE_P (type
)
1211 /* No way in DBX fmt to describe a variable size. */
1212 || ! host_integerp (TYPE_SIZE (type
), 1))
1214 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1219 /* Output a definition now. */
1221 fprintf (asmfile
, "=");
1224 /* Mark it as defined, so that if it is self-referent
1225 we will not get into an infinite recursion of definitions. */
1227 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1229 /* If this type is a variant of some other, hand off. Types with
1230 different names are usefully distinguished. We only distinguish
1231 cv-qualified types if we're using extensions. */
1232 if (TYPE_READONLY (type
) > TYPE_READONLY (main_variant
))
1234 putc ('k', asmfile
);
1236 dbxout_type (build_type_variant (type
, 0, TYPE_VOLATILE (type
)), 0);
1239 else if (TYPE_VOLATILE (type
) > TYPE_VOLATILE (main_variant
))
1241 putc ('B', asmfile
);
1243 dbxout_type (build_type_variant (type
, TYPE_READONLY (type
), 0), 0);
1246 else if (main_variant
!= TYPE_MAIN_VARIANT (type
))
1248 /* 'type' is a typedef; output the type it refers to. */
1249 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0);
1252 /* else continue. */
1254 switch (TREE_CODE (type
))
1258 /* For a void type, just define it as itself; ie, "5=5".
1259 This makes us consider it defined
1260 without saying what it is. The debugger will make it
1261 a void type when the reference is seen, and nothing will
1262 ever override that default. */
1263 dbxout_type_index (type
);
1267 if (type
== char_type_node
&& ! TREE_UNSIGNED (type
))
1269 /* Output the type `char' as a subrange of itself!
1270 I don't understand this definition, just copied it
1271 from the output of pcc.
1272 This used to use `r2' explicitly and we used to
1273 take care to make sure that `char' was type number 2. */
1274 fprintf (asmfile
, "r");
1276 dbxout_type_index (type
);
1277 fprintf (asmfile
, ";0;127;");
1281 /* If this is a subtype of another integer type, always prefer to
1282 write it as a subtype. */
1283 else if (TREE_TYPE (type
) != 0
1284 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
1286 /* If the size is non-standard, say what it is if we can use
1289 if (use_gnu_debug_info_extensions
1290 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1292 have_used_extensions
= 1;
1293 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1297 dbxout_range_type (type
);
1302 /* If the size is non-standard, say what it is if we can use
1305 if (use_gnu_debug_info_extensions
1306 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1308 have_used_extensions
= 1;
1309 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1313 /* If we can use GDB extensions and the size is wider than a
1314 long (the size used by GDB to read them) or we may have
1315 trouble writing the bounds the usual way, write them in
1316 octal. Note the test is for the *target's* size of "long",
1317 not that of the host. The host test is just to make sure we
1318 can write it out in case the host wide int is narrower than the
1321 /* For unsigned types, we use octal if they are the same size or
1322 larger. This is because we print the bounds as signed decimal,
1323 and hence they can't span same size unsigned types. */
1325 if (use_gnu_debug_info_extensions
1326 && TYPE_MIN_VALUE (type
) != 0
1327 && TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
1328 && TYPE_MAX_VALUE (type
) != 0
1329 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
1330 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
1331 || ((TYPE_PRECISION (type
)
1332 == TYPE_PRECISION (integer_type_node
))
1333 && TREE_UNSIGNED (type
))
1334 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
1335 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
1336 && TREE_UNSIGNED (type
))))
1338 fprintf (asmfile
, "r");
1340 dbxout_type_index (type
);
1341 fprintf (asmfile
, ";");
1343 print_int_cst_octal (TYPE_MIN_VALUE (type
));
1344 fprintf (asmfile
, ";");
1346 print_int_cst_octal (TYPE_MAX_VALUE (type
));
1347 fprintf (asmfile
, ";");
1352 /* Output other integer types as subranges of `int'. */
1353 dbxout_range_type (type
);
1359 /* This used to say `r1' and we used to take care
1360 to make sure that `int' was type number 1. */
1361 fprintf (asmfile
, "r");
1363 dbxout_type_index (integer_type_node
);
1364 putc (';', asmfile
);
1366 print_wide_int (int_size_in_bytes (type
));
1367 fputs (";0;", asmfile
);
1372 if (use_gnu_debug_info_extensions
)
1374 have_used_extensions
= 1;
1375 fputs ("@s", asmfile
);
1377 print_wide_int (BITS_PER_UNIT
* int_size_in_bytes (type
));
1378 fputs (";-20;", asmfile
);
1383 /* Output the type `char' as a subrange of itself.
1384 That is what pcc seems to do. */
1385 fprintf (asmfile
, "r");
1387 dbxout_type_index (char_type_node
);
1388 fprintf (asmfile
, ";0;%d;", TREE_UNSIGNED (type
) ? 255 : 127);
1394 if (use_gnu_debug_info_extensions
)
1396 have_used_extensions
= 1;
1397 fputs ("@s", asmfile
);
1399 print_wide_int (BITS_PER_UNIT
* int_size_in_bytes (type
));
1400 fputs (";-16;", asmfile
);
1403 else /* Define as enumeral type (False, True) */
1405 fprintf (asmfile
, "eFalse:0,True:1,;");
1411 putc ('d', asmfile
);
1413 dbxout_type (TREE_TYPE (type
), 0);
1417 /* Differs from the REAL_TYPE by its new data type number */
1419 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1421 putc ('R', asmfile
);
1423 dbxout_fptype_value (type
);
1424 putc (';', asmfile
);
1426 print_wide_int (2 * int_size_in_bytes (TREE_TYPE (type
)));
1427 fputs (";0;", asmfile
);
1432 /* Output a complex integer type as a structure,
1433 pending some other way to do it. */
1434 putc ('s', asmfile
);
1436 print_wide_int (int_size_in_bytes (type
));
1437 fprintf (asmfile
, "real:");
1440 dbxout_type (TREE_TYPE (type
), 0);
1441 fprintf (asmfile
, ",0,%d;", TYPE_PRECISION (TREE_TYPE (type
)));
1443 fprintf (asmfile
, "imag:");
1445 dbxout_type (TREE_TYPE (type
), 0);
1446 fprintf (asmfile
, ",%d,%d;;", TYPE_PRECISION (TREE_TYPE (type
)),
1447 TYPE_PRECISION (TREE_TYPE (type
)));
1453 if (use_gnu_debug_info_extensions
)
1455 have_used_extensions
= 1;
1456 fputs ("@s", asmfile
);
1458 print_wide_int (BITS_PER_UNIT
* int_size_in_bytes (type
));
1459 putc (';', asmfile
);
1462 /* Check if a bitstring type, which in Chill is
1463 different from a [power]set. */
1464 if (TYPE_STRING_FLAG (type
))
1466 fprintf (asmfile
, "@S;");
1470 putc ('S', asmfile
);
1472 dbxout_type (TYPE_DOMAIN (type
), 0);
1476 /* Make arrays of packed bits look like bitstrings for chill. */
1477 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
1479 have_used_extensions
= 1;
1480 fputs ("@s", asmfile
);
1482 print_wide_int (BITS_PER_UNIT
* int_size_in_bytes (type
));
1483 fprintf (asmfile
, ";@S;S");
1485 dbxout_type (TYPE_DOMAIN (type
), 0);
1489 /* Output "a" followed by a range type definition
1490 for the index type of the array
1491 followed by a reference to the target-type.
1492 ar1;0;N;M for a C array of type M and size N+1. */
1493 /* Check if a character string type, which in Chill is
1494 different from an array of characters. */
1495 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
1497 have_used_extensions
= 1;
1498 fprintf (asmfile
, "@S;");
1501 tem
= TYPE_DOMAIN (type
);
1504 fprintf (asmfile
, "ar");
1506 dbxout_type_index (integer_type_node
);
1507 fprintf (asmfile
, ";0;-1;");
1512 fprintf (asmfile
, "a");
1514 dbxout_range_type (tem
);
1517 dbxout_type (TREE_TYPE (type
), 0);
1522 case QUAL_UNION_TYPE
:
1524 int i
, n_baseclasses
= 0;
1526 if (TYPE_BINFO (type
) != 0
1527 && TREE_CODE (TYPE_BINFO (type
)) == TREE_VEC
1528 && TYPE_BINFO_BASETYPES (type
) != 0)
1529 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
1531 /* Output a structure type. We must use the same test here as we
1532 use in the DBX_NO_XREFS case above. */
1533 if ((TYPE_NAME (type
) != 0
1534 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1535 && DECL_IGNORED_P (TYPE_NAME (type
)))
1537 || !COMPLETE_TYPE_P (type
)
1538 /* No way in DBX fmt to describe a variable size. */
1539 || ! host_integerp (TYPE_SIZE (type
), 1))
1541 /* If the type is just a cross reference, output one
1542 and mark the type as partially described.
1543 If it later becomes defined, we will output
1544 its real definition.
1545 If the type has a name, don't nest its definition within
1546 another type's definition; instead, output an xref
1547 and let the definition come when the name is defined. */
1548 fputs ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu", asmfile
);
1550 #if 0 /* This assertion is legitimately false in C++. */
1551 /* We shouldn't be outputting a reference to a type before its
1552 definition unless the type has a tag name.
1553 A typedef name without a tag name should be impossible. */
1554 if (TREE_CODE (TYPE_NAME (type
)) != IDENTIFIER_NODE
)
1557 if (TYPE_NAME (type
) != 0)
1558 dbxout_type_name (type
);
1561 fprintf (asmfile
, "$$%d", anonymous_type_number
++);
1565 fprintf (asmfile
, ":");
1567 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1571 /* Identify record or union, and print its size. */
1572 putc (((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u'), asmfile
);
1574 print_wide_int (int_size_in_bytes (type
));
1576 if (use_gnu_debug_info_extensions
)
1580 have_used_extensions
= 1;
1581 fprintf (asmfile
, "!%d,", n_baseclasses
);
1585 for (i
= 0; i
< n_baseclasses
; i
++)
1587 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)), i
);
1589 if (use_gnu_debug_info_extensions
)
1591 have_used_extensions
= 1;
1592 putc (TREE_VIA_VIRTUAL (child
) ? '1' : '0', asmfile
);
1593 putc (TREE_VIA_PUBLIC (child
) ? '2' : '0', asmfile
);
1595 if (TREE_VIA_VIRTUAL (child
) && strcmp (lang_hooks
.name
, "GNU C++") == 0)
1596 /* For a virtual base, print the (negative) offset within
1597 the vtable where we must look to find the necessary
1599 print_wide_int (tree_low_cst (BINFO_VPTR_FIELD (child
), 0)
1602 print_wide_int (tree_low_cst (BINFO_OFFSET (child
), 0)
1604 putc (',', asmfile
);
1606 dbxout_type (BINFO_TYPE (child
), 0);
1607 putc (';', asmfile
);
1612 /* Print out the base class information with fields
1613 which have the same names at the types they hold. */
1614 dbxout_type_name (BINFO_TYPE (child
));
1615 putc (':', asmfile
);
1617 dbxout_type (BINFO_TYPE (child
), full
);
1618 putc (',', asmfile
);
1620 print_wide_int (tree_low_cst (BINFO_OFFSET (child
), 0)
1622 putc (',', asmfile
);
1624 print_wide_int (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child
)),
1627 putc (';', asmfile
);
1633 /* Write out the field declarations. */
1634 dbxout_type_fields (type
);
1635 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1637 have_used_extensions
= 1;
1638 dbxout_type_methods (type
);
1641 putc (';', asmfile
);
1644 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1645 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1646 && TYPE_VFIELD (type
))
1648 have_used_extensions
= 1;
1650 /* Tell GDB+ that it may keep reading. */
1651 putc ('~', asmfile
);
1654 /* We need to write out info about what field this class
1655 uses as its "main" vtable pointer field, because if this
1656 field is inherited from a base class, GDB cannot necessarily
1657 figure out which field it's using in time. */
1658 if (TYPE_VFIELD (type
))
1660 putc ('%', asmfile
);
1662 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0);
1665 putc (';', asmfile
);
1671 /* We must use the same test here as we use in the DBX_NO_XREFS case
1672 above. We simplify it a bit since an enum will never have a variable
1674 if ((TYPE_NAME (type
) != 0
1675 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1676 && DECL_IGNORED_P (TYPE_NAME (type
)))
1678 || !COMPLETE_TYPE_P (type
))
1680 fprintf (asmfile
, "xe");
1682 dbxout_type_name (type
);
1683 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1684 putc (':', asmfile
);
1688 #ifdef DBX_OUTPUT_ENUM
1689 DBX_OUTPUT_ENUM (asmfile
, type
);
1691 if (use_gnu_debug_info_extensions
1692 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1694 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1698 putc ('e', asmfile
);
1700 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1702 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)));
1703 CHARS (IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)) + 1);
1704 if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == 0)
1705 print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1706 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == -1
1707 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (TREE_VALUE (tem
)) < 0)
1708 print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1710 print_int_cst_octal (TREE_VALUE (tem
));
1712 putc (',', asmfile
);
1714 if (TREE_CHAIN (tem
) != 0)
1718 putc (';', asmfile
);
1724 putc ('*', asmfile
);
1726 dbxout_type (TREE_TYPE (type
), 0);
1730 if (use_gnu_debug_info_extensions
)
1732 have_used_extensions
= 1;
1733 putc ('#', asmfile
);
1736 /* Write the argument types out longhand. */
1737 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0);
1738 putc (',', asmfile
);
1740 dbxout_type (TREE_TYPE (type
), 0);
1741 dbxout_args (TYPE_ARG_TYPES (type
));
1742 putc (';', asmfile
);
1746 /* Treat it as a function type. */
1747 dbxout_type (TREE_TYPE (type
), 0);
1751 if (use_gnu_debug_info_extensions
)
1753 have_used_extensions
= 1;
1754 putc ('@', asmfile
);
1756 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0);
1757 putc (',', asmfile
);
1759 dbxout_type (TREE_TYPE (type
), 0);
1762 /* Should print as an int, because it is really just an offset. */
1763 dbxout_type (integer_type_node
, 0);
1766 case REFERENCE_TYPE
:
1767 if (use_gnu_debug_info_extensions
)
1768 have_used_extensions
= 1;
1769 putc (use_gnu_debug_info_extensions
? '&' : '*', asmfile
);
1771 dbxout_type (TREE_TYPE (type
), 0);
1775 putc ('f', asmfile
);
1777 dbxout_type (TREE_TYPE (type
), 0);
1785 /* Print the value of integer constant C, in octal,
1786 handling double precision. */
1789 print_int_cst_octal (c
)
1792 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (c
);
1793 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (c
);
1794 int excess
= (3 - (HOST_BITS_PER_WIDE_INT
% 3));
1795 unsigned int width
= TYPE_PRECISION (TREE_TYPE (c
));
1797 /* GDB wants constants with no extra leading "1" bits, so
1798 we need to remove any sign-extension that might be
1800 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
1802 else if (width
> HOST_BITS_PER_WIDE_INT
)
1803 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
1804 else if (width
== HOST_BITS_PER_WIDE_INT
)
1807 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
1809 fprintf (asmfile
, "0");
1814 print_octal (high
, HOST_BITS_PER_WIDE_INT
/ 3);
1815 print_octal (low
, HOST_BITS_PER_WIDE_INT
/ 3);
1819 unsigned HOST_WIDE_INT beg
= high
>> excess
;
1820 unsigned HOST_WIDE_INT middle
1821 = ((high
& (((HOST_WIDE_INT
) 1 << excess
) - 1)) << (3 - excess
)
1822 | (low
>> (HOST_BITS_PER_WIDE_INT
/ 3 * 3)));
1823 unsigned HOST_WIDE_INT end
1824 = low
& (((unsigned HOST_WIDE_INT
) 1
1825 << (HOST_BITS_PER_WIDE_INT
/ 3 * 3))
1828 fprintf (asmfile
, "%o%01o", (int) beg
, (int) middle
);
1830 print_octal (end
, HOST_BITS_PER_WIDE_INT
/ 3);
1835 print_octal (value
, digits
)
1836 unsigned HOST_WIDE_INT value
;
1841 for (i
= digits
- 1; i
>= 0; i
--)
1842 fprintf (asmfile
, "%01o", (int) ((value
>> (3 * i
)) & 7));
1847 /* Output C in decimal while adjusting the number of digits written. */
1855 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, c
);
1866 /* Output the name of type TYPE, with no punctuation.
1867 Such names can be set up either by typedef declarations
1868 or by struct, enum and union tags. */
1871 dbxout_type_name (type
)
1875 if (TYPE_NAME (type
) == 0)
1877 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
1879 t
= TYPE_NAME (type
);
1881 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1883 t
= DECL_NAME (TYPE_NAME (type
));
1888 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
1889 CHARS (IDENTIFIER_LENGTH (t
));
1892 /* Output leading leading struct or class names needed for qualifying
1893 type whose scope is limited to a struct or class. */
1896 dbxout_class_name_qualifiers (decl
)
1899 tree context
= decl_type_context (decl
);
1901 if (context
!= NULL_TREE
1902 && TREE_CODE(context
) == RECORD_TYPE
1903 && TYPE_NAME (context
) != 0
1904 && (TREE_CODE (TYPE_NAME (context
)) == IDENTIFIER_NODE
1905 || (DECL_NAME (TYPE_NAME (context
)) != 0)))
1907 tree name
= TYPE_NAME (context
);
1909 if (TREE_CODE (name
) == TYPE_DECL
)
1911 dbxout_class_name_qualifiers (name
);
1912 name
= DECL_NAME (name
);
1914 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (name
));
1915 CHARS (IDENTIFIER_LENGTH (name
) + 2);
1919 /* Output a .stabs for the symbol defined by DECL,
1920 which must be a ..._DECL node in the normal namespace.
1921 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1922 LOCAL is nonzero if the scope is less than the entire file.
1923 Return 1 if a stabs might have been emitted. */
1926 dbxout_symbol (decl
, local
)
1928 int local ATTRIBUTE_UNUSED
;
1930 tree type
= TREE_TYPE (decl
);
1931 tree context
= NULL_TREE
;
1934 /* Cast avoids warning in old compilers. */
1935 current_sym_code
= (STAB_CODE_TYPE
) 0;
1936 current_sym_value
= 0;
1937 current_sym_addr
= 0;
1939 /* Ignore nameless syms, but don't ignore type tags. */
1941 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
1942 || DECL_IGNORED_P (decl
))
1945 dbxout_prepare_symbol (decl
);
1947 /* The output will always start with the symbol name,
1948 so always count that in the length-output-so-far. */
1950 if (DECL_NAME (decl
) != 0)
1951 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
1953 switch (TREE_CODE (decl
))
1956 /* Enum values are defined by defining the enum type. */
1960 if (DECL_RTL (decl
) == 0)
1962 if (DECL_EXTERNAL (decl
))
1964 /* Don't mention a nested function under its parent. */
1965 context
= decl_function_context (decl
);
1966 if (context
== current_function_decl
)
1968 if (GET_CODE (DECL_RTL (decl
)) != MEM
1969 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
1973 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
1974 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1975 TREE_PUBLIC (decl
) ? 'F' : 'f');
1978 current_sym_code
= N_FUN
;
1979 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1981 if (TREE_TYPE (type
))
1982 dbxout_type (TREE_TYPE (type
), 0);
1984 dbxout_type (void_type_node
, 0);
1986 /* For a nested function, when that function is compiled,
1987 mention the containing function name
1988 as well as (since dbx wants it) our own assembler-name. */
1990 fprintf (asmfile
, ",%s,%s",
1991 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1992 IDENTIFIER_POINTER (DECL_NAME (context
)));
1994 dbxout_finish_symbol (decl
);
1999 /* This seems all wrong. Outputting most kinds of types gives no name
2000 at all. A true definition gives no name; a cross-ref for a
2001 structure can give the tag name, but not a type name.
2002 It seems that no typedef name is defined by outputting a type. */
2004 /* If this typedef name was defined by outputting the type,
2005 don't duplicate it. */
2006 if (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
== TYPE_DEFINED
2007 && TYPE_NAME (TREE_TYPE (decl
)) == decl
)
2010 /* Don't output the same typedef twice.
2011 And don't output what language-specific stuff doesn't want output. */
2012 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
2021 if (DECL_NAME (decl
))
2023 /* Nonzero means we must output a tag as well as a typedef. */
2026 /* Handle the case of a C++ structure or union
2027 where the TYPE_NAME is a TYPE_DECL
2028 which gives both a typedef name and a tag. */
2029 /* dbx requires the tag first and the typedef second. */
2030 if ((TREE_CODE (type
) == RECORD_TYPE
2031 || TREE_CODE (type
) == UNION_TYPE
2032 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2033 && TYPE_NAME (type
) == decl
2034 && !(use_gnu_debug_info_extensions
&& have_used_extensions
)
2035 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
2036 /* Distinguish the implicit typedefs of C++
2037 from explicit ones that might be found in C. */
2038 && DECL_ARTIFICIAL (decl
)
2039 /* Do not generate a tag for records of variable size,
2040 since this type can not be properly described in the
2041 DBX format, and it confuses some tools such as objdump. */
2042 && host_integerp (TYPE_SIZE (type
), 1))
2044 tree name
= TYPE_NAME (type
);
2045 if (TREE_CODE (name
) == TYPE_DECL
)
2046 name
= DECL_NAME (name
);
2048 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
2049 current_sym_value
= 0;
2050 current_sym_addr
= 0;
2051 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
2053 fprintf (asmfile
, "%s\"%s:T", ASM_STABS_OP
,
2054 IDENTIFIER_POINTER (name
));
2055 dbxout_type (type
, 1);
2056 dbxout_finish_symbol (NULL_TREE
);
2059 /* Output .stabs (or whatever) and leading double quote. */
2060 fprintf (asmfile
, "%s\"", ASM_STABS_OP
);
2062 if (use_gnu_debug_info_extensions
)
2064 /* Output leading class/struct qualifiers. */
2065 dbxout_class_name_qualifiers (decl
);
2068 /* Output typedef name. */
2069 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (DECL_NAME (decl
)));
2071 /* Short cut way to output a tag also. */
2072 if ((TREE_CODE (type
) == RECORD_TYPE
2073 || TREE_CODE (type
) == UNION_TYPE
2074 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2075 && TYPE_NAME (type
) == decl
2076 /* Distinguish the implicit typedefs of C++
2077 from explicit ones that might be found in C. */
2078 && DECL_ARTIFICIAL (decl
))
2080 if (use_gnu_debug_info_extensions
&& have_used_extensions
)
2082 putc ('T', asmfile
);
2083 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
2085 #if 0 /* Now we generate the tag for this case up above. */
2091 putc ('t', asmfile
);
2092 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
2094 dbxout_type (type
, 1);
2095 dbxout_finish_symbol (decl
);
2099 /* Don't output a tag if this is an incomplete type. This prevents
2100 the sun4 Sun OS 4.x dbx from crashing. */
2102 if (tag_needed
&& TYPE_NAME (type
) != 0
2103 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
2104 || (DECL_NAME (TYPE_NAME (type
)) != 0))
2105 && COMPLETE_TYPE_P (type
)
2106 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
2108 /* For a TYPE_DECL with no name, but the type has a name,
2110 This is what represents `struct foo' with no typedef. */
2111 /* In C++, the name of a type is the corresponding typedef.
2112 In C, it is an IDENTIFIER_NODE. */
2113 tree name
= TYPE_NAME (type
);
2114 if (TREE_CODE (name
) == TYPE_DECL
)
2115 name
= DECL_NAME (name
);
2117 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
2118 current_sym_value
= 0;
2119 current_sym_addr
= 0;
2120 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
2122 fprintf (asmfile
, "%s\"%s:T", ASM_STABS_OP
,
2123 IDENTIFIER_POINTER (name
));
2124 dbxout_type (type
, 1);
2125 dbxout_finish_symbol (NULL_TREE
);
2129 /* If an enum type has no name, it cannot be referred to,
2130 but we must output it anyway, since the enumeration constants
2131 can be referred to. */
2132 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2134 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
2135 current_sym_value
= 0;
2136 current_sym_addr
= 0;
2137 current_sym_nchars
= 2;
2139 /* Some debuggers fail when given NULL names, so give this a
2140 harmless name of ` '. */
2141 fprintf (asmfile
, "%s\" :T", ASM_STABS_OP
);
2142 dbxout_type (type
, 1);
2143 dbxout_finish_symbol (NULL_TREE
);
2146 /* Prevent duplicate output of a typedef. */
2147 TREE_ASM_WRITTEN (decl
) = 1;
2152 /* Parm decls go in their own separate chains
2153 and are output by dbxout_reg_parms and dbxout_parms. */
2157 /* Named return value, treat like a VAR_DECL. */
2159 if (! DECL_RTL_SET_P (decl
))
2161 /* Don't mention a variable that is external.
2162 Let the file that defines it describe it. */
2163 if (DECL_EXTERNAL (decl
))
2166 /* If the variable is really a constant
2167 and not written in memory, inform the debugger. */
2168 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
2169 && DECL_INITIAL (decl
) != 0
2170 && host_integerp (DECL_INITIAL (decl
), 0)
2171 && ! TREE_ASM_WRITTEN (decl
)
2172 && (DECL_CONTEXT (decl
) == NULL_TREE
2173 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
))
2175 if (TREE_PUBLIC (decl
) == 0)
2177 /* The sun4 assembler does not grok this. */
2178 const char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
2180 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
2181 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2183 HOST_WIDE_INT ival
= tree_low_cst (DECL_INITIAL (decl
), 0);
2184 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
2185 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile
, name
, ival
);
2187 fprintf (asmfile
, "%s\"%s:c=i", ASM_STABS_OP
, name
);
2189 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, ival
);
2190 fprintf (asmfile
, "\",0x%x,0,0,0\n", N_LSYM
);
2194 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
2196 /* don't know how to do this yet. */
2200 /* else it is something we handle like a normal variable. */
2203 SET_DECL_RTL (decl
, eliminate_regs (DECL_RTL (decl
), 0, NULL_RTX
));
2204 #ifdef LEAF_REG_REMAP
2205 if (current_function_uses_only_leaf_regs
)
2206 leaf_renumber_regs_insn (DECL_RTL (decl
));
2209 result
= dbxout_symbol_location (decl
, type
, 0, DECL_RTL (decl
));
2218 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2219 Add SUFFIX to its name, if SUFFIX is not 0.
2220 Describe the variable as residing in HOME
2221 (usually HOME is DECL_RTL (DECL), but not always).
2222 Returns 1 if the stab was really emitted. */
2225 dbxout_symbol_location (decl
, type
, suffix
, home
)
2233 /* Don't mention a variable at all
2234 if it was completely optimized into nothingness.
2236 If the decl was from an inline function, then its rtl
2237 is not identically the rtl that was used in this
2238 particular compilation. */
2239 if (GET_CODE (home
) == SUBREG
)
2243 while (GET_CODE (value
) == SUBREG
)
2244 value
= SUBREG_REG (value
);
2245 if (GET_CODE (value
) == REG
)
2247 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
2250 home
= alter_subreg (&home
);
2252 if (GET_CODE (home
) == REG
)
2254 regno
= REGNO (home
);
2255 if (regno
>= FIRST_PSEUDO_REGISTER
)
2259 /* The kind-of-variable letter depends on where
2260 the variable is and on the scope of its name:
2261 G and N_GSYM for static storage and global scope,
2262 S for static storage and file scope,
2263 V for static storage and local scope,
2264 for those two, use N_LCSYM if data is in bss segment,
2265 N_STSYM if in data segment, N_FUN otherwise.
2266 (We used N_FUN originally, then changed to N_STSYM
2267 to please GDB. However, it seems that confused ld.
2268 Now GDB has been fixed to like N_FUN, says Kingdon.)
2269 no letter at all, and N_LSYM, for auto variable,
2270 r and N_RSYM for register variable. */
2272 if (GET_CODE (home
) == MEM
2273 && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2275 if (TREE_PUBLIC (decl
))
2278 current_sym_code
= N_GSYM
;
2282 current_sym_addr
= XEXP (home
, 0);
2284 letter
= decl_function_context (decl
) ? 'V' : 'S';
2286 /* This should be the same condition as in assemble_variable, but
2287 we don't have access to dont_output_data here. So, instead,
2288 we rely on the fact that error_mark_node initializers always
2289 end up in bss for C++ and never end up in bss for C. */
2290 if (DECL_INITIAL (decl
) == 0
2291 || (!strcmp (lang_hooks
.name
, "GNU C++")
2292 && DECL_INITIAL (decl
) == error_mark_node
))
2293 current_sym_code
= N_LCSYM
;
2294 else if (DECL_IN_TEXT_SECTION (decl
))
2295 /* This is not quite right, but it's the closest
2296 of all the codes that Unix defines. */
2297 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
2300 /* Some ports can transform a symbol ref into a label ref,
2301 because the symbol ref is too far away and has to be
2302 dumped into a constant pool. Alternatively, the symbol
2303 in the constant pool might be referenced by a different
2305 if (GET_CODE (current_sym_addr
) == SYMBOL_REF
2306 && CONSTANT_POOL_ADDRESS_P (current_sym_addr
))
2308 rtx tmp
= get_pool_constant (current_sym_addr
);
2310 if (GET_CODE (tmp
) == SYMBOL_REF
2311 || GET_CODE (tmp
) == LABEL_REF
)
2312 current_sym_addr
= tmp
;
2315 /* Ultrix `as' seems to need this. */
2316 #ifdef DBX_STATIC_STAB_DATA_SECTION
2319 current_sym_code
= N_STSYM
;
2323 else if (regno
>= 0)
2326 current_sym_code
= N_RSYM
;
2327 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
2329 else if (GET_CODE (home
) == MEM
2330 && (GET_CODE (XEXP (home
, 0)) == MEM
2331 || (GET_CODE (XEXP (home
, 0)) == REG
2332 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
2333 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
2334 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2335 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
2338 /* If the value is indirect by memory or by a register
2339 that isn't the frame pointer
2340 then it means the object is variable-sized and address through
2341 that register or stack slot. DBX has no way to represent this
2342 so all we can do is output the variable as a pointer.
2343 If it's not a parameter, ignore it.
2344 (VAR_DECLs like this can be made by integrate.c.) */
2346 if (GET_CODE (XEXP (home
, 0)) == REG
)
2349 current_sym_code
= N_RSYM
;
2350 if (REGNO (XEXP (home
, 0)) >= FIRST_PSEUDO_REGISTER
)
2352 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
2356 current_sym_code
= N_LSYM
;
2357 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2358 We want the value of that CONST_INT. */
2360 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
2363 /* Effectively do build_pointer_type, but don't cache this type,
2364 since it might be temporary whereas the type it points to
2365 might have been saved for inlining. */
2366 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2367 type
= make_node (POINTER_TYPE
);
2368 TREE_TYPE (type
) = TREE_TYPE (decl
);
2370 else if (GET_CODE (home
) == MEM
2371 && GET_CODE (XEXP (home
, 0)) == REG
)
2373 current_sym_code
= N_LSYM
;
2374 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2376 else if (GET_CODE (home
) == MEM
2377 && GET_CODE (XEXP (home
, 0)) == PLUS
2378 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
2380 current_sym_code
= N_LSYM
;
2381 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2382 We want the value of that CONST_INT. */
2383 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2385 else if (GET_CODE (home
) == MEM
2386 && GET_CODE (XEXP (home
, 0)) == CONST
)
2388 /* Handle an obscure case which can arise when optimizing and
2389 when there are few available registers. (This is *always*
2390 the case for i386/i486 targets). The RTL looks like
2391 (MEM (CONST ...)) even though this variable is a local `auto'
2392 or a local `register' variable. In effect, what has happened
2393 is that the reload pass has seen that all assignments and
2394 references for one such a local variable can be replaced by
2395 equivalent assignments and references to some static storage
2396 variable, thereby avoiding the need for a register. In such
2397 cases we're forced to lie to debuggers and tell them that
2398 this variable was itself `static'. */
2399 current_sym_code
= N_LCSYM
;
2401 current_sym_addr
= XEXP (XEXP (home
, 0), 0);
2403 else if (GET_CODE (home
) == CONCAT
)
2407 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
2408 for example), then there is no easy way to figure out
2409 what SUBTYPE should be. So, we give up. */
2410 if (TREE_CODE (type
) != COMPLEX_TYPE
)
2413 subtype
= TREE_TYPE (type
);
2415 /* If the variable's storage is in two parts,
2416 output each as a separate stab with a modified name. */
2417 if (WORDS_BIG_ENDIAN
)
2418 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
2420 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
2422 /* Cast avoids warning in old compilers. */
2423 current_sym_code
= (STAB_CODE_TYPE
) 0;
2424 current_sym_value
= 0;
2425 current_sym_addr
= 0;
2426 dbxout_prepare_symbol (decl
);
2428 if (WORDS_BIG_ENDIAN
)
2429 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
2431 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
2435 /* Address might be a MEM, when DECL is a variable-sized object.
2436 Or it might be const0_rtx, meaning previous passes
2437 want us to ignore this variable. */
2440 /* Ok, start a symtab entry and output the variable name. */
2443 #ifdef DBX_STATIC_BLOCK_START
2444 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
2447 dbxout_symbol_name (decl
, suffix
, letter
);
2448 dbxout_type (type
, 0);
2449 dbxout_finish_symbol (decl
);
2451 #ifdef DBX_STATIC_BLOCK_END
2452 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
2457 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2458 Then output LETTER to indicate the kind of location the symbol has. */
2461 dbxout_symbol_name (decl
, suffix
, letter
)
2468 if (DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
)))
2469 /* One slight hitch: if this is a VAR_DECL which is a static
2470 class member, we must put out the mangled name instead of the
2471 DECL_NAME. Note also that static member (variable) names DO NOT begin
2472 with underscores in .stabs directives. */
2473 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2475 /* ...but if we're function-local, we don't want to include the junk
2476 added by ASM_FORMAT_PRIVATE_NAME. */
2477 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
2481 fprintf (asmfile
, "%s\"%s%s:", ASM_STABS_OP
, name
,
2482 (suffix
? suffix
: ""));
2485 putc (letter
, asmfile
);
2489 dbxout_prepare_symbol (decl
)
2490 tree decl ATTRIBUTE_UNUSED
;
2493 const char *filename
= DECL_SOURCE_FILE (decl
);
2495 dbxout_source_file (asmfile
, filename
);
2500 dbxout_finish_symbol (sym
)
2503 #ifdef DBX_FINISH_SYMBOL
2504 DBX_FINISH_SYMBOL (sym
);
2507 if (use_gnu_debug_info_extensions
&& sym
!= 0)
2508 line
= DECL_SOURCE_LINE (sym
);
2510 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
2511 if (current_sym_addr
)
2512 output_addr_const (asmfile
, current_sym_addr
);
2514 fprintf (asmfile
, "%d", current_sym_value
);
2515 putc ('\n', asmfile
);
2519 /* Output definitions of all the decls in a chain. Return nonzero if
2520 anything was output */
2529 result
+= dbxout_symbol (syms
, 1);
2530 syms
= TREE_CHAIN (syms
);
2535 /* The following two functions output definitions of function parameters.
2536 Each parameter gets a definition locating it in the parameter list.
2537 Each parameter that is a register variable gets a second definition
2538 locating it in the register.
2540 Printing or argument lists in gdb uses the definitions that
2541 locate in the parameter list. But reference to the variable in
2542 expressions uses preferentially the definition as a register. */
2544 /* Output definitions, referring to storage in the parmlist,
2545 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2548 dbxout_parms (parms
)
2551 for (; parms
; parms
= TREE_CHAIN (parms
))
2552 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
2554 dbxout_prepare_symbol (parms
);
2556 /* Perform any necessary register eliminations on the parameter's rtl,
2557 so that the debugging output will be accurate. */
2558 DECL_INCOMING_RTL (parms
)
2559 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
2560 SET_DECL_RTL (parms
, eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
));
2561 #ifdef LEAF_REG_REMAP
2562 if (current_function_uses_only_leaf_regs
)
2564 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
2565 leaf_renumber_regs_insn (DECL_RTL (parms
));
2569 if (PARM_PASSED_IN_MEMORY (parms
))
2571 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
2573 /* ??? Here we assume that the parm address is indexed
2574 off the frame pointer or arg pointer.
2575 If that is not true, we produce meaningless results,
2576 but do not crash. */
2577 if (GET_CODE (addr
) == PLUS
2578 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
2579 current_sym_value
= INTVAL (XEXP (addr
, 1));
2581 current_sym_value
= 0;
2583 current_sym_code
= N_PSYM
;
2584 current_sym_addr
= 0;
2587 if (DECL_NAME (parms
))
2589 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2591 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2592 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2593 DBX_MEMPARM_STABS_LETTER
);
2597 current_sym_nchars
= 8;
2598 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2599 DBX_MEMPARM_STABS_LETTER
);
2602 /* It is quite tempting to use:
2604 dbxout_type (TREE_TYPE (parms), 0);
2606 as the next statement, rather than using DECL_ARG_TYPE(), so
2607 that gcc reports the actual type of the parameter, rather
2608 than the promoted type. This certainly makes GDB's life
2609 easier, at least for some ports. The change is a bad idea
2610 however, since GDB expects to be able access the type without
2611 performing any conversions. So for example, if we were
2612 passing a float to an unprototyped function, gcc will store a
2613 double on the stack, but if we emit a stab saying the type is a
2614 float, then gdb will only read in a single value, and this will
2615 produce an erroneous value. */
2616 dbxout_type (DECL_ARG_TYPE (parms
), 0);
2617 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
2618 dbxout_finish_symbol (parms
);
2620 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
2623 char regparm_letter
;
2625 /* Parm passed in registers and lives in registers or nowhere. */
2627 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2628 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2629 current_sym_addr
= 0;
2631 /* If parm lives in a register, use that register;
2632 pretend the parm was passed there. It would be more consistent
2633 to describe the register where the parm was passed,
2634 but in practice that register usually holds something else.
2636 If we use DECL_RTL, then we must use the declared type of
2637 the variable, not the type that it arrived in. */
2638 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2640 best_rtl
= DECL_RTL (parms
);
2641 parm_type
= TREE_TYPE (parms
);
2643 /* If the parm lives nowhere, use the register where it was
2644 passed. It is also better to use the declared type here. */
2647 best_rtl
= DECL_INCOMING_RTL (parms
);
2648 parm_type
= TREE_TYPE (parms
);
2650 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
2653 if (DECL_NAME (parms
))
2655 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2656 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2657 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2662 current_sym_nchars
= 8;
2663 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2667 dbxout_type (parm_type
, 0);
2668 dbxout_finish_symbol (parms
);
2670 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2671 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
2672 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
2673 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
2674 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2675 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
2679 /* Parm was passed via invisible reference.
2680 That is, its address was passed in a register.
2681 Output it as if it lived in that register.
2682 The debugger will know from the type
2683 that it was actually passed by invisible reference. */
2685 char regparm_letter
;
2686 /* Parm passed in registers and lives in registers or nowhere. */
2688 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2689 if (use_gnu_debug_info_extensions
)
2690 regparm_letter
= GDB_INV_REF_REGPARM_STABS_LETTER
;
2692 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2694 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2695 If it is an unallocated pseudo-reg, then use the register where
2696 it was passed instead. */
2697 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
2698 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
2700 current_sym_value
= REGNO (DECL_INCOMING_RTL (parms
));
2702 current_sym_addr
= 0;
2705 if (DECL_NAME (parms
))
2708 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2710 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2711 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2716 current_sym_nchars
= 8;
2717 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2721 dbxout_type (TREE_TYPE (parms
), 0);
2722 dbxout_finish_symbol (parms
);
2724 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2725 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
2727 /* Parm was passed via invisible reference, with the reference
2728 living on the stack. DECL_RTL looks like
2729 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
2730 could look like (MEM (MEM (REG))). */
2731 const char *const decl_name
= (DECL_NAME (parms
)
2732 ? IDENTIFIER_POINTER (DECL_NAME (parms
))
2734 if (GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 0)) == REG
)
2735 current_sym_value
= 0;
2738 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
2739 current_sym_addr
= 0;
2740 current_sym_code
= N_PSYM
;
2743 fprintf (asmfile
, "%s\"%s:v", ASM_STABS_OP
, decl_name
);
2746 = DEBUGGER_ARG_OFFSET (current_sym_value
,
2747 XEXP (XEXP (DECL_RTL (parms
), 0), 0));
2748 dbxout_type (TREE_TYPE (parms
), 0);
2749 dbxout_finish_symbol (parms
);
2751 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2752 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
2753 /* ??? A constant address for a parm can happen
2754 when the reg it lives in is equiv to a constant in memory.
2755 Should make this not happen, after 2.4. */
2756 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
2758 /* Parm was passed in registers but lives on the stack. */
2760 current_sym_code
= N_PSYM
;
2761 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2762 in which case we want the value of that CONST_INT,
2764 in which case we use a value of zero. */
2765 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
)
2766 current_sym_value
= 0;
2769 = INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
2771 current_sym_addr
= 0;
2773 /* Make a big endian correction if the mode of the type of the
2774 parameter is not the same as the mode of the rtl. */
2775 if (BYTES_BIG_ENDIAN
2776 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
2777 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
2779 current_sym_value
+=
2780 GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
2781 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
)));
2785 if (DECL_NAME (parms
))
2788 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2790 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2791 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2792 DBX_MEMPARM_STABS_LETTER
);
2796 current_sym_nchars
= 8;
2797 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2798 DBX_MEMPARM_STABS_LETTER
);
2802 = DEBUGGER_ARG_OFFSET (current_sym_value
,
2803 XEXP (DECL_RTL (parms
), 0));
2804 dbxout_type (TREE_TYPE (parms
), 0);
2805 dbxout_finish_symbol (parms
);
2810 /* Output definitions for the places where parms live during the function,
2811 when different from where they were passed, when the parms were passed
2814 It is not useful to do this for parms passed in registers
2815 that live during the function in different registers, because it is
2816 impossible to look in the passed register for the passed value,
2817 so we use the within-the-function register to begin with.
2819 PARMS is a chain of PARM_DECL nodes. */
2822 dbxout_reg_parms (parms
)
2825 for (; parms
; parms
= TREE_CHAIN (parms
))
2826 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
2828 dbxout_prepare_symbol (parms
);
2830 /* Report parms that live in registers during the function
2831 but were passed in memory. */
2832 if (GET_CODE (DECL_RTL (parms
)) == REG
2833 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2834 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2835 0, DECL_RTL (parms
));
2836 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
2837 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2838 0, DECL_RTL (parms
));
2839 /* Report parms that live in memory but not where they were passed. */
2840 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2841 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
2842 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2843 0, DECL_RTL (parms
));
2847 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2848 output definitions of those names, in raw form */
2856 putc (',', asmfile
);
2857 dbxout_type (TREE_VALUE (args
), 0);
2859 args
= TREE_CHAIN (args
);
2863 /* Output everything about a symbol block (a BLOCK node
2864 that represents a scope level),
2865 including recursive output of contained blocks.
2867 BLOCK is the BLOCK node.
2868 DEPTH is its depth within containing symbol blocks.
2869 ARGS is usually zero; but for the outermost block of the
2870 body of a function, it is a chain of PARM_DECLs for the function parameters.
2871 We output definitions of all the register parms
2872 as if they were local variables of that block.
2874 If -g1 was used, we count blocks just the same, but output nothing
2875 except for the outermost block.
2877 Actually, BLOCK may be several blocks chained together.
2878 We handle them all in sequence. */
2881 dbxout_block (block
, depth
, args
)
2888 #if DBX_BLOCKS_FUNCTION_RELATIVE
2889 const char *begin_label
;
2890 if (current_function_func_begin_label
!= NULL_TREE
)
2891 begin_label
= IDENTIFIER_POINTER (current_function_func_begin_label
);
2893 begin_label
= XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0);
2898 /* Ignore blocks never expanded or otherwise marked as real. */
2899 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
2903 #ifdef DBX_LBRAC_FIRST
2906 /* In dbx format, the syms of a block come before the N_LBRAC.
2907 If nothing is output, we don't need the N_LBRAC, either. */
2909 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2910 did_output
= dbxout_syms (BLOCK_VARS (block
));
2912 dbxout_reg_parms (args
);
2915 /* Now output an N_LBRAC symbol to represent the beginning of
2916 the block. Use the block's tree-walk order to generate
2917 the assembler symbols LBBn and LBEn
2918 that final will define around the code in this block. */
2919 if (depth
> 0 && did_output
)
2922 blocknum
= BLOCK_NUMBER (block
);
2923 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
2925 if (BLOCK_HANDLER_BLOCK (block
))
2927 /* A catch block. Must precede N_LBRAC. */
2928 tree decl
= BLOCK_VARS (block
);
2931 #ifdef DBX_OUTPUT_CATCH
2932 DBX_OUTPUT_CATCH (asmfile
, decl
, buf
);
2934 fprintf (asmfile
, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP
,
2935 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
2936 assemble_name (asmfile
, buf
);
2937 fprintf (asmfile
, "\n");
2939 decl
= TREE_CHAIN (decl
);
2943 #ifdef DBX_OUTPUT_LBRAC
2944 DBX_OUTPUT_LBRAC (asmfile
, buf
);
2946 fprintf (asmfile
, "%s%d,0,0,", ASM_STABN_OP
, N_LBRAC
);
2947 assemble_name (asmfile
, buf
);
2948 #if DBX_BLOCKS_FUNCTION_RELATIVE
2949 putc ('-', asmfile
);
2950 assemble_name (asmfile
, begin_label
);
2952 fprintf (asmfile
, "\n");
2956 #ifdef DBX_LBRAC_FIRST
2957 /* On some weird machines, the syms of a block
2958 come after the N_LBRAC. */
2959 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2960 dbxout_syms (BLOCK_VARS (block
));
2962 dbxout_reg_parms (args
);
2965 /* Output the subblocks. */
2966 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
2968 /* Refer to the marker for the end of the block. */
2969 if (depth
> 0 && did_output
)
2972 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
2973 #ifdef DBX_OUTPUT_RBRAC
2974 DBX_OUTPUT_RBRAC (asmfile
, buf
);
2976 fprintf (asmfile
, "%s%d,0,0,", ASM_STABN_OP
, N_RBRAC
);
2977 assemble_name (asmfile
, buf
);
2978 #if DBX_BLOCKS_FUNCTION_RELATIVE
2979 putc ('-', asmfile
);
2980 assemble_name (asmfile
, begin_label
);
2982 fprintf (asmfile
, "\n");
2986 block
= BLOCK_CHAIN (block
);
2990 /* Output the information about a function and its arguments and result.
2991 Usually this follows the function's code,
2992 but on some systems, it comes before. */
2994 #if defined (DBX_DEBUGGING_INFO)
2996 dbxout_begin_function (decl
)
2999 dbxout_symbol (decl
, 0);
3000 dbxout_parms (DECL_ARGUMENTS (decl
));
3001 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3002 dbxout_symbol (DECL_RESULT (decl
), 1);
3004 #endif /* DBX_DEBUGGING_INFO */
3006 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */