1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
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. */
87 #ifdef XCOFF_DEBUGGING_INFO
92 #define ASM_STABS_OP "\t.stabs\t"
96 #define ASM_STABN_OP "\t.stabn\t"
99 #ifndef DBX_TYPE_DECL_STABS_CODE
100 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
103 #ifndef DBX_STATIC_CONST_VAR_CODE
104 #define DBX_STATIC_CONST_VAR_CODE N_FUN
107 #ifndef DBX_REGPARM_STABS_CODE
108 #define DBX_REGPARM_STABS_CODE N_RSYM
111 #ifndef DBX_REGPARM_STABS_LETTER
112 #define DBX_REGPARM_STABS_LETTER 'P'
115 /* This is used for parameters passed by invisible reference in a register. */
116 #ifndef GDB_INV_REF_REGPARM_STABS_LETTER
117 #define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
120 #ifndef DBX_MEMPARM_STABS_LETTER
121 #define DBX_MEMPARM_STABS_LETTER 'p'
124 #ifndef FILE_NAME_JOINER
125 #define FILE_NAME_JOINER "/"
128 /* GDB needs to know that the stabs were generated by GCC. We emit an
129 N_OPT stab at the beginning of the source file to indicate this.
130 The string is historical, and different on a very few targets. */
131 #ifndef STABS_GCC_MARKER
132 #define STABS_GCC_MARKER "gcc2_compiled."
135 /* Typical USG systems don't have stab.h, and they also have
136 no use for DBX-format debugging info. */
138 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
140 /* Nonzero if we have actually used any of the GDB extensions
141 to the debugging format. The idea is that we use them for the
142 first time only if there's a strong reason, but once we have done that,
143 we use them whenever convenient. */
145 static int have_used_extensions = 0;
147 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
148 for the N_SO filename stabs label. */
150 static int source_label_number = 1;
152 #ifdef DEBUG_SYMS_TEXT
153 #define FORCE_TEXT text_section ();
160 #define STAB_CODE_TYPE enum __stab_debug_code
162 /* 1 if PARM is passed to this function in memory. */
164 #define PARM_PASSED_IN_MEMORY(PARM) \
165 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
167 /* A C expression for the integer offset value of an automatic variable
168 (N_LSYM) having address X (an RTX). */
169 #ifndef DEBUGGER_AUTO_OFFSET
170 #define DEBUGGER_AUTO_OFFSET(X) \
171 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
174 /* A C expression for the integer offset value of an argument (N_PSYM)
175 having address X (an RTX). The nominal offset is OFFSET. */
176 #ifndef DEBUGGER_ARG_OFFSET
177 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
180 /* Stream for writing to assembler file. */
182 static FILE *asmfile;
184 /* Last source file name mentioned in a NOTE insn. */
186 static const char *lastfile;
188 /* Current working directory. */
190 static const char *cwd;
192 enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
194 /* Structure recording information about a C data type.
195 The status element says whether we have yet output
196 the definition of the type. TYPE_XREF says we have
197 output it as a cross-reference only.
198 The file_number and type_number elements are used if DBX_USE_BINCL
203 enum typestatus status;
210 /* Vector recording information about C data types.
211 When we first notice a data type (a tree node),
212 we assign it a number using next_type_number.
213 That is its index in this vector. */
215 struct typeinfo *typevec;
217 /* Number of elements of space allocated in `typevec'. */
219 static int typevec_len;
221 /* In dbx output, each type gets a unique number.
222 This is the number for the next type output.
223 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
225 static int next_type_number;
229 /* When using N_BINCL in dbx output, each type number is actually a
230 pair of the file number and the type number within the file.
231 This is a stack of input files. */
235 struct dbx_file *next;
237 int next_type_number;
240 /* This is the top of the stack. */
242 static struct dbx_file *current_file;
244 /* This is the next file number to use. */
246 static int next_file_number;
248 #endif /* DBX_USE_BINCL */
250 /* These variables are for dbxout_symbol to communicate to
251 dbxout_finish_symbol.
252 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
253 current_sym_value and current_sym_addr are two ways to address the
254 value to store in the symtab entry.
255 current_sym_addr if nonzero represents the value as an rtx.
256 If that is zero, current_sym_value is used. This is used
257 when the value is an offset (such as for auto variables,
258 register variables and parms). */
260 static STAB_CODE_TYPE current_sym_code;
261 static int current_sym_value;
262 static rtx current_sym_addr;
264 /* Number of chars of symbol-description generated so far for the
265 current symbol. Used by CHARS and CONTIN. */
267 static int current_sym_nchars;
269 /* Report having output N chars of the current symbol-description. */
271 #define CHARS(N) (current_sym_nchars += (N))
273 /* Break the current symbol-description, generating a continuation,
274 if it has become long. */
276 #ifndef DBX_CONTIN_LENGTH
277 #define DBX_CONTIN_LENGTH 80
280 #if DBX_CONTIN_LENGTH > 0
282 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
284 #define CONTIN do { } while (0)
287 static void dbxout_init PARAMS ((const char *));
288 static void dbxout_finish PARAMS ((const char *));
289 static void dbxout_start_source_file PARAMS ((unsigned, const char *));
290 static void dbxout_end_source_file PARAMS ((unsigned));
291 static void dbxout_source_line PARAMS ((unsigned int, const char *));
292 static void dbxout_source_file PARAMS ((FILE *, const char *));
293 #if defined(ASM_OUTPUT_SECTION_NAME)
294 static void dbxout_function_end PARAMS ((void));
296 static void dbxout_typedefs PARAMS ((tree));
297 static void dbxout_type_index PARAMS ((tree));
298 #if DBX_CONTIN_LENGTH > 0
299 static void dbxout_continue PARAMS ((void));
301 static void dbxout_args PARAMS ((tree));
302 static void dbxout_type_fields PARAMS ((tree));
303 static void dbxout_type_method_1 PARAMS ((tree, const char *));
304 static void dbxout_type_methods PARAMS ((tree));
305 static void dbxout_range_type PARAMS ((tree));
306 static void dbxout_type PARAMS ((tree, int));
307 static void print_int_cst_octal PARAMS ((tree));
308 static void print_octal PARAMS ((unsigned HOST_WIDE_INT, int));
309 static void dbxout_type_name PARAMS ((tree));
310 static int dbxout_symbol_location PARAMS ((tree, tree, const char *, rtx));
311 static void dbxout_symbol_name PARAMS ((tree, const char *, int));
312 static void dbxout_prepare_symbol PARAMS ((tree));
313 static void dbxout_finish_symbol PARAMS ((tree));
314 static void dbxout_block PARAMS ((tree, int, tree));
315 static void dbxout_begin_function PARAMS ((tree));
316 static void dbxout_global_decl PARAMS ((tree));
318 /* The debug hooks structure. */
319 #if defined (DBX_DEBUGGING_INFO)
321 static void dbxout_begin_block PARAMS ((unsigned, unsigned));
322 static void dbxout_end_block PARAMS ((unsigned, unsigned));
323 static void dbxout_function_decl PARAMS ((tree));
325 struct gcc_debug_hooks dbx_debug_hooks =
329 debug_nothing_int_charstar,
330 debug_nothing_int_charstar,
331 dbxout_start_source_file,
332 dbxout_end_source_file,
335 debug_true_tree, /* ignore_block */
336 dbxout_source_line, /* source_line */
337 dbxout_source_line, /* begin_prologue: just output line info */
338 debug_nothing_int, /* end_prologue */
339 debug_nothing_void, /* end_epilogue */
340 #ifdef DBX_FUNCTION_FIRST
341 dbxout_begin_function,
343 debug_nothing_tree, /* begin_function */
345 debug_nothing_int, /* end_function */
346 dbxout_function_decl,
347 dbxout_global_decl, /* global_decl */
348 debug_nothing_tree, /* deferred_inline_function */
349 debug_nothing_tree, /* outlining_inline_function */
350 debug_nothing_rtx /* label */
352 #endif /* DBX_DEBUGGING_INFO */
354 #if defined (XCOFF_DEBUGGING_INFO)
355 struct gcc_debug_hooks xcoff_debug_hooks =
359 debug_nothing_int_charstar,
360 debug_nothing_int_charstar,
361 dbxout_start_source_file,
362 dbxout_end_source_file,
363 xcoffout_begin_block,
365 debug_true_tree, /* ignore_block */
366 xcoffout_source_line,
367 xcoffout_begin_prologue, /* begin_prologue */
368 debug_nothing_int, /* end_prologue */
369 xcoffout_end_epilogue,
370 debug_nothing_tree, /* begin_function */
371 xcoffout_end_function,
372 debug_nothing_tree, /* function_decl */
373 dbxout_global_decl, /* global_decl */
374 debug_nothing_tree, /* deferred_inline_function */
375 debug_nothing_tree, /* outlining_inline_function */
376 debug_nothing_rtx /* label */
378 #endif /* XCOFF_DEBUGGING_INFO */
380 #if defined(ASM_OUTPUT_SECTION_NAME)
382 dbxout_function_end ()
384 static int scope_labelno = 0;
385 char lscope_label_name[100];
386 /* Convert Ltext into the appropriate format for local labels in case
387 the system doesn't insert underscores in front of user generated
389 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
390 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Lscope", scope_labelno);
393 /* By convention, GCC will mark the end of a function with an N_FUN
394 symbol and an empty string. */
395 fprintf (asmfile, "%s\"\",%d,0,0,", ASM_STABS_OP, N_FUN);
396 assemble_name (asmfile, lscope_label_name);
397 fputc ('-', asmfile);
398 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
399 fprintf (asmfile, "\n");
401 #endif /* ! NO_DBX_FUNCTION_END */
403 /* At the beginning of compilation, start writing the symbol table.
404 Initialize `typevec' and output the standard data types of C. */
407 dbxout_init (input_file_name)
408 const char *input_file_name;
410 char ltext_label_name[100];
411 tree syms = getdecls ();
413 asmfile = asm_out_file;
416 typevec = (struct typeinfo *) xcalloc (typevec_len, sizeof typevec[0]);
418 /* Convert Ltext into the appropriate format for local labels in case
419 the system doesn't insert underscores in front of user generated
421 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
423 /* Put the current working directory in an N_SO symbol. */
424 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
425 but GDB always does. */
426 if (use_gnu_debug_info_extensions)
429 if (!cwd && (cwd = getpwd ()) && (!*cwd || cwd[strlen (cwd) - 1] != '/'))
430 cwd = concat (cwd, FILE_NAME_JOINER, NULL);
433 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
434 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd);
435 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
436 fprintf (asmfile, "%s", ASM_STABS_OP);
437 output_quoted_string (asmfile, cwd);
438 fprintf (asmfile, ",%d,0,0,%s\n", N_SO, <ext_label_name[1]);
439 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
443 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
444 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
445 would give us an N_SOL, and we want an N_SO. */
446 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile, input_file_name);
447 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
448 /* We include outputting `Ltext:' here,
449 because that gives you a way to override it. */
450 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
451 fprintf (asmfile, "%s", ASM_STABS_OP);
452 output_quoted_string (asmfile, input_file_name);
453 fprintf (asmfile, ",%d,0,0,%s\n",
454 N_SO, <ext_label_name[1]);
456 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Ltext", 0);
457 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
459 #ifdef DBX_OUTPUT_GCC_MARKER
460 DBX_OUTPUT_GCC_MARKER (asmfile);
462 /* Emit an N_OPT stab to indicate that this file was compiled by GCC. */
463 fprintf (asmfile, "%s\"%s\",%d,0,0,0\n",
464 ASM_STABS_OP, STABS_GCC_MARKER, N_OPT);
467 lastfile = input_file_name;
469 next_type_number = 1;
472 current_file = (struct dbx_file *) xmalloc (sizeof *current_file);
473 current_file->next = NULL;
474 current_file->file_number = 0;
475 current_file->next_type_number = 1;
476 next_file_number = 1;
479 /* Make sure that types `int' and `char' have numbers 1 and 2.
480 Definitions of other integer types will refer to those numbers.
481 (Actually it should no longer matter what their numbers are.
482 Also, if any types with tags have been defined, dbxout_symbol
483 will output them first, so the numbers won't be 1 and 2. That
484 happens in C++. So it's a good thing it should no longer matter). */
486 #ifdef DBX_OUTPUT_STANDARD_TYPES
487 DBX_OUTPUT_STANDARD_TYPES (syms);
489 dbxout_symbol (TYPE_NAME (integer_type_node), 0);
490 dbxout_symbol (TYPE_NAME (char_type_node), 0);
493 /* Get all permanent types that have typedef names,
494 and output them all, except for those already output. */
496 dbxout_typedefs (syms);
499 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
500 in the reverse order from that which is found in SYMS. */
503 dbxout_typedefs (syms)
508 dbxout_typedefs (TREE_CHAIN (syms));
509 if (TREE_CODE (syms) == TYPE_DECL)
511 tree type = TREE_TYPE (syms);
513 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
514 && COMPLETE_TYPE_P (type)
515 && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
516 dbxout_symbol (TYPE_NAME (type), 0);
521 /* Change to reading from a new source file. Generate a N_BINCL stab. */
524 dbxout_start_source_file (line, filename)
525 unsigned int line ATTRIBUTE_UNUSED;
526 const char *filename ATTRIBUTE_UNUSED;
529 struct dbx_file *n = (struct dbx_file *) xmalloc (sizeof *n);
531 n->next = current_file;
532 n->file_number = next_file_number++;
533 n->next_type_number = 1;
535 fprintf (asmfile, "%s", ASM_STABS_OP);
536 output_quoted_string (asmfile, filename);
537 fprintf (asmfile, ",%d,0,0,0\n", N_BINCL);
541 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
544 dbxout_end_source_file (line)
545 unsigned int line ATTRIBUTE_UNUSED;
548 struct dbx_file *next;
550 fprintf (asmfile, "%s%d,0,0,0\n", ASM_STABN_OP, N_EINCL);
551 next = current_file->next;
557 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
560 dbxout_source_file (file, filename)
562 const char *filename;
564 char ltext_label_name[100];
566 if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
568 #ifdef DBX_OUTPUT_SOURCE_FILENAME
569 DBX_OUTPUT_SOURCE_FILENAME (file, filename);
571 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext",
572 source_label_number);
573 fprintf (file, "%s", ASM_STABS_OP);
574 output_quoted_string (file, filename);
575 fprintf (file, ",%d,0,0,%s\n", N_SOL, <ext_label_name[1]);
576 if (current_function_decl != NULL_TREE
577 && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
578 ; /* Don't change section amid function. */
581 ASM_OUTPUT_INTERNAL_LABEL (file, "Ltext", source_label_number);
582 source_label_number++;
588 /* Output a line number symbol entry for source file FILENAME and line
592 dbxout_source_line (lineno, filename)
594 const char *filename;
596 dbxout_source_file (asmfile, filename);
598 #ifdef ASM_OUTPUT_SOURCE_LINE
599 ASM_OUTPUT_SOURCE_LINE (asmfile, lineno);
601 fprintf (asmfile, "%s%d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno);
605 #if defined (DBX_DEBUGGING_INFO)
607 /* Describe the beginning of an internal block within a function. */
610 dbxout_begin_block (line, n)
611 unsigned int line ATTRIBUTE_UNUSED;
614 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "LBB", n);
617 /* Describe the end line-number of an internal block within a function. */
620 dbxout_end_block (line, n)
621 unsigned int line ATTRIBUTE_UNUSED;
624 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "LBE", n);
627 /* Debug information for a global DECL. Called from toplev.c after
628 compilation proper has finished. */
630 dbxout_global_decl (decl)
633 if (TREE_CODE (decl) == VAR_DECL
634 && ! DECL_EXTERNAL (decl)
635 && DECL_RTL_SET_P (decl)) /* Not necessary? */
636 dbxout_symbol (decl, 0);
639 /* Output dbx data for a function definition.
640 This includes a definition of the function name itself (a symbol),
641 definitions of the parameters (locating them in the parameter list)
642 and then output the block that makes up the function's body
643 (including all the auto variables of the function). */
646 dbxout_function_decl (decl)
649 #ifndef DBX_FUNCTION_FIRST
650 dbxout_begin_function (decl);
652 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
653 #ifdef DBX_OUTPUT_FUNCTION_END
654 DBX_OUTPUT_FUNCTION_END (asmfile, decl);
656 #if defined(ASM_OUTPUT_SECTION_NAME)
657 if (use_gnu_debug_info_extensions
658 #if defined(NO_DBX_FUNCTION_END)
659 && ! NO_DBX_FUNCTION_END
662 dbxout_function_end ();
666 #endif /* DBX_DEBUGGING_INFO */
668 /* At the end of compilation, finish writing the symbol table.
669 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
673 dbxout_finish (filename)
674 const char *filename ATTRIBUTE_UNUSED;
676 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
677 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asmfile, filename);
678 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
681 /* Output the index of a type. */
684 dbxout_type_index (type)
687 #ifndef DBX_USE_BINCL
688 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
691 struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
692 fprintf (asmfile, "(%d,%d)", t->file_number, t->type_number);
697 #if DBX_CONTIN_LENGTH > 0
698 /* Continue a symbol-description that gets too big.
699 End one symbol table entry with a double-backslash
700 and start a new one, eventually producing something like
701 .stabs "start......\\",code,0,value
702 .stabs "...rest",code,0,value */
707 #ifdef DBX_CONTIN_CHAR
708 fprintf (asmfile, "%c", DBX_CONTIN_CHAR);
710 fprintf (asmfile, "\\\\");
712 dbxout_finish_symbol (NULL_TREE);
713 fprintf (asmfile, "%s\"", ASM_STABS_OP);
714 current_sym_nchars = 0;
716 #endif /* DBX_CONTIN_LENGTH > 0 */
718 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
719 This must be a separate function because anonymous unions require
723 dbxout_type_fields (type)
728 /* Output the name, type, position (in bits), size (in bits) of each
729 field that we can support. */
730 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
732 /* Omit here local type decls until we know how to support them. */
733 if (TREE_CODE (tem) == TYPE_DECL
734 /* Omit fields whose position or size are variable or too large to
736 || (TREE_CODE (tem) == FIELD_DECL
737 && (! host_integerp (bit_position (tem), 0)
739 || ! host_integerp (DECL_SIZE (tem), 1)))
740 /* Omit here the nameless fields that are used to skip bits. */
741 || DECL_IGNORED_P (tem))
744 else if (TREE_CODE (tem) != CONST_DECL)
746 /* Continue the line if necessary,
747 but not before the first field. */
748 if (tem != TYPE_FIELDS (type))
753 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
754 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem)));
758 fprintf (asmfile, ":");
762 if (use_gnu_debug_info_extensions
763 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
764 || TREE_CODE (tem) != FIELD_DECL))
766 have_used_extensions = 1;
768 putc ((TREE_PRIVATE (tem) ? '0'
769 : TREE_PROTECTED (tem) ? '1' : '2'),
774 dbxout_type ((TREE_CODE (tem) == FIELD_DECL
775 && DECL_BIT_FIELD_TYPE (tem))
776 ? DECL_BIT_FIELD_TYPE (tem) : TREE_TYPE (tem), 0);
778 if (TREE_CODE (tem) == VAR_DECL)
780 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
783 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem));
784 have_used_extensions = 1;
785 fprintf (asmfile, ":%s;", name);
786 CHARS (strlen (name));
789 /* If TEM is non-static, GDB won't understand it. */
790 fprintf (asmfile, ",0,0;");
794 fputc (',', asmfile);
795 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
796 int_bit_position (tem));
797 fputc (',', asmfile);
798 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
799 tree_low_cst (DECL_SIZE (tem), 1));
800 fputc (';', asmfile);
807 /* Subroutine of `dbxout_type_methods'. Output debug info about the
808 method described DECL. DEBUG_NAME is an encoding of the method's
809 type signature. ??? We may be able to do without DEBUG_NAME altogether
813 dbxout_type_method_1 (decl, debug_name)
815 const char *debug_name;
819 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
821 else /* it's a METHOD_TYPE. */
823 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
824 /* A for normal functions.
825 B for `const' member functions.
826 C for `volatile' member functions.
827 D for `const volatile' member functions. */
828 if (TYPE_READONLY (TREE_TYPE (firstarg)))
830 if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
833 if (DECL_VINDEX (decl))
839 fprintf (asmfile, ":%s;%c%c%c", debug_name,
840 TREE_PRIVATE (decl) ? '0'
841 : TREE_PROTECTED (decl) ? '1' : '2', c1, c2);
842 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)) + 6
843 - (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
845 if (DECL_VINDEX (decl) && host_integerp (DECL_VINDEX (decl), 0))
847 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
848 tree_low_cst (DECL_VINDEX (decl), 0));
849 fputc (';', asmfile);
850 dbxout_type (DECL_CONTEXT (decl), 0);
851 fprintf (asmfile, ";");
856 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
860 dbxout_type_methods (type)
863 /* C++: put out the method names and their parameter lists */
864 tree methods = TYPE_METHODS (type);
866 register tree fndecl;
868 char formatted_type_identifier_length[16];
869 register int type_identifier_length;
871 if (methods == NULL_TREE)
874 type_encoding = DECL_NAME (TYPE_NAME (type));
877 /* C++: Template classes break some assumptions made by this code about
878 the class names, constructor names, and encodings for assembler
879 label names. For now, disable output of dbx info for them. */
881 const char *ptr = IDENTIFIER_POINTER (type_encoding);
882 /* This should use index. (mrs) */
883 while (*ptr && *ptr != '<') ptr++;
894 type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
896 sprintf (formatted_type_identifier_length, "%d", type_identifier_length);
898 if (TREE_CODE (methods) != TREE_VEC)
900 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
901 fndecl = TREE_VEC_ELT (methods, 0);
903 fndecl = TREE_VEC_ELT (methods, 1);
909 /* Group together all the methods for the same operation.
910 These differ in the types of the arguments. */
911 for (last = NULL_TREE;
912 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
913 fndecl = TREE_CHAIN (fndecl))
914 /* Output the name of the field (after overloading), as
915 well as the name of the field before overloading, along
916 with its parameter list */
918 /* This is the "mangled" name of the method.
919 It encodes the argument types. */
920 const char *debug_name;
922 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
923 include TEMPLATE_DECLs.) The debugger doesn't know what
924 to do with such entities anyhow. */
925 if (TREE_CODE (fndecl) != FUNCTION_DECL)
929 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
935 /* Also ignore abstract methods; those are only interesting to
936 the DWARF backends. */
937 if (DECL_IGNORED_P (fndecl) || DECL_ABSTRACT (fndecl))
940 /* Redundantly output the plain name, since that's what gdb
944 tree name = DECL_NAME (fndecl);
945 fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
946 CHARS (IDENTIFIER_LENGTH (name) + 2);
950 dbxout_type (TREE_TYPE (fndecl), 0);
952 dbxout_type_method_1 (fndecl, debug_name);
962 /* Emit a "range" type specification, which has the form:
963 "r<index type>;<lower bound>;<upper bound>;".
964 TYPE is an INTEGER_TYPE. */
967 dbxout_range_type (type)
970 fprintf (asmfile, "r");
971 if (TREE_TYPE (type))
972 dbxout_type (TREE_TYPE (type), 0);
973 else if (TREE_CODE (type) != INTEGER_TYPE)
974 dbxout_type (type, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
977 /* Traditionally, we made sure 'int' was type 1, and builtin types
978 were defined to be sub-ranges of int. Unfortunately, this
979 does not allow us to distinguish true sub-ranges from integer
980 types. So, instead we define integer (non-sub-range) types as
981 sub-ranges of themselves. This matters for Chill. If this isn't
982 a subrange type, then we want to define it in terms of itself.
983 However, in C, this may be an anonymous integer type, and we don't
984 want to emit debug info referring to it. Just calling
985 dbxout_type_index won't work anyways, because the type hasn't been
986 defined yet. We make this work for both cases by checked to see
987 whether this is a defined type, referring to it if it is, and using
989 if (TYPE_SYMTAB_ADDRESS (type) != 0)
990 dbxout_type_index (type);
992 dbxout_type_index (integer_type_node);
995 if (TYPE_MIN_VALUE (type) != 0
996 && host_integerp (TYPE_MIN_VALUE (type), 0))
998 fputc (';', asmfile);
999 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1000 tree_low_cst (TYPE_MIN_VALUE (type), 0));
1003 fprintf (asmfile, ";0");
1005 if (TYPE_MAX_VALUE (type) != 0
1006 && host_integerp (TYPE_MAX_VALUE (type), 0))
1008 fputc (';', asmfile);
1009 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1010 tree_low_cst (TYPE_MAX_VALUE (type), 0));
1011 fputc (';', asmfile);
1014 fprintf (asmfile, ";-1;");
1017 /* Output a reference to a type. If the type has not yet been
1018 described in the dbx output, output its definition now.
1019 For a type already defined, just refer to its definition
1020 using the type number.
1022 If FULL is nonzero, and the type has been described only with
1023 a forward-reference, output the definition now.
1024 If FULL is zero in this case, just refer to the forward-reference
1025 using the number previously allocated. */
1028 dbxout_type (type, full)
1033 static int anonymous_type_number = 0;
1035 if (TREE_CODE (type) == VECTOR_TYPE)
1036 type = TYPE_DEBUG_REPRESENTATION_TYPE (type);
1038 /* If there was an input error and we don't really have a type,
1039 avoid crashing and write something that is at least valid
1040 by assuming `int'. */
1041 if (type == error_mark_node)
1042 type = integer_type_node;
1045 /* Try to find the "main variant" with the same name but not const
1046 or volatile. (Since stabs does not distinguish const and volatile,
1047 there is no need to make them separate types. But types with
1048 different names are usefully distinguished.) */
1050 for (tem = TYPE_MAIN_VARIANT (type); tem; tem = TYPE_NEXT_VARIANT (tem))
1051 if (!TYPE_READONLY (tem) && !TYPE_VOLATILE (tem)
1052 && TYPE_NAME (tem) == TYPE_NAME (type))
1057 if (TYPE_NAME (type)
1058 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1059 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
1063 if (TYPE_SYMTAB_ADDRESS (type) == 0)
1065 /* Type has no dbx number assigned. Assign next available number. */
1066 TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
1068 /* Make sure type vector is long enough to record about this type. */
1070 if (next_type_number == typevec_len)
1073 = (struct typeinfo *) xrealloc (typevec,
1074 typevec_len * 2 * sizeof typevec[0]);
1075 memset ((char *) (typevec + typevec_len), 0,
1076 typevec_len * sizeof typevec[0]);
1080 #ifdef DBX_USE_BINCL
1081 typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
1082 = current_file->file_number;
1083 typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
1084 = current_file->next_type_number++;
1088 /* Output the number of this type, to refer to it. */
1089 dbxout_type_index (type);
1091 #ifdef DBX_TYPE_DEFINED
1092 if (DBX_TYPE_DEFINED (type))
1096 /* If this type's definition has been output or is now being output,
1099 switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
1104 /* If we have already had a cross reference,
1105 and either that's all we want or that's the best we could do,
1106 don't repeat the cross reference.
1107 Sun dbx crashes if we do. */
1108 if (! full || !COMPLETE_TYPE_P (type)
1109 /* No way in DBX fmt to describe a variable size. */
1110 || ! host_integerp (TYPE_SIZE (type), 1))
1118 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1119 leave the type-number completely undefined rather than output
1120 a cross-reference. If we have already used GNU debug info extensions,
1121 then it is OK to output a cross reference. This is necessary to get
1122 proper C++ debug output. */
1123 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
1124 || TREE_CODE (type) == QUAL_UNION_TYPE
1125 || TREE_CODE (type) == ENUMERAL_TYPE)
1126 && ! use_gnu_debug_info_extensions)
1127 /* We must use the same test here as we use twice below when deciding
1128 whether to emit a cross-reference. */
1129 if ((TYPE_NAME (type) != 0
1130 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1131 && DECL_IGNORED_P (TYPE_NAME (type)))
1133 || !COMPLETE_TYPE_P (type)
1134 /* No way in DBX fmt to describe a variable size. */
1135 || ! host_integerp (TYPE_SIZE (type), 1))
1137 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1142 /* Output a definition now. */
1144 fprintf (asmfile, "=");
1147 /* Mark it as defined, so that if it is self-referent
1148 we will not get into an infinite recursion of definitions. */
1150 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
1152 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1153 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1155 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0);
1159 switch (TREE_CODE (type))
1163 /* For a void type, just define it as itself; ie, "5=5".
1164 This makes us consider it defined
1165 without saying what it is. The debugger will make it
1166 a void type when the reference is seen, and nothing will
1167 ever override that default. */
1168 dbxout_type_index (type);
1172 if (type == char_type_node && ! TREE_UNSIGNED (type))
1174 /* Output the type `char' as a subrange of itself!
1175 I don't understand this definition, just copied it
1176 from the output of pcc.
1177 This used to use `r2' explicitly and we used to
1178 take care to make sure that `char' was type number 2. */
1179 fprintf (asmfile, "r");
1180 dbxout_type_index (type);
1181 fprintf (asmfile, ";0;127;");
1184 /* If this is a subtype of another integer type, always prefer to
1185 write it as a subtype. */
1186 else if (TREE_TYPE (type) != 0
1187 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
1188 dbxout_range_type (type);
1192 /* If the size is non-standard, say what it is if we can use
1195 if (use_gnu_debug_info_extensions
1196 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1197 fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1199 /* If we can use GDB extensions and the size is wider than a
1200 long (the size used by GDB to read them) or we may have
1201 trouble writing the bounds the usual way, write them in
1202 octal. Note the test is for the *target's* size of "long",
1203 not that of the host. The host test is just to make sure we
1204 can write it out in case the host wide int is narrower than the
1207 /* For unsigned types, we use octal if they are the same size or
1208 larger. This is because we print the bounds as signed decimal,
1209 and hence they can't span same size unsigned types. */
1211 if (use_gnu_debug_info_extensions
1212 && TYPE_MIN_VALUE (type) != 0
1213 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
1214 && TYPE_MAX_VALUE (type) != 0
1215 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
1216 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
1217 || ((TYPE_PRECISION (type)
1218 == TYPE_PRECISION (integer_type_node))
1219 && TREE_UNSIGNED (type))
1220 || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
1221 || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
1222 && TREE_UNSIGNED (type))))
1224 fprintf (asmfile, "r");
1225 dbxout_type_index (type);
1226 fprintf (asmfile, ";");
1227 print_int_cst_octal (TYPE_MIN_VALUE (type));
1228 fprintf (asmfile, ";");
1229 print_int_cst_octal (TYPE_MAX_VALUE (type));
1230 fprintf (asmfile, ";");
1234 /* Output other integer types as subranges of `int'. */
1235 dbxout_range_type (type);
1242 /* This used to say `r1' and we used to take care
1243 to make sure that `int' was type number 1. */
1244 fprintf (asmfile, "r");
1245 dbxout_type_index (integer_type_node);
1246 fputc (';', asmfile);
1247 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, int_size_in_bytes (type));
1248 fputs (";0;", asmfile);
1253 if (use_gnu_debug_info_extensions)
1255 fputs ("@s", asmfile);
1256 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1257 BITS_PER_UNIT * int_size_in_bytes (type));
1258 fputs (";-20;", asmfile);
1262 /* Output the type `char' as a subrange of itself.
1263 That is what pcc seems to do. */
1264 fprintf (asmfile, "r");
1265 dbxout_type_index (char_type_node);
1266 fprintf (asmfile, ";0;%d;", TREE_UNSIGNED (type) ? 255 : 127);
1272 if (use_gnu_debug_info_extensions)
1274 fputs ("@s", asmfile);
1275 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1276 BITS_PER_UNIT * int_size_in_bytes (type));
1277 fputs (";-16;", asmfile);
1279 else /* Define as enumeral type (False, True) */
1280 fprintf (asmfile, "eFalse:0,True:1,;");
1285 putc ('d', asmfile);
1287 dbxout_type (TREE_TYPE (type), 0);
1291 /* Differs from the REAL_TYPE by its new data type number */
1293 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1295 fprintf (asmfile, "r");
1296 dbxout_type_index (type);
1297 fputc (';', asmfile);
1298 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1299 2 * int_size_in_bytes (TREE_TYPE (type)));
1300 fputs (";0;", asmfile);
1301 CHARS (12); /* The number is probably incorrect here. */
1305 /* Output a complex integer type as a structure,
1306 pending some other way to do it. */
1307 fputc ('s', asmfile);
1308 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, int_size_in_bytes (type));
1310 fprintf (asmfile, "real:");
1312 dbxout_type (TREE_TYPE (type), 0);
1313 fprintf (asmfile, ",%d,%d;",
1314 0, TYPE_PRECISION (TREE_TYPE (type)));
1316 fprintf (asmfile, "imag:");
1318 dbxout_type (TREE_TYPE (type), 0);
1319 fprintf (asmfile, ",%d,%d;;",
1320 TYPE_PRECISION (TREE_TYPE (type)),
1321 TYPE_PRECISION (TREE_TYPE (type)));
1327 if (use_gnu_debug_info_extensions)
1329 have_used_extensions = 1;
1330 fputs ("@s", asmfile);
1331 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1332 BITS_PER_UNIT * int_size_in_bytes (type));
1333 fputc (';', asmfile);
1334 /* Check if a bitstring type, which in Chill is
1335 different from a [power]set. */
1336 if (TYPE_STRING_FLAG (type))
1337 fprintf (asmfile, "@S;");
1339 putc ('S', asmfile);
1341 dbxout_type (TYPE_DOMAIN (type), 0);
1345 /* Make arrays of packed bits look like bitstrings for chill. */
1346 if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
1348 have_used_extensions = 1;
1349 fputs ("@s", asmfile);
1350 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1351 BITS_PER_UNIT * int_size_in_bytes (type));
1352 fputc (';', asmfile);
1353 fprintf (asmfile, "@S;");
1354 putc ('S', asmfile);
1356 dbxout_type (TYPE_DOMAIN (type), 0);
1359 /* Output "a" followed by a range type definition
1360 for the index type of the array
1361 followed by a reference to the target-type.
1362 ar1;0;N;M for a C array of type M and size N+1. */
1363 /* Check if a character string type, which in Chill is
1364 different from an array of characters. */
1365 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
1367 have_used_extensions = 1;
1368 fprintf (asmfile, "@S;");
1370 tem = TYPE_DOMAIN (type);
1373 fprintf (asmfile, "ar");
1374 dbxout_type_index (integer_type_node);
1375 fprintf (asmfile, ";0;-1;");
1379 fprintf (asmfile, "a");
1380 dbxout_range_type (tem);
1383 dbxout_type (TREE_TYPE (type), 0);
1388 case QUAL_UNION_TYPE:
1390 int i, n_baseclasses = 0;
1392 if (TYPE_BINFO (type) != 0
1393 && TREE_CODE (TYPE_BINFO (type)) == TREE_VEC
1394 && TYPE_BINFO_BASETYPES (type) != 0)
1395 n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
1397 /* Output a structure type. We must use the same test here as we
1398 use in the DBX_NO_XREFS case above. */
1399 if ((TYPE_NAME (type) != 0
1400 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1401 && DECL_IGNORED_P (TYPE_NAME (type)))
1403 || !COMPLETE_TYPE_P (type)
1404 /* No way in DBX fmt to describe a variable size. */
1405 || ! host_integerp (TYPE_SIZE (type), 1))
1407 /* If the type is just a cross reference, output one
1408 and mark the type as partially described.
1409 If it later becomes defined, we will output
1410 its real definition.
1411 If the type has a name, don't nest its definition within
1412 another type's definition; instead, output an xref
1413 and let the definition come when the name is defined. */
1414 fputs ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu", asmfile);
1416 #if 0 /* This assertion is legitimately false in C++. */
1417 /* We shouldn't be outputting a reference to a type before its
1418 definition unless the type has a tag name.
1419 A typedef name without a tag name should be impossible. */
1420 if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
1423 if (TYPE_NAME (type) != 0)
1424 dbxout_type_name (type);
1426 fprintf (asmfile, "$$%d", anonymous_type_number++);
1427 fprintf (asmfile, ":");
1428 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1432 /* Identify record or union, and print its size. */
1433 fputc (((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'), asmfile);
1434 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1435 int_size_in_bytes (type));
1437 if (use_gnu_debug_info_extensions)
1441 have_used_extensions = 1;
1442 fprintf (asmfile, "!%d,", n_baseclasses);
1446 for (i = 0; i < n_baseclasses; i++)
1448 tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i);
1450 if (use_gnu_debug_info_extensions)
1452 have_used_extensions = 1;
1453 putc (TREE_VIA_VIRTUAL (child) ? '1' : '0', asmfile);
1454 putc (TREE_VIA_PUBLIC (child) ? '2' : '0', asmfile);
1455 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1456 (tree_low_cst (BINFO_OFFSET (child), 0)
1458 fputc (',', asmfile);
1460 dbxout_type (BINFO_TYPE (child), 0);
1461 putc (';', asmfile);
1465 /* Print out the base class information with fields
1466 which have the same names at the types they hold. */
1467 dbxout_type_name (BINFO_TYPE (child));
1468 putc (':', asmfile);
1469 dbxout_type (BINFO_TYPE (child), full);
1470 fputc (',', asmfile);
1471 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1472 tree_low_cst (BINFO_OFFSET (child), 0)
1474 fputc (',', asmfile);
1475 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1476 (tree_low_cst (DECL_SIZE (TYPE_NAME
1477 (BINFO_TYPE (child))), 0)
1479 fputc (';', asmfile);
1487 /* Write out the field declarations. */
1488 dbxout_type_fields (type);
1489 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
1491 have_used_extensions = 1;
1492 dbxout_type_methods (type);
1495 putc (';', asmfile);
1497 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
1498 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1499 && TYPE_VFIELD (type))
1501 have_used_extensions = 1;
1503 /* Tell GDB+ that it may keep reading. */
1504 putc ('~', asmfile);
1506 /* We need to write out info about what field this class
1507 uses as its "main" vtable pointer field, because if this
1508 field is inherited from a base class, GDB cannot necessarily
1509 figure out which field it's using in time. */
1510 if (TYPE_VFIELD (type))
1512 putc ('%', asmfile);
1513 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
1515 putc (';', asmfile);
1521 /* We must use the same test here as we use in the DBX_NO_XREFS case
1522 above. We simplify it a bit since an enum will never have a variable
1524 if ((TYPE_NAME (type) != 0
1525 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1526 && DECL_IGNORED_P (TYPE_NAME (type)))
1528 || !COMPLETE_TYPE_P (type))
1530 fprintf (asmfile, "xe");
1532 dbxout_type_name (type);
1533 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1534 fprintf (asmfile, ":");
1537 #ifdef DBX_OUTPUT_ENUM
1538 DBX_OUTPUT_ENUM (asmfile, type);
1540 if (use_gnu_debug_info_extensions
1541 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1542 fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1543 putc ('e', asmfile);
1545 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
1547 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1548 if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
1549 fprintf (asmfile, HOST_WIDE_INT_PRINT_UNSIGNED,
1550 TREE_INT_CST_LOW (TREE_VALUE (tem)));
1551 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
1552 && (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
1553 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1554 TREE_INT_CST_LOW (TREE_VALUE (tem)));
1556 print_int_cst_octal (TREE_VALUE (tem));
1557 fprintf (asmfile, ",");
1558 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem)));
1559 if (TREE_CHAIN (tem) != 0)
1564 putc (';', asmfile);
1570 putc ('*', asmfile);
1572 dbxout_type (TREE_TYPE (type), 0);
1576 if (use_gnu_debug_info_extensions)
1578 have_used_extensions = 1;
1579 putc ('#', asmfile);
1582 /* Write the argument types out longhand. */
1583 dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
1584 putc (',', asmfile);
1586 dbxout_type (TREE_TYPE (type), 0);
1587 dbxout_args (TYPE_ARG_TYPES (type));
1588 putc (';', asmfile);
1593 /* Treat it as a function type. */
1594 dbxout_type (TREE_TYPE (type), 0);
1599 if (use_gnu_debug_info_extensions)
1601 have_used_extensions = 1;
1602 putc ('@', asmfile);
1604 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
1605 putc (',', asmfile);
1607 dbxout_type (TREE_TYPE (type), 0);
1611 /* Should print as an int, because it is really
1613 dbxout_type (integer_type_node, 0);
1617 case REFERENCE_TYPE:
1618 if (use_gnu_debug_info_extensions)
1619 have_used_extensions = 1;
1620 putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
1622 dbxout_type (TREE_TYPE (type), 0);
1626 putc ('f', asmfile);
1628 dbxout_type (TREE_TYPE (type), 0);
1636 /* Print the value of integer constant C, in octal,
1637 handling double precision. */
1640 print_int_cst_octal (c)
1643 unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
1644 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
1645 int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
1646 unsigned int width = TYPE_PRECISION (TREE_TYPE (c));
1648 /* GDB wants constants with no extra leading "1" bits, so
1649 we need to remove any sign-extension that might be
1651 if (width == HOST_BITS_PER_WIDE_INT * 2)
1653 else if (width > HOST_BITS_PER_WIDE_INT)
1654 high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
1655 else if (width == HOST_BITS_PER_WIDE_INT)
1658 high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
1660 fprintf (asmfile, "0");
1664 print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
1665 print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
1669 unsigned HOST_WIDE_INT beg = high >> excess;
1670 unsigned HOST_WIDE_INT middle
1671 = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
1672 | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
1673 unsigned HOST_WIDE_INT end
1674 = low & (((unsigned HOST_WIDE_INT) 1
1675 << (HOST_BITS_PER_WIDE_INT / 3 * 3))
1678 fprintf (asmfile, "%o%01o", (int) beg, (int) middle);
1679 print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
1684 print_octal (value, digits)
1685 unsigned HOST_WIDE_INT value;
1690 for (i = digits - 1; i >= 0; i--)
1691 fprintf (asmfile, "%01o", (int) ((value >> (3 * i)) & 7));
1694 /* Output the name of type TYPE, with no punctuation.
1695 Such names can be set up either by typedef declarations
1696 or by struct, enum and union tags. */
1699 dbxout_type_name (type)
1703 if (TYPE_NAME (type) == 0)
1705 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
1707 t = TYPE_NAME (type);
1709 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1711 t = DECL_NAME (TYPE_NAME (type));
1716 fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
1717 CHARS (IDENTIFIER_LENGTH (t));
1720 /* Output a .stabs for the symbol defined by DECL,
1721 which must be a ..._DECL node in the normal namespace.
1722 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1723 LOCAL is nonzero if the scope is less than the entire file.
1724 Return 1 if a stabs might have been emitted. */
1727 dbxout_symbol (decl, local)
1729 int local ATTRIBUTE_UNUSED;
1731 tree type = TREE_TYPE (decl);
1732 tree context = NULL_TREE;
1735 /* Cast avoids warning in old compilers. */
1736 current_sym_code = (STAB_CODE_TYPE) 0;
1737 current_sym_value = 0;
1738 current_sym_addr = 0;
1740 /* Ignore nameless syms, but don't ignore type tags. */
1742 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
1743 || DECL_IGNORED_P (decl))
1746 dbxout_prepare_symbol (decl);
1748 /* The output will always start with the symbol name,
1749 so always count that in the length-output-so-far. */
1751 if (DECL_NAME (decl) != 0)
1752 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
1754 switch (TREE_CODE (decl))
1757 /* Enum values are defined by defining the enum type. */
1761 if (DECL_RTL (decl) == 0)
1763 if (DECL_EXTERNAL (decl))
1765 /* Don't mention a nested function under its parent. */
1766 context = decl_function_context (decl);
1767 if (context == current_function_decl)
1769 if (GET_CODE (DECL_RTL (decl)) != MEM
1770 || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
1774 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
1775 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1776 TREE_PUBLIC (decl) ? 'F' : 'f');
1779 current_sym_code = N_FUN;
1780 current_sym_addr = XEXP (DECL_RTL (decl), 0);
1782 if (TREE_TYPE (type))
1783 dbxout_type (TREE_TYPE (type), 0);
1785 dbxout_type (void_type_node, 0);
1787 /* For a nested function, when that function is compiled,
1788 mention the containing function name
1789 as well as (since dbx wants it) our own assembler-name. */
1791 fprintf (asmfile, ",%s,%s",
1792 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1793 IDENTIFIER_POINTER (DECL_NAME (context)));
1795 dbxout_finish_symbol (decl);
1800 /* This seems all wrong. Outputting most kinds of types gives no name
1801 at all. A true definition gives no name; a cross-ref for a
1802 structure can give the tag name, but not a type name.
1803 It seems that no typedef name is defined by outputting a type. */
1805 /* If this typedef name was defined by outputting the type,
1806 don't duplicate it. */
1807 if (typevec[TYPE_SYMTAB_ADDRESS (type)].status == TYPE_DEFINED
1808 && TYPE_NAME (TREE_TYPE (decl)) == decl)
1811 /* Don't output the same typedef twice.
1812 And don't output what language-specific stuff doesn't want output. */
1813 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
1822 if (DECL_NAME (decl))
1824 /* Nonzero means we must output a tag as well as a typedef. */
1827 /* Handle the case of a C++ structure or union
1828 where the TYPE_NAME is a TYPE_DECL
1829 which gives both a typedef name and a tag. */
1830 /* dbx requires the tag first and the typedef second. */
1831 if ((TREE_CODE (type) == RECORD_TYPE
1832 || TREE_CODE (type) == UNION_TYPE
1833 || TREE_CODE (type) == QUAL_UNION_TYPE)
1834 && TYPE_NAME (type) == decl
1835 && !(use_gnu_debug_info_extensions && have_used_extensions)
1836 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
1837 /* Distinguish the implicit typedefs of C++
1838 from explicit ones that might be found in C. */
1839 && DECL_ARTIFICIAL (decl)
1840 /* Do not generate a tag for records of variable size,
1841 since this type can not be properly described in the
1842 DBX format, and it confuses some tools such as objdump. */
1843 && host_integerp (TYPE_SIZE (type), 1))
1845 tree name = TYPE_NAME (type);
1846 if (TREE_CODE (name) == TYPE_DECL)
1847 name = DECL_NAME (name);
1849 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1850 current_sym_value = 0;
1851 current_sym_addr = 0;
1852 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1854 fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
1855 IDENTIFIER_POINTER (name));
1856 dbxout_type (type, 1);
1857 dbxout_finish_symbol (NULL_TREE);
1860 /* Output typedef name. */
1861 fprintf (asmfile, "%s\"%s:", ASM_STABS_OP,
1862 IDENTIFIER_POINTER (DECL_NAME (decl)));
1864 /* Short cut way to output a tag also. */
1865 if ((TREE_CODE (type) == RECORD_TYPE
1866 || TREE_CODE (type) == UNION_TYPE
1867 || TREE_CODE (type) == QUAL_UNION_TYPE)
1868 && TYPE_NAME (type) == decl
1869 /* Distinguish the implicit typedefs of C++
1870 from explicit ones that might be found in C. */
1871 && DECL_ARTIFICIAL (decl))
1873 if (use_gnu_debug_info_extensions && have_used_extensions)
1875 putc ('T', asmfile);
1876 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
1878 #if 0 /* Now we generate the tag for this case up above. */
1884 putc ('t', asmfile);
1885 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1887 dbxout_type (type, 1);
1888 dbxout_finish_symbol (decl);
1892 /* Don't output a tag if this is an incomplete type. This prevents
1893 the sun4 Sun OS 4.x dbx from crashing. */
1895 if (tag_needed && TYPE_NAME (type) != 0
1896 && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
1897 || (DECL_NAME (TYPE_NAME (type)) != 0))
1898 && COMPLETE_TYPE_P (type)
1899 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
1901 /* For a TYPE_DECL with no name, but the type has a name,
1903 This is what represents `struct foo' with no typedef. */
1904 /* In C++, the name of a type is the corresponding typedef.
1905 In C, it is an IDENTIFIER_NODE. */
1906 tree name = TYPE_NAME (type);
1907 if (TREE_CODE (name) == TYPE_DECL)
1908 name = DECL_NAME (name);
1910 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1911 current_sym_value = 0;
1912 current_sym_addr = 0;
1913 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1915 fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
1916 IDENTIFIER_POINTER (name));
1917 dbxout_type (type, 1);
1918 dbxout_finish_symbol (NULL_TREE);
1922 /* If an enum type has no name, it cannot be referred to,
1923 but we must output it anyway, since the enumeration constants
1924 can be referred to. */
1925 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
1927 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1928 current_sym_value = 0;
1929 current_sym_addr = 0;
1930 current_sym_nchars = 2;
1932 /* Some debuggers fail when given NULL names, so give this a
1933 harmless name of ` '. */
1934 fprintf (asmfile, "%s\" :T", ASM_STABS_OP);
1935 dbxout_type (type, 1);
1936 dbxout_finish_symbol (NULL_TREE);
1939 /* Prevent duplicate output of a typedef. */
1940 TREE_ASM_WRITTEN (decl) = 1;
1945 /* Parm decls go in their own separate chains
1946 and are output by dbxout_reg_parms and dbxout_parms. */
1950 /* Named return value, treat like a VAR_DECL. */
1952 if (! DECL_RTL_SET_P (decl))
1954 /* Don't mention a variable that is external.
1955 Let the file that defines it describe it. */
1956 if (DECL_EXTERNAL (decl))
1959 /* If the variable is really a constant
1960 and not written in memory, inform the debugger. */
1961 if (TREE_STATIC (decl) && TREE_READONLY (decl)
1962 && DECL_INITIAL (decl) != 0
1963 && host_integerp (DECL_INITIAL (decl), 0)
1964 && ! TREE_ASM_WRITTEN (decl)
1965 && (DECL_CONTEXT (decl) == NULL_TREE
1966 || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK))
1968 if (TREE_PUBLIC (decl) == 0)
1970 /* The sun4 assembler does not grok this. */
1971 const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1973 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
1974 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
1976 HOST_WIDE_INT ival = tree_low_cst (DECL_INITIAL (decl), 0);
1977 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1978 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile, name, ival);
1980 fprintf (asmfile, "%s\"%s:c=i", ASM_STABS_OP, name);
1982 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, ival);
1983 fprintf (asmfile, "\",0x%x,0,0,0\n", N_LSYM);
1987 else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
1989 /* don't know how to do this yet. */
1993 /* else it is something we handle like a normal variable. */
1996 SET_DECL_RTL (decl, eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
1997 #ifdef LEAF_REG_REMAP
1998 if (current_function_uses_only_leaf_regs)
1999 leaf_renumber_regs_insn (DECL_RTL (decl));
2002 result = dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
2011 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2012 Add SUFFIX to its name, if SUFFIX is not 0.
2013 Describe the variable as residing in HOME
2014 (usually HOME is DECL_RTL (DECL), but not always).
2015 Returns 1 if the stab was really emitted. */
2018 dbxout_symbol_location (decl, type, suffix, home)
2026 /* Don't mention a variable at all
2027 if it was completely optimized into nothingness.
2029 If the decl was from an inline function, then its rtl
2030 is not identically the rtl that was used in this
2031 particular compilation. */
2032 if (GET_CODE (home) == REG)
2034 regno = REGNO (home);
2035 if (regno >= FIRST_PSEUDO_REGISTER)
2038 else if (GET_CODE (home) == SUBREG)
2042 while (GET_CODE (value) == SUBREG)
2043 value = SUBREG_REG (value);
2044 if (GET_CODE (value) == REG)
2046 if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
2049 regno = REGNO (alter_subreg (home));
2052 /* The kind-of-variable letter depends on where
2053 the variable is and on the scope of its name:
2054 G and N_GSYM for static storage and global scope,
2055 S for static storage and file scope,
2056 V for static storage and local scope,
2057 for those two, use N_LCSYM if data is in bss segment,
2058 N_STSYM if in data segment, N_FUN otherwise.
2059 (We used N_FUN originally, then changed to N_STSYM
2060 to please GDB. However, it seems that confused ld.
2061 Now GDB has been fixed to like N_FUN, says Kingdon.)
2062 no letter at all, and N_LSYM, for auto variable,
2063 r and N_RSYM for register variable. */
2065 if (GET_CODE (home) == MEM
2066 && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
2068 if (TREE_PUBLIC (decl))
2071 current_sym_code = N_GSYM;
2075 current_sym_addr = XEXP (home, 0);
2077 letter = decl_function_context (decl) ? 'V' : 'S';
2079 /* This should be the same condition as in assemble_variable, but
2080 we don't have access to dont_output_data here. So, instead,
2081 we rely on the fact that error_mark_node initializers always
2082 end up in bss for C++ and never end up in bss for C. */
2083 if (DECL_INITIAL (decl) == 0
2084 || (!strcmp (lang_identify (), "cplusplus")
2085 && DECL_INITIAL (decl) == error_mark_node))
2086 current_sym_code = N_LCSYM;
2087 else if (DECL_IN_TEXT_SECTION (decl))
2088 /* This is not quite right, but it's the closest
2089 of all the codes that Unix defines. */
2090 current_sym_code = DBX_STATIC_CONST_VAR_CODE;
2093 /* Ultrix `as' seems to need this. */
2094 #ifdef DBX_STATIC_STAB_DATA_SECTION
2097 current_sym_code = N_STSYM;
2101 else if (regno >= 0)
2104 current_sym_code = N_RSYM;
2105 current_sym_value = DBX_REGISTER_NUMBER (regno);
2107 else if (GET_CODE (home) == MEM
2108 && (GET_CODE (XEXP (home, 0)) == MEM
2109 || (GET_CODE (XEXP (home, 0)) == REG
2110 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
2111 && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
2112 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2113 && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
2116 /* If the value is indirect by memory or by a register
2117 that isn't the frame pointer
2118 then it means the object is variable-sized and address through
2119 that register or stack slot. DBX has no way to represent this
2120 so all we can do is output the variable as a pointer.
2121 If it's not a parameter, ignore it.
2122 (VAR_DECLs like this can be made by integrate.c.) */
2124 if (GET_CODE (XEXP (home, 0)) == REG)
2127 current_sym_code = N_RSYM;
2128 current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
2132 current_sym_code = N_LSYM;
2133 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2134 We want the value of that CONST_INT. */
2136 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
2139 /* Effectively do build_pointer_type, but don't cache this type,
2140 since it might be temporary whereas the type it points to
2141 might have been saved for inlining. */
2142 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2143 type = make_node (POINTER_TYPE);
2144 TREE_TYPE (type) = TREE_TYPE (decl);
2146 else if (GET_CODE (home) == MEM
2147 && GET_CODE (XEXP (home, 0)) == REG)
2149 current_sym_code = N_LSYM;
2150 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2152 else if (GET_CODE (home) == MEM
2153 && GET_CODE (XEXP (home, 0)) == PLUS
2154 && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
2156 current_sym_code = N_LSYM;
2157 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2158 We want the value of that CONST_INT. */
2159 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2161 else if (GET_CODE (home) == MEM
2162 && GET_CODE (XEXP (home, 0)) == CONST)
2164 /* Handle an obscure case which can arise when optimizing and
2165 when there are few available registers. (This is *always*
2166 the case for i386/i486 targets). The RTL looks like
2167 (MEM (CONST ...)) even though this variable is a local `auto'
2168 or a local `register' variable. In effect, what has happened
2169 is that the reload pass has seen that all assignments and
2170 references for one such a local variable can be replaced by
2171 equivalent assignments and references to some static storage
2172 variable, thereby avoiding the need for a register. In such
2173 cases we're forced to lie to debuggers and tell them that
2174 this variable was itself `static'. */
2175 current_sym_code = N_LCSYM;
2177 current_sym_addr = XEXP (XEXP (home, 0), 0);
2179 else if (GET_CODE (home) == CONCAT)
2183 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
2184 for example), then there is no easy way to figure out
2185 what SUBTYPE should be. So, we give up. */
2186 if (TREE_CODE (type) != COMPLEX_TYPE)
2189 subtype = TREE_TYPE (type);
2191 /* If the variable's storage is in two parts,
2192 output each as a separate stab with a modified name. */
2193 if (WORDS_BIG_ENDIAN)
2194 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
2196 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
2198 /* Cast avoids warning in old compilers. */
2199 current_sym_code = (STAB_CODE_TYPE) 0;
2200 current_sym_value = 0;
2201 current_sym_addr = 0;
2202 dbxout_prepare_symbol (decl);
2204 if (WORDS_BIG_ENDIAN)
2205 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
2207 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
2211 /* Address might be a MEM, when DECL is a variable-sized object.
2212 Or it might be const0_rtx, meaning previous passes
2213 want us to ignore this variable. */
2216 /* Ok, start a symtab entry and output the variable name. */
2219 #ifdef DBX_STATIC_BLOCK_START
2220 DBX_STATIC_BLOCK_START (asmfile, current_sym_code);
2223 dbxout_symbol_name (decl, suffix, letter);
2224 dbxout_type (type, 0);
2225 dbxout_finish_symbol (decl);
2227 #ifdef DBX_STATIC_BLOCK_END
2228 DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
2233 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2234 Then output LETTER to indicate the kind of location the symbol has. */
2237 dbxout_symbol_name (decl, suffix, letter)
2244 if (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)))
2245 /* One slight hitch: if this is a VAR_DECL which is a static
2246 class member, we must put out the mangled name instead of the
2247 DECL_NAME. Note also that static member (variable) names DO NOT begin
2248 with underscores in .stabs directives. */
2249 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2251 /* ...but if we're function-local, we don't want to include the junk
2252 added by ASM_FORMAT_PRIVATE_NAME. */
2253 name = IDENTIFIER_POINTER (DECL_NAME (decl));
2257 fprintf (asmfile, "%s\"%s%s:", ASM_STABS_OP, name,
2258 (suffix ? suffix : ""));
2260 if (letter) putc (letter, asmfile);
2264 dbxout_prepare_symbol (decl)
2265 tree decl ATTRIBUTE_UNUSED;
2268 const char *filename = DECL_SOURCE_FILE (decl);
2270 dbxout_source_file (asmfile, filename);
2275 dbxout_finish_symbol (sym)
2278 #ifdef DBX_FINISH_SYMBOL
2279 DBX_FINISH_SYMBOL (sym);
2282 if (use_gnu_debug_info_extensions && sym != 0)
2283 line = DECL_SOURCE_LINE (sym);
2285 fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line);
2286 if (current_sym_addr)
2287 output_addr_const (asmfile, current_sym_addr);
2289 fprintf (asmfile, "%d", current_sym_value);
2290 putc ('\n', asmfile);
2294 /* Output definitions of all the decls in a chain. Return non-zero if
2295 anything was output */
2304 result += dbxout_symbol (syms, 1);
2305 syms = TREE_CHAIN (syms);
2310 /* The following two functions output definitions of function parameters.
2311 Each parameter gets a definition locating it in the parameter list.
2312 Each parameter that is a register variable gets a second definition
2313 locating it in the register.
2315 Printing or argument lists in gdb uses the definitions that
2316 locate in the parameter list. But reference to the variable in
2317 expressions uses preferentially the definition as a register. */
2319 /* Output definitions, referring to storage in the parmlist,
2320 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2323 dbxout_parms (parms)
2326 for (; parms; parms = TREE_CHAIN (parms))
2327 if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node)
2329 dbxout_prepare_symbol (parms);
2331 /* Perform any necessary register eliminations on the parameter's rtl,
2332 so that the debugging output will be accurate. */
2333 DECL_INCOMING_RTL (parms)
2334 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
2335 SET_DECL_RTL (parms, eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
2336 #ifdef LEAF_REG_REMAP
2337 if (current_function_uses_only_leaf_regs)
2339 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
2340 leaf_renumber_regs_insn (DECL_RTL (parms));
2344 if (PARM_PASSED_IN_MEMORY (parms))
2346 rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
2348 /* ??? Here we assume that the parm address is indexed
2349 off the frame pointer or arg pointer.
2350 If that is not true, we produce meaningless results,
2351 but do not crash. */
2352 if (GET_CODE (addr) == PLUS
2353 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
2354 current_sym_value = INTVAL (XEXP (addr, 1));
2356 current_sym_value = 0;
2358 current_sym_code = N_PSYM;
2359 current_sym_addr = 0;
2362 if (DECL_NAME (parms))
2364 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2366 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2367 IDENTIFIER_POINTER (DECL_NAME (parms)),
2368 DBX_MEMPARM_STABS_LETTER);
2372 current_sym_nchars = 8;
2373 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2374 DBX_MEMPARM_STABS_LETTER);
2377 /* It is quite tempting to use:
2379 dbxout_type (TREE_TYPE (parms), 0);
2381 as the next statement, rather than using DECL_ARG_TYPE(), so
2382 that gcc reports the actual type of the parameter, rather
2383 than the promoted type. This certainly makes GDB's life
2384 easier, at least for some ports. The change is a bad idea
2385 however, since GDB expects to be able access the type without
2386 performing any conversions. So for example, if we were
2387 passing a float to an unprototyped function, gcc will store a
2388 double on the stack, but if we emit a stab saying the type is a
2389 float, then gdb will only read in a single value, and this will
2390 produce an erropneous value. */
2391 dbxout_type (DECL_ARG_TYPE (parms), 0);
2392 current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
2393 dbxout_finish_symbol (parms);
2395 else if (GET_CODE (DECL_RTL (parms)) == REG)
2398 char regparm_letter;
2400 /* Parm passed in registers and lives in registers or nowhere. */
2402 current_sym_code = DBX_REGPARM_STABS_CODE;
2403 regparm_letter = DBX_REGPARM_STABS_LETTER;
2404 current_sym_addr = 0;
2406 /* If parm lives in a register, use that register;
2407 pretend the parm was passed there. It would be more consistent
2408 to describe the register where the parm was passed,
2409 but in practice that register usually holds something else.
2411 If we use DECL_RTL, then we must use the declared type of
2412 the variable, not the type that it arrived in. */
2413 if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2415 best_rtl = DECL_RTL (parms);
2416 parm_type = TREE_TYPE (parms);
2418 /* If the parm lives nowhere, use the register where it was
2419 passed. It is also better to use the declared type here. */
2422 best_rtl = DECL_INCOMING_RTL (parms);
2423 parm_type = TREE_TYPE (parms);
2425 current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
2428 if (DECL_NAME (parms))
2430 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2431 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2432 IDENTIFIER_POINTER (DECL_NAME (parms)),
2437 current_sym_nchars = 8;
2438 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2442 dbxout_type (parm_type, 0);
2443 dbxout_finish_symbol (parms);
2445 else if (GET_CODE (DECL_RTL (parms)) == MEM
2446 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2447 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
2448 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
2449 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2450 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
2454 /* Parm was passed via invisible reference.
2455 That is, its address was passed in a register.
2456 Output it as if it lived in that register.
2457 The debugger will know from the type
2458 that it was actually passed by invisible reference. */
2460 char regparm_letter;
2461 /* Parm passed in registers and lives in registers or nowhere. */
2463 current_sym_code = DBX_REGPARM_STABS_CODE;
2464 if (use_gnu_debug_info_extensions)
2465 regparm_letter = GDB_INV_REF_REGPARM_STABS_LETTER;
2467 regparm_letter = DBX_REGPARM_STABS_LETTER;
2469 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2470 If it is an unallocated pseudo-reg, then use the register where
2471 it was passed instead. */
2472 if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
2473 current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2475 current_sym_value = REGNO (DECL_INCOMING_RTL (parms));
2477 current_sym_addr = 0;
2480 if (DECL_NAME (parms))
2482 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2484 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2485 IDENTIFIER_POINTER (DECL_NAME (parms)),
2490 current_sym_nchars = 8;
2491 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2495 dbxout_type (TREE_TYPE (parms), 0);
2496 dbxout_finish_symbol (parms);
2498 else if (GET_CODE (DECL_RTL (parms)) == MEM
2499 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
2501 /* Parm was passed via invisible reference, with the reference
2502 living on the stack. DECL_RTL looks like
2503 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
2504 could look like (MEM (MEM (REG))). */
2505 const char *decl_name = (DECL_NAME (parms)
2506 ? IDENTIFIER_POINTER (DECL_NAME (parms))
2508 if (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 0)) == REG)
2509 current_sym_value = 0;
2512 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
2513 current_sym_addr = 0;
2516 fprintf (asmfile, "%s\"%s:v", ASM_STABS_OP, decl_name);
2517 dbxout_type (TREE_TYPE (parms), 0);
2518 dbxout_finish_symbol (parms);
2520 else if (GET_CODE (DECL_RTL (parms)) == MEM
2521 && XEXP (DECL_RTL (parms), 0) != const0_rtx
2522 /* ??? A constant address for a parm can happen
2523 when the reg it lives in is equiv to a constant in memory.
2524 Should make this not happen, after 2.4. */
2525 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
2527 /* Parm was passed in registers but lives on the stack. */
2529 current_sym_code = N_PSYM;
2530 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2531 in which case we want the value of that CONST_INT,
2533 in which case we use a value of zero. */
2534 if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG)
2535 current_sym_value = 0;
2538 = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
2540 current_sym_addr = 0;
2542 /* Make a big endian correction if the mode of the type of the
2543 parameter is not the same as the mode of the rtl. */
2544 if (BYTES_BIG_ENDIAN
2545 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
2546 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
2548 current_sym_value +=
2549 GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
2550 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms)));
2554 if (DECL_NAME (parms))
2557 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2559 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2560 IDENTIFIER_POINTER (DECL_NAME (parms)),
2561 DBX_MEMPARM_STABS_LETTER);
2565 current_sym_nchars = 8;
2566 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2567 DBX_MEMPARM_STABS_LETTER);
2571 = DEBUGGER_ARG_OFFSET (current_sym_value,
2572 XEXP (DECL_RTL (parms), 0));
2573 dbxout_type (TREE_TYPE (parms), 0);
2574 dbxout_finish_symbol (parms);
2579 /* Output definitions for the places where parms live during the function,
2580 when different from where they were passed, when the parms were passed
2583 It is not useful to do this for parms passed in registers
2584 that live during the function in different registers, because it is
2585 impossible to look in the passed register for the passed value,
2586 so we use the within-the-function register to begin with.
2588 PARMS is a chain of PARM_DECL nodes. */
2591 dbxout_reg_parms (parms)
2594 for (; parms; parms = TREE_CHAIN (parms))
2595 if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
2597 dbxout_prepare_symbol (parms);
2599 /* Report parms that live in registers during the function
2600 but were passed in memory. */
2601 if (GET_CODE (DECL_RTL (parms)) == REG
2602 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2603 dbxout_symbol_location (parms, TREE_TYPE (parms),
2604 0, DECL_RTL (parms));
2605 else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
2606 dbxout_symbol_location (parms, TREE_TYPE (parms),
2607 0, DECL_RTL (parms));
2608 /* Report parms that live in memory but not where they were passed. */
2609 else if (GET_CODE (DECL_RTL (parms)) == MEM
2610 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
2611 dbxout_symbol_location (parms, TREE_TYPE (parms),
2612 0, DECL_RTL (parms));
2616 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2617 output definitions of those names, in raw form */
2625 putc (',', asmfile);
2626 dbxout_type (TREE_VALUE (args), 0);
2628 args = TREE_CHAIN (args);
2632 /* Output everything about a symbol block (a BLOCK node
2633 that represents a scope level),
2634 including recursive output of contained blocks.
2636 BLOCK is the BLOCK node.
2637 DEPTH is its depth within containing symbol blocks.
2638 ARGS is usually zero; but for the outermost block of the
2639 body of a function, it is a chain of PARM_DECLs for the function parameters.
2640 We output definitions of all the register parms
2641 as if they were local variables of that block.
2643 If -g1 was used, we count blocks just the same, but output nothing
2644 except for the outermost block.
2646 Actually, BLOCK may be several blocks chained together.
2647 We handle them all in sequence. */
2650 dbxout_block (block, depth, args)
2651 register tree block;
2657 #if DBX_BLOCKS_FUNCTION_RELATIVE
2658 const char *begin_label;
2659 if (current_function_func_begin_label != NULL_TREE)
2660 begin_label = IDENTIFIER_POINTER (current_function_func_begin_label);
2662 begin_label = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
2667 /* Ignore blocks never expanded or otherwise marked as real. */
2668 if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
2672 #ifdef DBX_LBRAC_FIRST
2675 /* In dbx format, the syms of a block come before the N_LBRAC.
2676 If nothing is output, we don't need the N_LBRAC, either. */
2678 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2679 did_output = dbxout_syms (BLOCK_VARS (block));
2681 dbxout_reg_parms (args);
2684 /* Now output an N_LBRAC symbol to represent the beginning of
2685 the block. Use the block's tree-walk order to generate
2686 the assembler symbols LBBn and LBEn
2687 that final will define around the code in this block. */
2688 if (depth > 0 && did_output)
2691 blocknum = BLOCK_NUMBER (block);
2692 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
2694 if (BLOCK_HANDLER_BLOCK (block))
2696 /* A catch block. Must precede N_LBRAC. */
2697 tree decl = BLOCK_VARS (block);
2700 #ifdef DBX_OUTPUT_CATCH
2701 DBX_OUTPUT_CATCH (asmfile, decl, buf);
2703 fprintf (asmfile, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP,
2704 IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
2705 assemble_name (asmfile, buf);
2706 fprintf (asmfile, "\n");
2708 decl = TREE_CHAIN (decl);
2712 #ifdef DBX_OUTPUT_LBRAC
2713 DBX_OUTPUT_LBRAC (asmfile, buf);
2715 fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_LBRAC);
2716 assemble_name (asmfile, buf);
2717 #if DBX_BLOCKS_FUNCTION_RELATIVE
2718 fputc ('-', asmfile);
2719 assemble_name (asmfile, begin_label);
2721 fprintf (asmfile, "\n");
2725 #ifdef DBX_LBRAC_FIRST
2726 /* On some weird machines, the syms of a block
2727 come after the N_LBRAC. */
2728 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2729 dbxout_syms (BLOCK_VARS (block));
2731 dbxout_reg_parms (args);
2734 /* Output the subblocks. */
2735 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
2737 /* Refer to the marker for the end of the block. */
2738 if (depth > 0 && did_output)
2741 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
2742 #ifdef DBX_OUTPUT_RBRAC
2743 DBX_OUTPUT_RBRAC (asmfile, buf);
2745 fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_RBRAC);
2746 assemble_name (asmfile, buf);
2747 #if DBX_BLOCKS_FUNCTION_RELATIVE
2748 fputc ('-', asmfile);
2749 assemble_name (asmfile, begin_label);
2751 fprintf (asmfile, "\n");
2755 block = BLOCK_CHAIN (block);
2759 /* Output the information about a function and its arguments and result.
2760 Usually this follows the function's code,
2761 but on some systems, it comes before. */
2764 dbxout_begin_function (decl)
2767 dbxout_symbol (decl, 0);
2768 dbxout_parms (DECL_ARGUMENTS (decl));
2769 if (DECL_NAME (DECL_RESULT (decl)) != 0)
2770 dbxout_symbol (DECL_RESULT (decl), 1);
2773 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */