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));
317 /* The debug hooks structure. */
318 #if defined (DBX_DEBUGGING_INFO)
320 static void dbxout_begin_block PARAMS ((unsigned, unsigned));
321 static void dbxout_end_block PARAMS ((unsigned, unsigned));
322 static void dbxout_function_decl PARAMS ((tree));
324 struct gcc_debug_hooks dbx_debug_hooks =
328 debug_nothing_int_charstar,
329 debug_nothing_int_charstar,
330 dbxout_start_source_file,
331 dbxout_end_source_file,
334 debug_true_tree, /* ignore_block */
335 dbxout_source_line, /* source_line */
336 dbxout_source_line, /* begin_prologue: just output line info */
337 debug_nothing_int, /* end_prologue */
338 debug_nothing_void, /* end_epilogue */
339 #ifdef DBX_FUNCTION_FIRST
340 dbxout_begin_function,
342 debug_nothing_tree, /* begin_function */
344 debug_nothing_int, /* end_function */
345 dbxout_function_decl,
346 debug_nothing_tree, /* global_decl */
347 debug_nothing_tree, /* deferred_inline_function */
348 debug_nothing_tree, /* outlining_inline_function */
349 debug_nothing_rtx /* label */
351 #endif /* DBX_DEBUGGING_INFO */
353 #if defined (XCOFF_DEBUGGING_INFO)
354 struct gcc_debug_hooks xcoff_debug_hooks =
358 debug_nothing_int_charstar,
359 debug_nothing_int_charstar,
360 dbxout_start_source_file,
361 dbxout_end_source_file,
362 xcoffout_begin_block,
364 debug_true_tree, /* ignore_block */
365 xcoffout_source_line,
366 xcoffout_begin_prologue, /* begin_prologue */
367 debug_nothing_int, /* end_prologue */
368 xcoffout_end_epilogue,
369 debug_nothing_tree, /* begin_function */
370 xcoffout_end_function,
371 debug_nothing_tree, /* function_decl */
372 debug_nothing_tree, /* global_decl */
373 debug_nothing_tree, /* deferred_inline_function */
374 debug_nothing_tree, /* outlining_inline_function */
375 debug_nothing_rtx /* label */
377 #endif /* XCOFF_DEBUGGING_INFO */
379 #if defined(ASM_OUTPUT_SECTION_NAME)
381 dbxout_function_end ()
383 static int scope_labelno = 0;
384 char lscope_label_name[100];
385 /* Convert Ltext into the appropriate format for local labels in case
386 the system doesn't insert underscores in front of user generated
388 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
389 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Lscope", scope_labelno);
392 /* By convention, GCC will mark the end of a function with an N_FUN
393 symbol and an empty string. */
394 fprintf (asmfile, "%s\"\",%d,0,0,", ASM_STABS_OP, N_FUN);
395 assemble_name (asmfile, lscope_label_name);
396 fputc ('-', asmfile);
397 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
398 fprintf (asmfile, "\n");
400 #endif /* ! NO_DBX_FUNCTION_END */
402 /* At the beginning of compilation, start writing the symbol table.
403 Initialize `typevec' and output the standard data types of C. */
406 dbxout_init (input_file_name)
407 const char *input_file_name;
409 char ltext_label_name[100];
410 tree syms = getdecls ();
412 asmfile = asm_out_file;
415 typevec = (struct typeinfo *) xcalloc (typevec_len, sizeof typevec[0]);
417 /* Convert Ltext into the appropriate format for local labels in case
418 the system doesn't insert underscores in front of user generated
420 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
422 /* Put the current working directory in an N_SO symbol. */
423 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
424 but GDB always does. */
425 if (use_gnu_debug_info_extensions)
428 if (!cwd && (cwd = getpwd ()) && (!*cwd || cwd[strlen (cwd) - 1] != '/'))
429 cwd = concat (cwd, FILE_NAME_JOINER, NULL);
432 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
433 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd);
434 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
435 fprintf (asmfile, "%s", ASM_STABS_OP);
436 output_quoted_string (asmfile, cwd);
437 fprintf (asmfile, ",%d,0,0,%s\n", N_SO, <ext_label_name[1]);
438 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
442 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
443 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
444 would give us an N_SOL, and we want an N_SO. */
445 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile, input_file_name);
446 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
447 /* We include outputting `Ltext:' here,
448 because that gives you a way to override it. */
449 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
450 fprintf (asmfile, "%s", ASM_STABS_OP);
451 output_quoted_string (asmfile, input_file_name);
452 fprintf (asmfile, ",%d,0,0,%s\n",
453 N_SO, <ext_label_name[1]);
455 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Ltext", 0);
456 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
458 #ifdef DBX_OUTPUT_GCC_MARKER
459 DBX_OUTPUT_GCC_MARKER (asmfile);
461 /* Emit an N_OPT stab to indicate that this file was compiled by GCC. */
462 fprintf (asmfile, "%s\"%s\",%d,0,0,0\n",
463 ASM_STABS_OP, STABS_GCC_MARKER, N_OPT);
466 lastfile = input_file_name;
468 next_type_number = 1;
471 current_file = (struct dbx_file *) xmalloc (sizeof *current_file);
472 current_file->next = NULL;
473 current_file->file_number = 0;
474 current_file->next_type_number = 1;
475 next_file_number = 1;
478 /* Make sure that types `int' and `char' have numbers 1 and 2.
479 Definitions of other integer types will refer to those numbers.
480 (Actually it should no longer matter what their numbers are.
481 Also, if any types with tags have been defined, dbxout_symbol
482 will output them first, so the numbers won't be 1 and 2. That
483 happens in C++. So it's a good thing it should no longer matter). */
485 #ifdef DBX_OUTPUT_STANDARD_TYPES
486 DBX_OUTPUT_STANDARD_TYPES (syms);
488 dbxout_symbol (TYPE_NAME (integer_type_node), 0);
489 dbxout_symbol (TYPE_NAME (char_type_node), 0);
492 /* Get all permanent types that have typedef names,
493 and output them all, except for those already output. */
495 dbxout_typedefs (syms);
498 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
499 in the reverse order from that which is found in SYMS. */
502 dbxout_typedefs (syms)
507 dbxout_typedefs (TREE_CHAIN (syms));
508 if (TREE_CODE (syms) == TYPE_DECL)
510 tree type = TREE_TYPE (syms);
512 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
513 && COMPLETE_TYPE_P (type)
514 && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
515 dbxout_symbol (TYPE_NAME (type), 0);
520 /* Change to reading from a new source file. Generate a N_BINCL stab. */
523 dbxout_start_source_file (line, filename)
524 unsigned int line ATTRIBUTE_UNUSED;
525 const char *filename ATTRIBUTE_UNUSED;
528 struct dbx_file *n = (struct dbx_file *) xmalloc (sizeof *n);
530 n->next = current_file;
531 n->file_number = next_file_number++;
532 n->next_type_number = 1;
534 fprintf (asmfile, "%s", ASM_STABS_OP);
535 output_quoted_string (asmfile, filename);
536 fprintf (asmfile, ",%d,0,0,0\n", N_BINCL);
540 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
543 dbxout_end_source_file (line)
544 unsigned int line ATTRIBUTE_UNUSED;
547 struct dbx_file *next;
549 fprintf (asmfile, "%s%d,0,0,0\n", ASM_STABN_OP, N_EINCL);
550 next = current_file->next;
556 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
559 dbxout_source_file (file, filename)
561 const char *filename;
563 char ltext_label_name[100];
565 if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
567 #ifdef DBX_OUTPUT_SOURCE_FILENAME
568 DBX_OUTPUT_SOURCE_FILENAME (file, filename);
570 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext",
571 source_label_number);
572 fprintf (file, "%s", ASM_STABS_OP);
573 output_quoted_string (file, filename);
574 fprintf (file, ",%d,0,0,%s\n", N_SOL, <ext_label_name[1]);
575 if (current_function_decl != NULL_TREE
576 && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
577 ; /* Don't change section amid function. */
580 ASM_OUTPUT_INTERNAL_LABEL (file, "Ltext", source_label_number);
581 source_label_number++;
587 /* Output a line number symbol entry for source file FILENAME and line
591 dbxout_source_line (lineno, filename)
593 const char *filename;
595 dbxout_source_file (asmfile, filename);
597 #ifdef ASM_OUTPUT_SOURCE_LINE
598 ASM_OUTPUT_SOURCE_LINE (asmfile, lineno);
600 fprintf (asmfile, "%s%d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno);
604 #if defined (DBX_DEBUGGING_INFO)
606 /* Describe the beginning of an internal block within a function. */
609 dbxout_begin_block (line, n)
610 unsigned int line ATTRIBUTE_UNUSED;
613 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "LBB", n);
616 /* Describe the end line-number of an internal block within a function. */
619 dbxout_end_block (line, n)
620 unsigned int line ATTRIBUTE_UNUSED;
623 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "LBE", n);
626 /* Output dbx data for a function definition.
627 This includes a definition of the function name itself (a symbol),
628 definitions of the parameters (locating them in the parameter list)
629 and then output the block that makes up the function's body
630 (including all the auto variables of the function). */
633 dbxout_function_decl (decl)
636 #ifndef DBX_FUNCTION_FIRST
637 dbxout_begin_function (decl);
639 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
640 #ifdef DBX_OUTPUT_FUNCTION_END
641 DBX_OUTPUT_FUNCTION_END (asmfile, decl);
643 #if defined(ASM_OUTPUT_SECTION_NAME)
644 if (use_gnu_debug_info_extensions
645 #if defined(NO_DBX_FUNCTION_END)
646 && ! NO_DBX_FUNCTION_END
649 dbxout_function_end ();
653 #endif /* DBX_DEBUGGING_INFO */
655 /* At the end of compilation, finish writing the symbol table.
656 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
660 dbxout_finish (filename)
661 const char *filename ATTRIBUTE_UNUSED;
663 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
664 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asmfile, filename);
665 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
668 /* Output the index of a type. */
671 dbxout_type_index (type)
674 #ifndef DBX_USE_BINCL
675 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
678 struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
679 fprintf (asmfile, "(%d,%d)", t->file_number, t->type_number);
684 #if DBX_CONTIN_LENGTH > 0
685 /* Continue a symbol-description that gets too big.
686 End one symbol table entry with a double-backslash
687 and start a new one, eventually producing something like
688 .stabs "start......\\",code,0,value
689 .stabs "...rest",code,0,value */
694 #ifdef DBX_CONTIN_CHAR
695 fprintf (asmfile, "%c", DBX_CONTIN_CHAR);
697 fprintf (asmfile, "\\\\");
699 dbxout_finish_symbol (NULL_TREE);
700 fprintf (asmfile, "%s\"", ASM_STABS_OP);
701 current_sym_nchars = 0;
703 #endif /* DBX_CONTIN_LENGTH > 0 */
705 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
706 This must be a separate function because anonymous unions require
710 dbxout_type_fields (type)
715 /* Output the name, type, position (in bits), size (in bits) of each
716 field that we can support. */
717 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
719 /* Omit here local type decls until we know how to support them. */
720 if (TREE_CODE (tem) == TYPE_DECL
721 /* Omit fields whose position or size are variable or too large to
723 || (TREE_CODE (tem) == FIELD_DECL
724 && (! host_integerp (bit_position (tem), 0)
726 || ! host_integerp (DECL_SIZE (tem), 1)))
727 /* Omit here the nameless fields that are used to skip bits. */
728 || DECL_IGNORED_P (tem))
731 else if (TREE_CODE (tem) != CONST_DECL)
733 /* Continue the line if necessary,
734 but not before the first field. */
735 if (tem != TYPE_FIELDS (type))
740 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
741 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem)));
745 fprintf (asmfile, ":");
749 if (use_gnu_debug_info_extensions
750 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
751 || TREE_CODE (tem) != FIELD_DECL))
753 have_used_extensions = 1;
755 putc ((TREE_PRIVATE (tem) ? '0'
756 : TREE_PROTECTED (tem) ? '1' : '2'),
761 dbxout_type ((TREE_CODE (tem) == FIELD_DECL
762 && DECL_BIT_FIELD_TYPE (tem))
763 ? DECL_BIT_FIELD_TYPE (tem) : TREE_TYPE (tem), 0);
765 if (TREE_CODE (tem) == VAR_DECL)
767 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
770 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem));
771 have_used_extensions = 1;
772 fprintf (asmfile, ":%s;", name);
773 CHARS (strlen (name));
776 /* If TEM is non-static, GDB won't understand it. */
777 fprintf (asmfile, ",0,0;");
781 fputc (',', asmfile);
782 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
783 int_bit_position (tem));
784 fputc (',', asmfile);
785 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
786 tree_low_cst (DECL_SIZE (tem), 1));
787 fputc (';', asmfile);
794 /* Subroutine of `dbxout_type_methods'. Output debug info about the
795 method described DECL. DEBUG_NAME is an encoding of the method's
796 type signature. ??? We may be able to do without DEBUG_NAME altogether
800 dbxout_type_method_1 (decl, debug_name)
802 const char *debug_name;
806 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
808 else /* it's a METHOD_TYPE. */
810 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
811 /* A for normal functions.
812 B for `const' member functions.
813 C for `volatile' member functions.
814 D for `const volatile' member functions. */
815 if (TYPE_READONLY (TREE_TYPE (firstarg)))
817 if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
820 if (DECL_VINDEX (decl))
826 fprintf (asmfile, ":%s;%c%c%c", debug_name,
827 TREE_PRIVATE (decl) ? '0'
828 : TREE_PROTECTED (decl) ? '1' : '2', c1, c2);
829 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)) + 6
830 - (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
832 if (DECL_VINDEX (decl) && host_integerp (DECL_VINDEX (decl), 0))
834 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
835 tree_low_cst (DECL_VINDEX (decl), 0));
836 fputc (';', asmfile);
837 dbxout_type (DECL_CONTEXT (decl), 0);
838 fprintf (asmfile, ";");
843 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
847 dbxout_type_methods (type)
850 /* C++: put out the method names and their parameter lists */
851 tree methods = TYPE_METHODS (type);
853 register tree fndecl;
855 char formatted_type_identifier_length[16];
856 register int type_identifier_length;
858 if (methods == NULL_TREE)
861 type_encoding = DECL_NAME (TYPE_NAME (type));
864 /* C++: Template classes break some assumptions made by this code about
865 the class names, constructor names, and encodings for assembler
866 label names. For now, disable output of dbx info for them. */
868 const char *ptr = IDENTIFIER_POINTER (type_encoding);
869 /* This should use index. (mrs) */
870 while (*ptr && *ptr != '<') ptr++;
881 type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
883 sprintf (formatted_type_identifier_length, "%d", type_identifier_length);
885 if (TREE_CODE (methods) != TREE_VEC)
887 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
888 fndecl = TREE_VEC_ELT (methods, 0);
890 fndecl = TREE_VEC_ELT (methods, 1);
896 /* Group together all the methods for the same operation.
897 These differ in the types of the arguments. */
898 for (last = NULL_TREE;
899 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
900 fndecl = TREE_CHAIN (fndecl))
901 /* Output the name of the field (after overloading), as
902 well as the name of the field before overloading, along
903 with its parameter list */
905 /* This is the "mangled" name of the method.
906 It encodes the argument types. */
907 const char *debug_name;
909 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
910 include TEMPLATE_DECLs.) The debugger doesn't know what
911 to do with such entities anyhow. */
912 if (TREE_CODE (fndecl) != FUNCTION_DECL)
916 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
922 /* Also ignore abstract methods; those are only interesting to
923 the DWARF backends. */
924 if (DECL_IGNORED_P (fndecl) || DECL_ABSTRACT (fndecl))
927 /* Redundantly output the plain name, since that's what gdb
931 tree name = DECL_NAME (fndecl);
932 fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
933 CHARS (IDENTIFIER_LENGTH (name) + 2);
937 dbxout_type (TREE_TYPE (fndecl), 0);
939 dbxout_type_method_1 (fndecl, debug_name);
949 /* Emit a "range" type specification, which has the form:
950 "r<index type>;<lower bound>;<upper bound>;".
951 TYPE is an INTEGER_TYPE. */
954 dbxout_range_type (type)
957 fprintf (asmfile, "r");
958 if (TREE_TYPE (type))
959 dbxout_type (TREE_TYPE (type), 0);
960 else if (TREE_CODE (type) != INTEGER_TYPE)
961 dbxout_type (type, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
964 /* Traditionally, we made sure 'int' was type 1, and builtin types
965 were defined to be sub-ranges of int. Unfortunately, this
966 does not allow us to distinguish true sub-ranges from integer
967 types. So, instead we define integer (non-sub-range) types as
968 sub-ranges of themselves. This matters for Chill. If this isn't
969 a subrange type, then we want to define it in terms of itself.
970 However, in C, this may be an anonymous integer type, and we don't
971 want to emit debug info referring to it. Just calling
972 dbxout_type_index won't work anyways, because the type hasn't been
973 defined yet. We make this work for both cases by checked to see
974 whether this is a defined type, referring to it if it is, and using
976 if (TYPE_SYMTAB_ADDRESS (type) != 0)
977 dbxout_type_index (type);
979 dbxout_type_index (integer_type_node);
982 if (TYPE_MIN_VALUE (type) != 0
983 && host_integerp (TYPE_MIN_VALUE (type), 0))
985 fputc (';', asmfile);
986 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
987 tree_low_cst (TYPE_MIN_VALUE (type), 0));
990 fprintf (asmfile, ";0");
992 if (TYPE_MAX_VALUE (type) != 0
993 && host_integerp (TYPE_MAX_VALUE (type), 0))
995 fputc (';', asmfile);
996 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
997 tree_low_cst (TYPE_MAX_VALUE (type), 0));
998 fputc (';', asmfile);
1001 fprintf (asmfile, ";-1;");
1004 /* Output a reference to a type. If the type has not yet been
1005 described in the dbx output, output its definition now.
1006 For a type already defined, just refer to its definition
1007 using the type number.
1009 If FULL is nonzero, and the type has been described only with
1010 a forward-reference, output the definition now.
1011 If FULL is zero in this case, just refer to the forward-reference
1012 using the number previously allocated. */
1015 dbxout_type (type, full)
1020 static int anonymous_type_number = 0;
1022 if (TREE_CODE (type) == VECTOR_TYPE)
1023 type = TYPE_DEBUG_REPRESENTATION_TYPE (type);
1025 /* If there was an input error and we don't really have a type,
1026 avoid crashing and write something that is at least valid
1027 by assuming `int'. */
1028 if (type == error_mark_node)
1029 type = integer_type_node;
1032 /* Try to find the "main variant" with the same name but not const
1033 or volatile. (Since stabs does not distinguish const and volatile,
1034 there is no need to make them separate types. But types with
1035 different names are usefully distinguished.) */
1037 for (tem = TYPE_MAIN_VARIANT (type); tem; tem = TYPE_NEXT_VARIANT (tem))
1038 if (!TYPE_READONLY (tem) && !TYPE_VOLATILE (tem)
1039 && TYPE_NAME (tem) == TYPE_NAME (type))
1044 if (TYPE_NAME (type)
1045 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1046 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
1050 if (TYPE_SYMTAB_ADDRESS (type) == 0)
1052 /* Type has no dbx number assigned. Assign next available number. */
1053 TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
1055 /* Make sure type vector is long enough to record about this type. */
1057 if (next_type_number == typevec_len)
1060 = (struct typeinfo *) xrealloc (typevec,
1061 typevec_len * 2 * sizeof typevec[0]);
1062 memset ((char *) (typevec + typevec_len), 0,
1063 typevec_len * sizeof typevec[0]);
1067 #ifdef DBX_USE_BINCL
1068 typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
1069 = current_file->file_number;
1070 typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
1071 = current_file->next_type_number++;
1075 /* Output the number of this type, to refer to it. */
1076 dbxout_type_index (type);
1078 #ifdef DBX_TYPE_DEFINED
1079 if (DBX_TYPE_DEFINED (type))
1083 /* If this type's definition has been output or is now being output,
1086 switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
1091 /* If we have already had a cross reference,
1092 and either that's all we want or that's the best we could do,
1093 don't repeat the cross reference.
1094 Sun dbx crashes if we do. */
1095 if (! full || !COMPLETE_TYPE_P (type)
1096 /* No way in DBX fmt to describe a variable size. */
1097 || ! host_integerp (TYPE_SIZE (type), 1))
1105 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1106 leave the type-number completely undefined rather than output
1107 a cross-reference. If we have already used GNU debug info extensions,
1108 then it is OK to output a cross reference. This is necessary to get
1109 proper C++ debug output. */
1110 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
1111 || TREE_CODE (type) == QUAL_UNION_TYPE
1112 || TREE_CODE (type) == ENUMERAL_TYPE)
1113 && ! use_gnu_debug_info_extensions)
1114 /* We must use the same test here as we use twice below when deciding
1115 whether to emit a cross-reference. */
1116 if ((TYPE_NAME (type) != 0
1117 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1118 && DECL_IGNORED_P (TYPE_NAME (type)))
1120 || !COMPLETE_TYPE_P (type)
1121 /* No way in DBX fmt to describe a variable size. */
1122 || ! host_integerp (TYPE_SIZE (type), 1))
1124 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1129 /* Output a definition now. */
1131 fprintf (asmfile, "=");
1134 /* Mark it as defined, so that if it is self-referent
1135 we will not get into an infinite recursion of definitions. */
1137 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
1139 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1140 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1142 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0);
1146 switch (TREE_CODE (type))
1150 /* For a void type, just define it as itself; ie, "5=5".
1151 This makes us consider it defined
1152 without saying what it is. The debugger will make it
1153 a void type when the reference is seen, and nothing will
1154 ever override that default. */
1155 dbxout_type_index (type);
1159 if (type == char_type_node && ! TREE_UNSIGNED (type))
1161 /* Output the type `char' as a subrange of itself!
1162 I don't understand this definition, just copied it
1163 from the output of pcc.
1164 This used to use `r2' explicitly and we used to
1165 take care to make sure that `char' was type number 2. */
1166 fprintf (asmfile, "r");
1167 dbxout_type_index (type);
1168 fprintf (asmfile, ";0;127;");
1171 /* If this is a subtype of another integer type, always prefer to
1172 write it as a subtype. */
1173 else if (TREE_TYPE (type) != 0
1174 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
1175 dbxout_range_type (type);
1179 /* If the size is non-standard, say what it is if we can use
1182 if (use_gnu_debug_info_extensions
1183 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1184 fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1186 /* If we can use GDB extensions and the size is wider than a
1187 long (the size used by GDB to read them) or we may have
1188 trouble writing the bounds the usual way, write them in
1189 octal. Note the test is for the *target's* size of "long",
1190 not that of the host. The host test is just to make sure we
1191 can write it out in case the host wide int is narrower than the
1194 /* For unsigned types, we use octal if they are the same size or
1195 larger. This is because we print the bounds as signed decimal,
1196 and hence they can't span same size unsigned types. */
1198 if (use_gnu_debug_info_extensions
1199 && TYPE_MIN_VALUE (type) != 0
1200 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
1201 && TYPE_MAX_VALUE (type) != 0
1202 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
1203 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
1204 || ((TYPE_PRECISION (type)
1205 == TYPE_PRECISION (integer_type_node))
1206 && TREE_UNSIGNED (type))
1207 || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
1208 || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
1209 && TREE_UNSIGNED (type))))
1211 fprintf (asmfile, "r");
1212 dbxout_type_index (type);
1213 fprintf (asmfile, ";");
1214 print_int_cst_octal (TYPE_MIN_VALUE (type));
1215 fprintf (asmfile, ";");
1216 print_int_cst_octal (TYPE_MAX_VALUE (type));
1217 fprintf (asmfile, ";");
1221 /* Output other integer types as subranges of `int'. */
1222 dbxout_range_type (type);
1229 /* This used to say `r1' and we used to take care
1230 to make sure that `int' was type number 1. */
1231 fprintf (asmfile, "r");
1232 dbxout_type_index (integer_type_node);
1233 fputc (';', asmfile);
1234 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, int_size_in_bytes (type));
1235 fputs (";0;", asmfile);
1240 if (use_gnu_debug_info_extensions)
1242 fputs ("@s", asmfile);
1243 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1244 BITS_PER_UNIT * int_size_in_bytes (type));
1245 fputs (";-20;", asmfile);
1249 /* Output the type `char' as a subrange of itself.
1250 That is what pcc seems to do. */
1251 fprintf (asmfile, "r");
1252 dbxout_type_index (char_type_node);
1253 fprintf (asmfile, ";0;%d;", TREE_UNSIGNED (type) ? 255 : 127);
1259 if (use_gnu_debug_info_extensions)
1261 fputs ("@s", asmfile);
1262 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1263 BITS_PER_UNIT * int_size_in_bytes (type));
1264 fputs (";-16;", asmfile);
1266 else /* Define as enumeral type (False, True) */
1267 fprintf (asmfile, "eFalse:0,True:1,;");
1272 putc ('d', asmfile);
1274 dbxout_type (TREE_TYPE (type), 0);
1278 /* Differs from the REAL_TYPE by its new data type number */
1280 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1282 fprintf (asmfile, "r");
1283 dbxout_type_index (type);
1284 fputc (';', asmfile);
1285 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1286 2 * int_size_in_bytes (TREE_TYPE (type)));
1287 fputs (";0;", asmfile);
1288 CHARS (12); /* The number is probably incorrect here. */
1292 /* Output a complex integer type as a structure,
1293 pending some other way to do it. */
1294 fputc ('s', asmfile);
1295 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, int_size_in_bytes (type));
1297 fprintf (asmfile, "real:");
1299 dbxout_type (TREE_TYPE (type), 0);
1300 fprintf (asmfile, ",%d,%d;",
1301 0, TYPE_PRECISION (TREE_TYPE (type)));
1303 fprintf (asmfile, "imag:");
1305 dbxout_type (TREE_TYPE (type), 0);
1306 fprintf (asmfile, ",%d,%d;;",
1307 TYPE_PRECISION (TREE_TYPE (type)),
1308 TYPE_PRECISION (TREE_TYPE (type)));
1314 if (use_gnu_debug_info_extensions)
1316 have_used_extensions = 1;
1317 fputs ("@s", asmfile);
1318 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1319 BITS_PER_UNIT * int_size_in_bytes (type));
1320 fputc (';', asmfile);
1321 /* Check if a bitstring type, which in Chill is
1322 different from a [power]set. */
1323 if (TYPE_STRING_FLAG (type))
1324 fprintf (asmfile, "@S;");
1326 putc ('S', asmfile);
1328 dbxout_type (TYPE_DOMAIN (type), 0);
1332 /* Make arrays of packed bits look like bitstrings for chill. */
1333 if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
1335 have_used_extensions = 1;
1336 fputs ("@s", asmfile);
1337 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1338 BITS_PER_UNIT * int_size_in_bytes (type));
1339 fputc (';', asmfile);
1340 fprintf (asmfile, "@S;");
1341 putc ('S', asmfile);
1343 dbxout_type (TYPE_DOMAIN (type), 0);
1346 /* Output "a" followed by a range type definition
1347 for the index type of the array
1348 followed by a reference to the target-type.
1349 ar1;0;N;M for a C array of type M and size N+1. */
1350 /* Check if a character string type, which in Chill is
1351 different from an array of characters. */
1352 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
1354 have_used_extensions = 1;
1355 fprintf (asmfile, "@S;");
1357 tem = TYPE_DOMAIN (type);
1360 fprintf (asmfile, "ar");
1361 dbxout_type_index (integer_type_node);
1362 fprintf (asmfile, ";0;-1;");
1366 fprintf (asmfile, "a");
1367 dbxout_range_type (tem);
1370 dbxout_type (TREE_TYPE (type), 0);
1375 case QUAL_UNION_TYPE:
1377 int i, n_baseclasses = 0;
1379 if (TYPE_BINFO (type) != 0
1380 && TREE_CODE (TYPE_BINFO (type)) == TREE_VEC
1381 && TYPE_BINFO_BASETYPES (type) != 0)
1382 n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
1384 /* Output a structure type. We must use the same test here as we
1385 use in the DBX_NO_XREFS case above. */
1386 if ((TYPE_NAME (type) != 0
1387 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1388 && DECL_IGNORED_P (TYPE_NAME (type)))
1390 || !COMPLETE_TYPE_P (type)
1391 /* No way in DBX fmt to describe a variable size. */
1392 || ! host_integerp (TYPE_SIZE (type), 1))
1394 /* If the type is just a cross reference, output one
1395 and mark the type as partially described.
1396 If it later becomes defined, we will output
1397 its real definition.
1398 If the type has a name, don't nest its definition within
1399 another type's definition; instead, output an xref
1400 and let the definition come when the name is defined. */
1401 fputs ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu", asmfile);
1403 #if 0 /* This assertion is legitimately false in C++. */
1404 /* We shouldn't be outputting a reference to a type before its
1405 definition unless the type has a tag name.
1406 A typedef name without a tag name should be impossible. */
1407 if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
1410 if (TYPE_NAME (type) != 0)
1411 dbxout_type_name (type);
1413 fprintf (asmfile, "$$%d", anonymous_type_number++);
1414 fprintf (asmfile, ":");
1415 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1419 /* Identify record or union, and print its size. */
1420 fputc (((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'), asmfile);
1421 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1422 int_size_in_bytes (type));
1424 if (use_gnu_debug_info_extensions)
1428 have_used_extensions = 1;
1429 fprintf (asmfile, "!%d,", n_baseclasses);
1433 for (i = 0; i < n_baseclasses; i++)
1435 tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i);
1437 if (use_gnu_debug_info_extensions)
1439 have_used_extensions = 1;
1440 putc (TREE_VIA_VIRTUAL (child) ? '1' : '0', asmfile);
1441 putc (TREE_VIA_PUBLIC (child) ? '2' : '0', asmfile);
1442 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1443 (tree_low_cst (BINFO_OFFSET (child), 0)
1445 fputc (',', asmfile);
1447 dbxout_type (BINFO_TYPE (child), 0);
1448 putc (';', asmfile);
1452 /* Print out the base class information with fields
1453 which have the same names at the types they hold. */
1454 dbxout_type_name (BINFO_TYPE (child));
1455 putc (':', asmfile);
1456 dbxout_type (BINFO_TYPE (child), full);
1457 fputc (',', asmfile);
1458 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1459 tree_low_cst (BINFO_OFFSET (child), 0)
1461 fputc (',', asmfile);
1462 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1463 (tree_low_cst (DECL_SIZE (TYPE_NAME
1464 (BINFO_TYPE (child))), 0)
1466 fputc (';', asmfile);
1474 /* Write out the field declarations. */
1475 dbxout_type_fields (type);
1476 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
1478 have_used_extensions = 1;
1479 dbxout_type_methods (type);
1482 putc (';', asmfile);
1484 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
1485 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1486 && TYPE_VFIELD (type))
1488 have_used_extensions = 1;
1490 /* Tell GDB+ that it may keep reading. */
1491 putc ('~', asmfile);
1493 /* We need to write out info about what field this class
1494 uses as its "main" vtable pointer field, because if this
1495 field is inherited from a base class, GDB cannot necessarily
1496 figure out which field it's using in time. */
1497 if (TYPE_VFIELD (type))
1499 putc ('%', asmfile);
1500 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
1502 putc (';', asmfile);
1508 /* We must use the same test here as we use in the DBX_NO_XREFS case
1509 above. We simplify it a bit since an enum will never have a variable
1511 if ((TYPE_NAME (type) != 0
1512 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1513 && DECL_IGNORED_P (TYPE_NAME (type)))
1515 || !COMPLETE_TYPE_P (type))
1517 fprintf (asmfile, "xe");
1519 dbxout_type_name (type);
1520 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1521 fprintf (asmfile, ":");
1524 #ifdef DBX_OUTPUT_ENUM
1525 DBX_OUTPUT_ENUM (asmfile, type);
1527 if (use_gnu_debug_info_extensions
1528 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1529 fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1530 putc ('e', asmfile);
1532 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
1534 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1535 if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
1536 fprintf (asmfile, HOST_WIDE_INT_PRINT_UNSIGNED,
1537 TREE_INT_CST_LOW (TREE_VALUE (tem)));
1538 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
1539 && (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
1540 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1541 TREE_INT_CST_LOW (TREE_VALUE (tem)));
1543 print_int_cst_octal (TREE_VALUE (tem));
1544 fprintf (asmfile, ",");
1545 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem)));
1546 if (TREE_CHAIN (tem) != 0)
1551 putc (';', asmfile);
1557 putc ('*', asmfile);
1559 dbxout_type (TREE_TYPE (type), 0);
1563 if (use_gnu_debug_info_extensions)
1565 have_used_extensions = 1;
1566 putc ('#', asmfile);
1569 /* Write the argument types out longhand. */
1570 dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
1571 putc (',', asmfile);
1573 dbxout_type (TREE_TYPE (type), 0);
1574 dbxout_args (TYPE_ARG_TYPES (type));
1575 putc (';', asmfile);
1580 /* Treat it as a function type. */
1581 dbxout_type (TREE_TYPE (type), 0);
1586 if (use_gnu_debug_info_extensions)
1588 have_used_extensions = 1;
1589 putc ('@', asmfile);
1591 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
1592 putc (',', asmfile);
1594 dbxout_type (TREE_TYPE (type), 0);
1598 /* Should print as an int, because it is really
1600 dbxout_type (integer_type_node, 0);
1604 case REFERENCE_TYPE:
1605 if (use_gnu_debug_info_extensions)
1606 have_used_extensions = 1;
1607 putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
1609 dbxout_type (TREE_TYPE (type), 0);
1613 putc ('f', asmfile);
1615 dbxout_type (TREE_TYPE (type), 0);
1623 /* Print the value of integer constant C, in octal,
1624 handling double precision. */
1627 print_int_cst_octal (c)
1630 unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
1631 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
1632 int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
1633 unsigned int width = TYPE_PRECISION (TREE_TYPE (c));
1635 /* GDB wants constants with no extra leading "1" bits, so
1636 we need to remove any sign-extension that might be
1638 if (width == HOST_BITS_PER_WIDE_INT * 2)
1640 else if (width > HOST_BITS_PER_WIDE_INT)
1641 high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
1642 else if (width == HOST_BITS_PER_WIDE_INT)
1645 high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
1647 fprintf (asmfile, "0");
1651 print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
1652 print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
1656 unsigned HOST_WIDE_INT beg = high >> excess;
1657 unsigned HOST_WIDE_INT middle
1658 = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
1659 | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
1660 unsigned HOST_WIDE_INT end
1661 = low & (((unsigned HOST_WIDE_INT) 1
1662 << (HOST_BITS_PER_WIDE_INT / 3 * 3))
1665 fprintf (asmfile, "%o%01o", (int) beg, (int) middle);
1666 print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
1671 print_octal (value, digits)
1672 unsigned HOST_WIDE_INT value;
1677 for (i = digits - 1; i >= 0; i--)
1678 fprintf (asmfile, "%01o", (int) ((value >> (3 * i)) & 7));
1681 /* Output the name of type TYPE, with no punctuation.
1682 Such names can be set up either by typedef declarations
1683 or by struct, enum and union tags. */
1686 dbxout_type_name (type)
1690 if (TYPE_NAME (type) == 0)
1692 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
1694 t = TYPE_NAME (type);
1696 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1698 t = DECL_NAME (TYPE_NAME (type));
1703 fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
1704 CHARS (IDENTIFIER_LENGTH (t));
1707 /* Output a .stabs for the symbol defined by DECL,
1708 which must be a ..._DECL node in the normal namespace.
1709 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1710 LOCAL is nonzero if the scope is less than the entire file.
1711 Return 1 if a stabs might have been emitted. */
1714 dbxout_symbol (decl, local)
1716 int local ATTRIBUTE_UNUSED;
1718 tree type = TREE_TYPE (decl);
1719 tree context = NULL_TREE;
1722 /* Cast avoids warning in old compilers. */
1723 current_sym_code = (STAB_CODE_TYPE) 0;
1724 current_sym_value = 0;
1725 current_sym_addr = 0;
1727 /* Ignore nameless syms, but don't ignore type tags. */
1729 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
1730 || DECL_IGNORED_P (decl))
1733 dbxout_prepare_symbol (decl);
1735 /* The output will always start with the symbol name,
1736 so always count that in the length-output-so-far. */
1738 if (DECL_NAME (decl) != 0)
1739 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
1741 switch (TREE_CODE (decl))
1744 /* Enum values are defined by defining the enum type. */
1748 if (DECL_RTL (decl) == 0)
1750 if (DECL_EXTERNAL (decl))
1752 /* Don't mention a nested function under its parent. */
1753 context = decl_function_context (decl);
1754 if (context == current_function_decl)
1756 if (GET_CODE (DECL_RTL (decl)) != MEM
1757 || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
1761 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
1762 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1763 TREE_PUBLIC (decl) ? 'F' : 'f');
1766 current_sym_code = N_FUN;
1767 current_sym_addr = XEXP (DECL_RTL (decl), 0);
1769 if (TREE_TYPE (type))
1770 dbxout_type (TREE_TYPE (type), 0);
1772 dbxout_type (void_type_node, 0);
1774 /* For a nested function, when that function is compiled,
1775 mention the containing function name
1776 as well as (since dbx wants it) our own assembler-name. */
1778 fprintf (asmfile, ",%s,%s",
1779 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1780 IDENTIFIER_POINTER (DECL_NAME (context)));
1782 dbxout_finish_symbol (decl);
1787 /* This seems all wrong. Outputting most kinds of types gives no name
1788 at all. A true definition gives no name; a cross-ref for a
1789 structure can give the tag name, but not a type name.
1790 It seems that no typedef name is defined by outputting a type. */
1792 /* If this typedef name was defined by outputting the type,
1793 don't duplicate it. */
1794 if (typevec[TYPE_SYMTAB_ADDRESS (type)].status == TYPE_DEFINED
1795 && TYPE_NAME (TREE_TYPE (decl)) == decl)
1798 /* Don't output the same typedef twice.
1799 And don't output what language-specific stuff doesn't want output. */
1800 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
1809 if (DECL_NAME (decl))
1811 /* Nonzero means we must output a tag as well as a typedef. */
1814 /* Handle the case of a C++ structure or union
1815 where the TYPE_NAME is a TYPE_DECL
1816 which gives both a typedef name and a tag. */
1817 /* dbx requires the tag first and the typedef second. */
1818 if ((TREE_CODE (type) == RECORD_TYPE
1819 || TREE_CODE (type) == UNION_TYPE
1820 || TREE_CODE (type) == QUAL_UNION_TYPE)
1821 && TYPE_NAME (type) == decl
1822 && !(use_gnu_debug_info_extensions && have_used_extensions)
1823 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
1824 /* Distinguish the implicit typedefs of C++
1825 from explicit ones that might be found in C. */
1826 && DECL_ARTIFICIAL (decl)
1827 /* Do not generate a tag for records of variable size,
1828 since this type can not be properly described in the
1829 DBX format, and it confuses some tools such as objdump. */
1830 && host_integerp (TYPE_SIZE (type), 1))
1832 tree name = TYPE_NAME (type);
1833 if (TREE_CODE (name) == TYPE_DECL)
1834 name = DECL_NAME (name);
1836 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1837 current_sym_value = 0;
1838 current_sym_addr = 0;
1839 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1841 fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
1842 IDENTIFIER_POINTER (name));
1843 dbxout_type (type, 1);
1844 dbxout_finish_symbol (NULL_TREE);
1847 /* Output typedef name. */
1848 fprintf (asmfile, "%s\"%s:", ASM_STABS_OP,
1849 IDENTIFIER_POINTER (DECL_NAME (decl)));
1851 /* Short cut way to output a tag also. */
1852 if ((TREE_CODE (type) == RECORD_TYPE
1853 || TREE_CODE (type) == UNION_TYPE
1854 || TREE_CODE (type) == QUAL_UNION_TYPE)
1855 && TYPE_NAME (type) == decl
1856 /* Distinguish the implicit typedefs of C++
1857 from explicit ones that might be found in C. */
1858 && DECL_ARTIFICIAL (decl))
1860 if (use_gnu_debug_info_extensions && have_used_extensions)
1862 putc ('T', asmfile);
1863 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
1865 #if 0 /* Now we generate the tag for this case up above. */
1871 putc ('t', asmfile);
1872 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1874 dbxout_type (type, 1);
1875 dbxout_finish_symbol (decl);
1879 /* Don't output a tag if this is an incomplete type. This prevents
1880 the sun4 Sun OS 4.x dbx from crashing. */
1882 if (tag_needed && TYPE_NAME (type) != 0
1883 && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
1884 || (DECL_NAME (TYPE_NAME (type)) != 0))
1885 && COMPLETE_TYPE_P (type)
1886 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
1888 /* For a TYPE_DECL with no name, but the type has a name,
1890 This is what represents `struct foo' with no typedef. */
1891 /* In C++, the name of a type is the corresponding typedef.
1892 In C, it is an IDENTIFIER_NODE. */
1893 tree name = TYPE_NAME (type);
1894 if (TREE_CODE (name) == TYPE_DECL)
1895 name = DECL_NAME (name);
1897 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1898 current_sym_value = 0;
1899 current_sym_addr = 0;
1900 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1902 fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
1903 IDENTIFIER_POINTER (name));
1904 dbxout_type (type, 1);
1905 dbxout_finish_symbol (NULL_TREE);
1909 /* If an enum type has no name, it cannot be referred to,
1910 but we must output it anyway, since the enumeration constants
1911 can be referred to. */
1912 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
1914 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1915 current_sym_value = 0;
1916 current_sym_addr = 0;
1917 current_sym_nchars = 2;
1919 /* Some debuggers fail when given NULL names, so give this a
1920 harmless name of ` '. */
1921 fprintf (asmfile, "%s\" :T", ASM_STABS_OP);
1922 dbxout_type (type, 1);
1923 dbxout_finish_symbol (NULL_TREE);
1926 /* Prevent duplicate output of a typedef. */
1927 TREE_ASM_WRITTEN (decl) = 1;
1932 /* Parm decls go in their own separate chains
1933 and are output by dbxout_reg_parms and dbxout_parms. */
1937 /* Named return value, treat like a VAR_DECL. */
1939 if (! DECL_RTL_SET_P (decl))
1941 /* Don't mention a variable that is external.
1942 Let the file that defines it describe it. */
1943 if (DECL_EXTERNAL (decl))
1946 /* If the variable is really a constant
1947 and not written in memory, inform the debugger. */
1948 if (TREE_STATIC (decl) && TREE_READONLY (decl)
1949 && DECL_INITIAL (decl) != 0
1950 && host_integerp (DECL_INITIAL (decl), 0)
1951 && ! TREE_ASM_WRITTEN (decl)
1952 && (DECL_CONTEXT (decl) == NULL_TREE
1953 || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK))
1955 if (TREE_PUBLIC (decl) == 0)
1957 /* The sun4 assembler does not grok this. */
1958 const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1960 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
1961 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
1963 HOST_WIDE_INT ival = tree_low_cst (DECL_INITIAL (decl), 0);
1964 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1965 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile, name, ival);
1967 fprintf (asmfile, "%s\"%s:c=i", ASM_STABS_OP, name);
1969 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, ival);
1970 fprintf (asmfile, "\",0x%x,0,0,0\n", N_LSYM);
1974 else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
1976 /* don't know how to do this yet. */
1980 /* else it is something we handle like a normal variable. */
1983 SET_DECL_RTL (decl, eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
1984 #ifdef LEAF_REG_REMAP
1985 if (current_function_uses_only_leaf_regs)
1986 leaf_renumber_regs_insn (DECL_RTL (decl));
1989 result = dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
1998 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1999 Add SUFFIX to its name, if SUFFIX is not 0.
2000 Describe the variable as residing in HOME
2001 (usually HOME is DECL_RTL (DECL), but not always).
2002 Returns 1 if the stab was really emitted. */
2005 dbxout_symbol_location (decl, type, suffix, home)
2013 /* Don't mention a variable at all
2014 if it was completely optimized into nothingness.
2016 If the decl was from an inline function, then its rtl
2017 is not identically the rtl that was used in this
2018 particular compilation. */
2019 if (GET_CODE (home) == REG)
2021 regno = REGNO (home);
2022 if (regno >= FIRST_PSEUDO_REGISTER)
2025 else if (GET_CODE (home) == SUBREG)
2029 while (GET_CODE (value) == SUBREG)
2030 value = SUBREG_REG (value);
2031 if (GET_CODE (value) == REG)
2033 if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
2036 regno = REGNO (alter_subreg (home));
2039 /* The kind-of-variable letter depends on where
2040 the variable is and on the scope of its name:
2041 G and N_GSYM for static storage and global scope,
2042 S for static storage and file scope,
2043 V for static storage and local scope,
2044 for those two, use N_LCSYM if data is in bss segment,
2045 N_STSYM if in data segment, N_FUN otherwise.
2046 (We used N_FUN originally, then changed to N_STSYM
2047 to please GDB. However, it seems that confused ld.
2048 Now GDB has been fixed to like N_FUN, says Kingdon.)
2049 no letter at all, and N_LSYM, for auto variable,
2050 r and N_RSYM for register variable. */
2052 if (GET_CODE (home) == MEM
2053 && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
2055 if (TREE_PUBLIC (decl))
2058 current_sym_code = N_GSYM;
2062 current_sym_addr = XEXP (home, 0);
2064 letter = decl_function_context (decl) ? 'V' : 'S';
2066 /* This should be the same condition as in assemble_variable, but
2067 we don't have access to dont_output_data here. So, instead,
2068 we rely on the fact that error_mark_node initializers always
2069 end up in bss for C++ and never end up in bss for C. */
2070 if (DECL_INITIAL (decl) == 0
2071 || (!strcmp (lang_identify (), "cplusplus")
2072 && DECL_INITIAL (decl) == error_mark_node))
2073 current_sym_code = N_LCSYM;
2074 else if (DECL_IN_TEXT_SECTION (decl))
2075 /* This is not quite right, but it's the closest
2076 of all the codes that Unix defines. */
2077 current_sym_code = DBX_STATIC_CONST_VAR_CODE;
2080 /* Ultrix `as' seems to need this. */
2081 #ifdef DBX_STATIC_STAB_DATA_SECTION
2084 current_sym_code = N_STSYM;
2088 else if (regno >= 0)
2091 current_sym_code = N_RSYM;
2092 current_sym_value = DBX_REGISTER_NUMBER (regno);
2094 else if (GET_CODE (home) == MEM
2095 && (GET_CODE (XEXP (home, 0)) == MEM
2096 || (GET_CODE (XEXP (home, 0)) == REG
2097 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
2098 && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
2099 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2100 && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
2103 /* If the value is indirect by memory or by a register
2104 that isn't the frame pointer
2105 then it means the object is variable-sized and address through
2106 that register or stack slot. DBX has no way to represent this
2107 so all we can do is output the variable as a pointer.
2108 If it's not a parameter, ignore it.
2109 (VAR_DECLs like this can be made by integrate.c.) */
2111 if (GET_CODE (XEXP (home, 0)) == REG)
2114 current_sym_code = N_RSYM;
2115 current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
2119 current_sym_code = N_LSYM;
2120 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2121 We want the value of that CONST_INT. */
2123 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
2126 /* Effectively do build_pointer_type, but don't cache this type,
2127 since it might be temporary whereas the type it points to
2128 might have been saved for inlining. */
2129 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2130 type = make_node (POINTER_TYPE);
2131 TREE_TYPE (type) = TREE_TYPE (decl);
2133 else if (GET_CODE (home) == MEM
2134 && GET_CODE (XEXP (home, 0)) == REG)
2136 current_sym_code = N_LSYM;
2137 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2139 else if (GET_CODE (home) == MEM
2140 && GET_CODE (XEXP (home, 0)) == PLUS
2141 && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
2143 current_sym_code = N_LSYM;
2144 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2145 We want the value of that CONST_INT. */
2146 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2148 else if (GET_CODE (home) == MEM
2149 && GET_CODE (XEXP (home, 0)) == CONST)
2151 /* Handle an obscure case which can arise when optimizing and
2152 when there are few available registers. (This is *always*
2153 the case for i386/i486 targets). The RTL looks like
2154 (MEM (CONST ...)) even though this variable is a local `auto'
2155 or a local `register' variable. In effect, what has happened
2156 is that the reload pass has seen that all assignments and
2157 references for one such a local variable can be replaced by
2158 equivalent assignments and references to some static storage
2159 variable, thereby avoiding the need for a register. In such
2160 cases we're forced to lie to debuggers and tell them that
2161 this variable was itself `static'. */
2162 current_sym_code = N_LCSYM;
2164 current_sym_addr = XEXP (XEXP (home, 0), 0);
2166 else if (GET_CODE (home) == CONCAT)
2170 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
2171 for example), then there is no easy way to figure out
2172 what SUBTYPE should be. So, we give up. */
2173 if (TREE_CODE (type) != COMPLEX_TYPE)
2176 subtype = TREE_TYPE (type);
2178 /* If the variable's storage is in two parts,
2179 output each as a separate stab with a modified name. */
2180 if (WORDS_BIG_ENDIAN)
2181 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
2183 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
2185 /* Cast avoids warning in old compilers. */
2186 current_sym_code = (STAB_CODE_TYPE) 0;
2187 current_sym_value = 0;
2188 current_sym_addr = 0;
2189 dbxout_prepare_symbol (decl);
2191 if (WORDS_BIG_ENDIAN)
2192 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
2194 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
2198 /* Address might be a MEM, when DECL is a variable-sized object.
2199 Or it might be const0_rtx, meaning previous passes
2200 want us to ignore this variable. */
2203 /* Ok, start a symtab entry and output the variable name. */
2206 #ifdef DBX_STATIC_BLOCK_START
2207 DBX_STATIC_BLOCK_START (asmfile, current_sym_code);
2210 dbxout_symbol_name (decl, suffix, letter);
2211 dbxout_type (type, 0);
2212 dbxout_finish_symbol (decl);
2214 #ifdef DBX_STATIC_BLOCK_END
2215 DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
2220 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2221 Then output LETTER to indicate the kind of location the symbol has. */
2224 dbxout_symbol_name (decl, suffix, letter)
2231 if (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)))
2232 /* One slight hitch: if this is a VAR_DECL which is a static
2233 class member, we must put out the mangled name instead of the
2234 DECL_NAME. Note also that static member (variable) names DO NOT begin
2235 with underscores in .stabs directives. */
2236 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2238 /* ...but if we're function-local, we don't want to include the junk
2239 added by ASM_FORMAT_PRIVATE_NAME. */
2240 name = IDENTIFIER_POINTER (DECL_NAME (decl));
2244 fprintf (asmfile, "%s\"%s%s:", ASM_STABS_OP, name,
2245 (suffix ? suffix : ""));
2247 if (letter) putc (letter, asmfile);
2251 dbxout_prepare_symbol (decl)
2252 tree decl ATTRIBUTE_UNUSED;
2255 const char *filename = DECL_SOURCE_FILE (decl);
2257 dbxout_source_file (asmfile, filename);
2262 dbxout_finish_symbol (sym)
2265 #ifdef DBX_FINISH_SYMBOL
2266 DBX_FINISH_SYMBOL (sym);
2269 if (use_gnu_debug_info_extensions && sym != 0)
2270 line = DECL_SOURCE_LINE (sym);
2272 fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line);
2273 if (current_sym_addr)
2274 output_addr_const (asmfile, current_sym_addr);
2276 fprintf (asmfile, "%d", current_sym_value);
2277 putc ('\n', asmfile);
2281 /* Output definitions of all the decls in a chain. Return non-zero if
2282 anything was output */
2291 result += dbxout_symbol (syms, 1);
2292 syms = TREE_CHAIN (syms);
2297 /* The following two functions output definitions of function parameters.
2298 Each parameter gets a definition locating it in the parameter list.
2299 Each parameter that is a register variable gets a second definition
2300 locating it in the register.
2302 Printing or argument lists in gdb uses the definitions that
2303 locate in the parameter list. But reference to the variable in
2304 expressions uses preferentially the definition as a register. */
2306 /* Output definitions, referring to storage in the parmlist,
2307 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2310 dbxout_parms (parms)
2313 for (; parms; parms = TREE_CHAIN (parms))
2314 if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node)
2316 dbxout_prepare_symbol (parms);
2318 /* Perform any necessary register eliminations on the parameter's rtl,
2319 so that the debugging output will be accurate. */
2320 DECL_INCOMING_RTL (parms)
2321 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
2322 SET_DECL_RTL (parms, eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
2323 #ifdef LEAF_REG_REMAP
2324 if (current_function_uses_only_leaf_regs)
2326 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
2327 leaf_renumber_regs_insn (DECL_RTL (parms));
2331 if (PARM_PASSED_IN_MEMORY (parms))
2333 rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
2335 /* ??? Here we assume that the parm address is indexed
2336 off the frame pointer or arg pointer.
2337 If that is not true, we produce meaningless results,
2338 but do not crash. */
2339 if (GET_CODE (addr) == PLUS
2340 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
2341 current_sym_value = INTVAL (XEXP (addr, 1));
2343 current_sym_value = 0;
2345 current_sym_code = N_PSYM;
2346 current_sym_addr = 0;
2349 if (DECL_NAME (parms))
2351 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2353 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2354 IDENTIFIER_POINTER (DECL_NAME (parms)),
2355 DBX_MEMPARM_STABS_LETTER);
2359 current_sym_nchars = 8;
2360 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2361 DBX_MEMPARM_STABS_LETTER);
2364 /* It is quite tempting to use:
2366 dbxout_type (TREE_TYPE (parms), 0);
2368 as the next statement, rather than using DECL_ARG_TYPE(), so
2369 that gcc reports the actual type of the parameter, rather
2370 than the promoted type. This certainly makes GDB's life
2371 easier, at least for some ports. The change is a bad idea
2372 however, since GDB expects to be able access the type without
2373 performing any conversions. So for example, if we were
2374 passing a float to an unprototyped function, gcc will store a
2375 double on the stack, but if we emit a stab saying the type is a
2376 float, then gdb will only read in a single value, and this will
2377 produce an erropneous value. */
2378 dbxout_type (DECL_ARG_TYPE (parms), 0);
2379 current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
2380 dbxout_finish_symbol (parms);
2382 else if (GET_CODE (DECL_RTL (parms)) == REG)
2385 char regparm_letter;
2387 /* Parm passed in registers and lives in registers or nowhere. */
2389 current_sym_code = DBX_REGPARM_STABS_CODE;
2390 regparm_letter = DBX_REGPARM_STABS_LETTER;
2391 current_sym_addr = 0;
2393 /* If parm lives in a register, use that register;
2394 pretend the parm was passed there. It would be more consistent
2395 to describe the register where the parm was passed,
2396 but in practice that register usually holds something else.
2398 If we use DECL_RTL, then we must use the declared type of
2399 the variable, not the type that it arrived in. */
2400 if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2402 best_rtl = DECL_RTL (parms);
2403 parm_type = TREE_TYPE (parms);
2405 /* If the parm lives nowhere, use the register where it was
2406 passed. It is also better to use the declared type here. */
2409 best_rtl = DECL_INCOMING_RTL (parms);
2410 parm_type = TREE_TYPE (parms);
2412 current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
2415 if (DECL_NAME (parms))
2417 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2418 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2419 IDENTIFIER_POINTER (DECL_NAME (parms)),
2424 current_sym_nchars = 8;
2425 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2429 dbxout_type (parm_type, 0);
2430 dbxout_finish_symbol (parms);
2432 else if (GET_CODE (DECL_RTL (parms)) == MEM
2433 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2434 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
2435 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
2436 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2437 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
2441 /* Parm was passed via invisible reference.
2442 That is, its address was passed in a register.
2443 Output it as if it lived in that register.
2444 The debugger will know from the type
2445 that it was actually passed by invisible reference. */
2447 char regparm_letter;
2448 /* Parm passed in registers and lives in registers or nowhere. */
2450 current_sym_code = DBX_REGPARM_STABS_CODE;
2451 if (use_gnu_debug_info_extensions)
2452 regparm_letter = GDB_INV_REF_REGPARM_STABS_LETTER;
2454 regparm_letter = DBX_REGPARM_STABS_LETTER;
2456 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2457 If it is an unallocated pseudo-reg, then use the register where
2458 it was passed instead. */
2459 if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
2460 current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2462 current_sym_value = REGNO (DECL_INCOMING_RTL (parms));
2464 current_sym_addr = 0;
2467 if (DECL_NAME (parms))
2469 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2471 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2472 IDENTIFIER_POINTER (DECL_NAME (parms)),
2477 current_sym_nchars = 8;
2478 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2482 dbxout_type (TREE_TYPE (parms), 0);
2483 dbxout_finish_symbol (parms);
2485 else if (GET_CODE (DECL_RTL (parms)) == MEM
2486 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
2488 /* Parm was passed via invisible reference, with the reference
2489 living on the stack. DECL_RTL looks like
2490 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
2491 could look like (MEM (MEM (REG))). */
2492 const char *decl_name = (DECL_NAME (parms)
2493 ? IDENTIFIER_POINTER (DECL_NAME (parms))
2495 if (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 0)) == REG)
2496 current_sym_value = 0;
2499 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
2500 current_sym_addr = 0;
2503 fprintf (asmfile, "%s\"%s:v", ASM_STABS_OP, decl_name);
2504 dbxout_type (TREE_TYPE (parms), 0);
2505 dbxout_finish_symbol (parms);
2507 else if (GET_CODE (DECL_RTL (parms)) == MEM
2508 && XEXP (DECL_RTL (parms), 0) != const0_rtx
2509 /* ??? A constant address for a parm can happen
2510 when the reg it lives in is equiv to a constant in memory.
2511 Should make this not happen, after 2.4. */
2512 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
2514 /* Parm was passed in registers but lives on the stack. */
2516 current_sym_code = N_PSYM;
2517 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2518 in which case we want the value of that CONST_INT,
2520 in which case we use a value of zero. */
2521 if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG)
2522 current_sym_value = 0;
2525 = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
2527 current_sym_addr = 0;
2529 /* Make a big endian correction if the mode of the type of the
2530 parameter is not the same as the mode of the rtl. */
2531 if (BYTES_BIG_ENDIAN
2532 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
2533 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
2535 current_sym_value +=
2536 GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
2537 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms)));
2541 if (DECL_NAME (parms))
2544 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2546 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2547 IDENTIFIER_POINTER (DECL_NAME (parms)),
2548 DBX_MEMPARM_STABS_LETTER);
2552 current_sym_nchars = 8;
2553 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2554 DBX_MEMPARM_STABS_LETTER);
2558 = DEBUGGER_ARG_OFFSET (current_sym_value,
2559 XEXP (DECL_RTL (parms), 0));
2560 dbxout_type (TREE_TYPE (parms), 0);
2561 dbxout_finish_symbol (parms);
2566 /* Output definitions for the places where parms live during the function,
2567 when different from where they were passed, when the parms were passed
2570 It is not useful to do this for parms passed in registers
2571 that live during the function in different registers, because it is
2572 impossible to look in the passed register for the passed value,
2573 so we use the within-the-function register to begin with.
2575 PARMS is a chain of PARM_DECL nodes. */
2578 dbxout_reg_parms (parms)
2581 for (; parms; parms = TREE_CHAIN (parms))
2582 if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
2584 dbxout_prepare_symbol (parms);
2586 /* Report parms that live in registers during the function
2587 but were passed in memory. */
2588 if (GET_CODE (DECL_RTL (parms)) == REG
2589 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2590 dbxout_symbol_location (parms, TREE_TYPE (parms),
2591 0, DECL_RTL (parms));
2592 else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
2593 dbxout_symbol_location (parms, TREE_TYPE (parms),
2594 0, DECL_RTL (parms));
2595 /* Report parms that live in memory but not where they were passed. */
2596 else if (GET_CODE (DECL_RTL (parms)) == MEM
2597 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
2598 dbxout_symbol_location (parms, TREE_TYPE (parms),
2599 0, DECL_RTL (parms));
2603 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2604 output definitions of those names, in raw form */
2612 putc (',', asmfile);
2613 dbxout_type (TREE_VALUE (args), 0);
2615 args = TREE_CHAIN (args);
2619 /* Output everything about a symbol block (a BLOCK node
2620 that represents a scope level),
2621 including recursive output of contained blocks.
2623 BLOCK is the BLOCK node.
2624 DEPTH is its depth within containing symbol blocks.
2625 ARGS is usually zero; but for the outermost block of the
2626 body of a function, it is a chain of PARM_DECLs for the function parameters.
2627 We output definitions of all the register parms
2628 as if they were local variables of that block.
2630 If -g1 was used, we count blocks just the same, but output nothing
2631 except for the outermost block.
2633 Actually, BLOCK may be several blocks chained together.
2634 We handle them all in sequence. */
2637 dbxout_block (block, depth, args)
2638 register tree block;
2644 #if DBX_BLOCKS_FUNCTION_RELATIVE
2645 const char *begin_label;
2646 if (current_function_func_begin_label != NULL_TREE)
2647 begin_label = IDENTIFIER_POINTER (current_function_func_begin_label);
2649 begin_label = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
2654 /* Ignore blocks never expanded or otherwise marked as real. */
2655 if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
2659 #ifdef DBX_LBRAC_FIRST
2662 /* In dbx format, the syms of a block come before the N_LBRAC.
2663 If nothing is output, we don't need the N_LBRAC, either. */
2665 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2666 did_output = dbxout_syms (BLOCK_VARS (block));
2668 dbxout_reg_parms (args);
2671 /* Now output an N_LBRAC symbol to represent the beginning of
2672 the block. Use the block's tree-walk order to generate
2673 the assembler symbols LBBn and LBEn
2674 that final will define around the code in this block. */
2675 if (depth > 0 && did_output)
2678 blocknum = BLOCK_NUMBER (block);
2679 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
2681 if (BLOCK_HANDLER_BLOCK (block))
2683 /* A catch block. Must precede N_LBRAC. */
2684 tree decl = BLOCK_VARS (block);
2687 #ifdef DBX_OUTPUT_CATCH
2688 DBX_OUTPUT_CATCH (asmfile, decl, buf);
2690 fprintf (asmfile, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP,
2691 IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
2692 assemble_name (asmfile, buf);
2693 fprintf (asmfile, "\n");
2695 decl = TREE_CHAIN (decl);
2699 #ifdef DBX_OUTPUT_LBRAC
2700 DBX_OUTPUT_LBRAC (asmfile, buf);
2702 fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_LBRAC);
2703 assemble_name (asmfile, buf);
2704 #if DBX_BLOCKS_FUNCTION_RELATIVE
2705 fputc ('-', asmfile);
2706 assemble_name (asmfile, begin_label);
2708 fprintf (asmfile, "\n");
2712 #ifdef DBX_LBRAC_FIRST
2713 /* On some weird machines, the syms of a block
2714 come after the N_LBRAC. */
2715 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2716 dbxout_syms (BLOCK_VARS (block));
2718 dbxout_reg_parms (args);
2721 /* Output the subblocks. */
2722 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
2724 /* Refer to the marker for the end of the block. */
2725 if (depth > 0 && did_output)
2728 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
2729 #ifdef DBX_OUTPUT_RBRAC
2730 DBX_OUTPUT_RBRAC (asmfile, buf);
2732 fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_RBRAC);
2733 assemble_name (asmfile, buf);
2734 #if DBX_BLOCKS_FUNCTION_RELATIVE
2735 fputc ('-', asmfile);
2736 assemble_name (asmfile, begin_label);
2738 fprintf (asmfile, "\n");
2742 block = BLOCK_CHAIN (block);
2746 /* Output the information about a function and its arguments and result.
2747 Usually this follows the function's code,
2748 but on some systems, it comes before. */
2751 dbxout_begin_function (decl)
2754 dbxout_symbol (decl, 0);
2755 dbxout_parms (DECL_ARGUMENTS (decl));
2756 if (DECL_NAME (DECL_RESULT (decl)) != 0)
2757 dbxout_symbol (DECL_RESULT (decl), 1);
2760 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */