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. */
86 #ifdef XCOFF_DEBUGGING_INFO
91 #define ASM_STABS_OP "\t.stabs\t"
95 #define ASM_STABN_OP "\t.stabn\t"
98 #ifndef DBX_TYPE_DECL_STABS_CODE
99 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
102 #ifndef DBX_STATIC_CONST_VAR_CODE
103 #define DBX_STATIC_CONST_VAR_CODE N_FUN
106 #ifndef DBX_REGPARM_STABS_CODE
107 #define DBX_REGPARM_STABS_CODE N_RSYM
110 #ifndef DBX_REGPARM_STABS_LETTER
111 #define DBX_REGPARM_STABS_LETTER 'P'
114 /* This is used for parameters passed by invisible reference in a register. */
115 #ifndef GDB_INV_REF_REGPARM_STABS_LETTER
116 #define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
119 #ifndef DBX_MEMPARM_STABS_LETTER
120 #define DBX_MEMPARM_STABS_LETTER 'p'
123 #ifndef FILE_NAME_JOINER
124 #define FILE_NAME_JOINER "/"
127 /* Nonzero means if the type has methods, only output debugging
128 information if methods are actually written to the asm file. This
129 optimization only works if the debugger can detect the special C++
132 #define MINIMAL_DEBUG 1
134 #ifdef NO_DOLLAR_IN_LABEL
135 #ifdef NO_DOT_IN_LABEL
137 #define MINIMAL_DEBUG 0
141 /* Typical USG systems don't have stab.h, and they also have
142 no use for DBX-format debugging info. */
144 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
146 static int flag_minimal_debug = MINIMAL_DEBUG;
148 /* Nonzero if we have actually used any of the GDB extensions
149 to the debugging format. The idea is that we use them for the
150 first time only if there's a strong reason, but once we have done that,
151 we use them whenever convenient. */
153 static int have_used_extensions = 0;
155 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
156 for the N_SO filename stabs label. */
158 static int source_label_number = 1;
160 #ifdef DEBUG_SYMS_TEXT
161 #define FORCE_TEXT text_section ();
166 /* If there is a system stab.h, use it. Otherwise, use our own. */
167 /* ??? This is supposed to describe the target's stab format, so using
168 the host HAVE_STAB_H appears to be wrong. For now, we use our own file
169 when cross compiling. */
170 #if defined (USG) || !defined (HAVE_STAB_H) || defined (CROSS_COMPILE)
171 #include "gstab.h" /* If doing DBX on sysV, use our own stab.h. */
175 /* This is a GNU extension we need to reference in this file. */
182 #define STAB_CODE_TYPE enum __stab_debug_code
184 #define STAB_CODE_TYPE int
187 /* 1 if PARM is passed to this function in memory. */
189 #define PARM_PASSED_IN_MEMORY(PARM) \
190 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
192 /* A C expression for the integer offset value of an automatic variable
193 (N_LSYM) having address X (an RTX). */
194 #ifndef DEBUGGER_AUTO_OFFSET
195 #define DEBUGGER_AUTO_OFFSET(X) \
196 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
199 /* A C expression for the integer offset value of an argument (N_PSYM)
200 having address X (an RTX). The nominal offset is OFFSET. */
201 #ifndef DEBUGGER_ARG_OFFSET
202 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
205 /* Stream for writing to assembler file. */
207 static FILE *asmfile;
209 /* Last source file name mentioned in a NOTE insn. */
211 static const char *lastfile;
213 /* Current working directory. */
215 static const char *cwd;
217 enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
219 /* Structure recording information about a C data type.
220 The status element says whether we have yet output
221 the definition of the type. TYPE_XREF says we have
222 output it as a cross-reference only.
223 The file_number and type_number elements are used if DBX_USE_BINCL
228 enum typestatus status;
235 /* Vector recording information about C data types.
236 When we first notice a data type (a tree node),
237 we assign it a number using next_type_number.
238 That is its index in this vector. */
240 struct typeinfo *typevec;
242 /* Number of elements of space allocated in `typevec'. */
244 static int typevec_len;
246 /* In dbx output, each type gets a unique number.
247 This is the number for the next type output.
248 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
250 static int next_type_number;
254 /* When using N_BINCL in dbx output, each type number is actually a
255 pair of the file number and the type number within the file.
256 This is a stack of input files. */
260 struct dbx_file *next;
262 int next_type_number;
265 /* This is the top of the stack. */
267 static struct dbx_file *current_file;
269 /* This is the next file number to use. */
271 static int next_file_number;
273 #endif /* DBX_USE_BINCL */
275 /* These variables are for dbxout_symbol to communicate to
276 dbxout_finish_symbol.
277 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
278 current_sym_value and current_sym_addr are two ways to address the
279 value to store in the symtab entry.
280 current_sym_addr if nonzero represents the value as an rtx.
281 If that is zero, current_sym_value is used. This is used
282 when the value is an offset (such as for auto variables,
283 register variables and parms). */
285 static STAB_CODE_TYPE current_sym_code;
286 static int current_sym_value;
287 static rtx current_sym_addr;
289 /* Number of chars of symbol-description generated so far for the
290 current symbol. Used by CHARS and CONTIN. */
292 static int current_sym_nchars;
294 /* Report having output N chars of the current symbol-description. */
296 #define CHARS(N) (current_sym_nchars += (N))
298 /* Break the current symbol-description, generating a continuation,
299 if it has become long. */
301 #ifndef DBX_CONTIN_LENGTH
302 #define DBX_CONTIN_LENGTH 80
305 #if DBX_CONTIN_LENGTH > 0
307 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
309 #define CONTIN do { } while (0)
312 #if defined(ASM_OUTPUT_SECTION_NAME)
313 static void dbxout_function_end PARAMS ((void));
315 static void dbxout_typedefs PARAMS ((tree));
316 static void dbxout_type_index PARAMS ((tree));
317 #if DBX_CONTIN_LENGTH > 0
318 static void dbxout_continue PARAMS ((void));
320 static void dbxout_type_fields PARAMS ((tree));
321 static void dbxout_type_method_1 PARAMS ((tree, const char *));
322 static void dbxout_type_methods PARAMS ((tree));
323 static void dbxout_range_type PARAMS ((tree));
324 static void dbxout_type PARAMS ((tree, int, int));
325 static void print_int_cst_octal PARAMS ((tree));
326 static void print_octal PARAMS ((unsigned HOST_WIDE_INT, int));
327 static void dbxout_type_name PARAMS ((tree));
328 static int dbxout_symbol_location PARAMS ((tree, tree, const char *, rtx));
329 static void dbxout_symbol_name PARAMS ((tree, const char *, int));
330 static void dbxout_prepare_symbol PARAMS ((tree));
331 static void dbxout_finish_symbol PARAMS ((tree));
332 static void dbxout_block PARAMS ((tree, int, tree));
333 static void dbxout_really_begin_function PARAMS ((tree));
335 #if defined(ASM_OUTPUT_SECTION_NAME)
337 dbxout_function_end ()
339 static int scope_labelno = 0;
340 char lscope_label_name[100];
341 /* Convert Ltext into the appropriate format for local labels in case
342 the system doesn't insert underscores in front of user generated
344 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
345 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Lscope", scope_labelno);
348 /* By convention, GCC will mark the end of a function with an N_FUN
349 symbol and an empty string. */
350 fprintf (asmfile, "%s\"\",%d,0,0,", ASM_STABS_OP, N_FUN);
351 assemble_name (asmfile, lscope_label_name);
352 fputc ('-', asmfile);
353 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
354 fprintf (asmfile, "\n");
356 #endif /* ! NO_DBX_FUNCTION_END */
358 /* At the beginning of compilation, start writing the symbol table.
359 Initialize `typevec' and output the standard data types of C. */
362 dbxout_init (asm_file, input_file_name, syms)
364 const char *input_file_name;
367 char ltext_label_name[100];
372 typevec = (struct typeinfo *) xcalloc (typevec_len, sizeof typevec[0]);
374 /* Convert Ltext into the appropriate format for local labels in case
375 the system doesn't insert underscores in front of user generated
377 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
379 /* Put the current working directory in an N_SO symbol. */
380 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
381 but GDB always does. */
382 if (use_gnu_debug_info_extensions)
385 if (!cwd && (cwd = getpwd ()) && (!*cwd || cwd[strlen (cwd) - 1] != '/'))
387 char *wdslash = xmalloc (strlen (cwd) + sizeof (FILE_NAME_JOINER));
388 sprintf (wdslash, "%s%s", cwd, FILE_NAME_JOINER);
393 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
394 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd);
395 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
396 fprintf (asmfile, "%s", ASM_STABS_OP);
397 output_quoted_string (asmfile, cwd);
398 fprintf (asmfile, ",%d,0,0,%s\n", N_SO, <ext_label_name[1]);
399 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
403 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
404 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
405 would give us an N_SOL, and we want an N_SO. */
406 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile, input_file_name);
407 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
408 /* We include outputting `Ltext:' here,
409 because that gives you a way to override it. */
410 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
411 fprintf (asmfile, "%s", ASM_STABS_OP);
412 output_quoted_string (asmfile, input_file_name);
413 fprintf (asmfile, ",%d,0,0,%s\n",
414 N_SO, <ext_label_name[1]);
416 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Ltext", 0);
417 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
419 /* Possibly output something to inform GDB that this compilation was by
420 GCC. It's easier for GDB to parse it when after the N_SO's. This
421 is used in Solaris 2. */
422 #ifdef ASM_IDENTIFY_GCC_AFTER_SOURCE
423 ASM_IDENTIFY_GCC_AFTER_SOURCE (asmfile);
426 lastfile = input_file_name;
428 next_type_number = 1;
431 current_file = (struct dbx_file *) xmalloc (sizeof *current_file);
432 current_file->next = NULL;
433 current_file->file_number = 0;
434 current_file->next_type_number = 1;
435 next_file_number = 1;
438 /* Make sure that types `int' and `char' have numbers 1 and 2.
439 Definitions of other integer types will refer to those numbers.
440 (Actually it should no longer matter what their numbers are.
441 Also, if any types with tags have been defined, dbxout_symbol
442 will output them first, so the numbers won't be 1 and 2. That
443 happens in C++. So it's a good thing it should no longer matter). */
445 #ifdef DBX_OUTPUT_STANDARD_TYPES
446 DBX_OUTPUT_STANDARD_TYPES (syms);
448 dbxout_symbol (TYPE_NAME (integer_type_node), 0);
449 dbxout_symbol (TYPE_NAME (char_type_node), 0);
452 /* Get all permanent types that have typedef names,
453 and output them all, except for those already output. */
455 dbxout_typedefs (syms);
458 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
459 in the reverse order from that which is found in SYMS. */
462 dbxout_typedefs (syms)
467 dbxout_typedefs (TREE_CHAIN (syms));
468 if (TREE_CODE (syms) == TYPE_DECL)
470 tree type = TREE_TYPE (syms);
472 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
473 && COMPLETE_TYPE_P (type)
474 && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
475 dbxout_symbol (TYPE_NAME (type), 0);
480 /* Change to reading from a new source file. Generate a N_BINCL stab. */
483 dbxout_start_new_source_file (filename)
484 const char *filename ATTRIBUTE_UNUSED;
487 struct dbx_file *n = (struct dbx_file *) xmalloc (sizeof *n);
489 n->next = current_file;
490 n->file_number = next_file_number++;
491 n->next_type_number = 1;
493 fprintf (asmfile, "%s", ASM_STABS_OP);
494 output_quoted_string (asmfile, filename);
495 fprintf (asmfile, ",%d,0,0,0\n", N_BINCL);
499 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
502 dbxout_resume_previous_source_file ()
505 struct dbx_file *next;
507 fprintf (asmfile, "%s%d,0,0,0\n", ASM_STABN_OP, N_EINCL);
508 next = current_file->next;
514 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
517 dbxout_source_file (file, filename)
519 const char *filename;
521 char ltext_label_name[100];
523 if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
525 #ifdef DBX_OUTPUT_SOURCE_FILENAME
526 DBX_OUTPUT_SOURCE_FILENAME (file, filename);
528 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext",
529 source_label_number);
530 fprintf (file, "%s", ASM_STABS_OP);
531 output_quoted_string (file, filename);
532 fprintf (file, ",%d,0,0,%s\n", N_SOL, <ext_label_name[1]);
533 if (current_function_decl != NULL_TREE
534 && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
535 ; /* Don't change section amid function. */
538 ASM_OUTPUT_INTERNAL_LABEL (file, "Ltext", source_label_number);
539 source_label_number++;
545 /* Output a line number symbol entry into output stream FILE,
546 for source file FILENAME and line number LINENO. */
549 dbxout_source_line (file, filename, lineno)
551 const char *filename;
554 dbxout_source_file (file, filename);
556 #ifdef ASM_OUTPUT_SOURCE_LINE
557 ASM_OUTPUT_SOURCE_LINE (file, lineno);
559 fprintf (file, "%s%d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno);
563 /* At the end of compilation, finish writing the symbol table.
564 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
568 dbxout_finish (file, filename)
569 FILE *file ATTRIBUTE_UNUSED;
570 const char *filename ATTRIBUTE_UNUSED;
572 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
573 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file, filename);
574 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
577 /* Output the index of a type. */
580 dbxout_type_index (type)
583 #ifndef DBX_USE_BINCL
584 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
587 struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
588 fprintf (asmfile, "(%d,%d)", t->file_number, t->type_number);
593 #if DBX_CONTIN_LENGTH > 0
594 /* Continue a symbol-description that gets too big.
595 End one symbol table entry with a double-backslash
596 and start a new one, eventually producing something like
597 .stabs "start......\\",code,0,value
598 .stabs "...rest",code,0,value */
603 #ifdef DBX_CONTIN_CHAR
604 fprintf (asmfile, "%c", DBX_CONTIN_CHAR);
606 fprintf (asmfile, "\\\\");
608 dbxout_finish_symbol (NULL_TREE);
609 fprintf (asmfile, "%s\"", ASM_STABS_OP);
610 current_sym_nchars = 0;
612 #endif /* DBX_CONTIN_LENGTH > 0 */
614 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
615 This must be a separate function because anonymous unions require
619 dbxout_type_fields (type)
624 /* Output the name, type, position (in bits), size (in bits) of each
625 field that we can support. */
626 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
628 /* Omit here local type decls until we know how to support them. */
629 if (TREE_CODE (tem) == TYPE_DECL
630 /* Omit fields whose position or size are variable or too large to
632 || (TREE_CODE (tem) == FIELD_DECL
633 && (! host_integerp (bit_position (tem), 0)
635 || ! host_integerp (DECL_SIZE (tem), 1)))
636 /* Omit here the nameless fields that are used to skip bits. */
637 || DECL_IGNORED_P (tem))
640 else if (TREE_CODE (tem) != CONST_DECL)
642 /* Continue the line if necessary,
643 but not before the first field. */
644 if (tem != TYPE_FIELDS (type))
647 if (use_gnu_debug_info_extensions
648 && flag_minimal_debug
649 && TREE_CODE (tem) == FIELD_DECL
650 && DECL_VIRTUAL_P (tem)
651 && DECL_ASSEMBLER_NAME (tem))
653 have_used_extensions = 1;
654 CHARS (3 + IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (tem)));
655 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem)), asmfile);
656 dbxout_type (DECL_FCONTEXT (tem), 0, 0);
657 fprintf (asmfile, ":");
658 dbxout_type (TREE_TYPE (tem), 0, 0);
659 fputc (',', asmfile);
660 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
661 int_bit_position (tem));
662 fputc (';', asmfile);
668 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
669 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem)));
673 fprintf (asmfile, ":");
677 if (use_gnu_debug_info_extensions
678 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
679 || TREE_CODE (tem) != FIELD_DECL))
681 have_used_extensions = 1;
683 putc ((TREE_PRIVATE (tem) ? '0'
684 : TREE_PROTECTED (tem) ? '1' : '2'),
689 dbxout_type ((TREE_CODE (tem) == FIELD_DECL
690 && DECL_BIT_FIELD_TYPE (tem))
691 ? DECL_BIT_FIELD_TYPE (tem) : TREE_TYPE (tem), 0, 0);
693 if (TREE_CODE (tem) == VAR_DECL)
695 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
698 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem));
699 have_used_extensions = 1;
700 fprintf (asmfile, ":%s;", name);
701 CHARS (strlen (name));
704 /* If TEM is non-static, GDB won't understand it. */
705 fprintf (asmfile, ",0,0;");
709 fputc (',', asmfile);
710 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
711 int_bit_position (tem));
712 fputc (',', asmfile);
713 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
714 tree_low_cst (DECL_SIZE (tem), 1));
715 fputc (';', asmfile);
722 /* Subroutine of `dbxout_type_methods'. Output debug info about the
723 method described DECL. DEBUG_NAME is an encoding of the method's
724 type signature. ??? We may be able to do without DEBUG_NAME altogether
728 dbxout_type_method_1 (decl, debug_name)
730 const char *debug_name;
734 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
736 else /* it's a METHOD_TYPE. */
738 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
739 /* A for normal functions.
740 B for `const' member functions.
741 C for `volatile' member functions.
742 D for `const volatile' member functions. */
743 if (TYPE_READONLY (TREE_TYPE (firstarg)))
745 if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
748 if (DECL_VINDEX (decl))
754 fprintf (asmfile, ":%s;%c%c%c", debug_name,
755 TREE_PRIVATE (decl) ? '0'
756 : TREE_PROTECTED (decl) ? '1' : '2', c1, c2);
757 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)) + 6
758 - (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
760 if (DECL_VINDEX (decl) && host_integerp (DECL_VINDEX (decl), 0))
762 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
763 tree_low_cst (DECL_VINDEX (decl), 0));
764 fputc (';', asmfile);
765 dbxout_type (DECL_CONTEXT (decl), 0, 0);
766 fprintf (asmfile, ";");
771 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
775 dbxout_type_methods (type)
778 /* C++: put out the method names and their parameter lists */
779 tree methods = TYPE_METHODS (type);
781 register tree fndecl;
783 char formatted_type_identifier_length[16];
784 register int type_identifier_length;
786 if (methods == NULL_TREE)
789 type_encoding = DECL_NAME (TYPE_NAME (type));
792 /* C++: Template classes break some assumptions made by this code about
793 the class names, constructor names, and encodings for assembler
794 label names. For now, disable output of dbx info for them. */
796 const char *ptr = IDENTIFIER_POINTER (type_encoding);
797 /* This should use index. (mrs) */
798 while (*ptr && *ptr != '<') ptr++;
809 type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
811 sprintf(formatted_type_identifier_length, "%d", type_identifier_length);
813 if (TREE_CODE (methods) != TREE_VEC)
815 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
816 fndecl = TREE_VEC_ELT (methods, 0);
818 fndecl = TREE_VEC_ELT (methods, 1);
822 tree name = DECL_NAME (fndecl);
825 /* Group together all the methods for the same operation.
826 These differ in the types of the arguments. */
827 for (last = NULL_TREE;
828 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
829 fndecl = TREE_CHAIN (fndecl))
830 /* Output the name of the field (after overloading), as
831 well as the name of the field before overloading, along
832 with its parameter list */
834 /* This is the "mangled" name of the method.
835 It encodes the argument types. */
836 const char *debug_name =
837 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
838 int show_arg_types = 0;
844 /* Also ignore abstract methods; those are only interesting to
845 the DWARF backends. */
846 if (DECL_IGNORED_P (fndecl) || DECL_ABSTRACT (fndecl))
849 if (flag_minimal_debug)
853 /* We can't optimize a method which uses an anonymous
854 class, because the debugger will not be able to
855 associate the arbitrary class name with the actual
857 #ifndef NO_DOLLAR_IN_LABEL
862 if (strchr (debug_name, marker))
864 /* Detect ordinary methods because their mangled names
865 start with the operation name. */
866 else if (!strncmp (IDENTIFIER_POINTER (name), debug_name,
867 IDENTIFIER_LENGTH (name)))
869 debug_name += IDENTIFIER_LENGTH (name);
870 if (debug_name[0] == '_' && debug_name[1] == '_')
872 const char *method_name = debug_name + 2;
873 const char *length_ptr =
874 formatted_type_identifier_length;
875 /* Get past const and volatile qualifiers. */
876 while (*method_name == 'C' || *method_name == 'V')
878 /* Skip digits for length of type_encoding. */
879 while (*method_name == *length_ptr && *length_ptr)
880 length_ptr++, method_name++;
881 if (! strncmp (method_name,
882 IDENTIFIER_POINTER (type_encoding),
883 type_identifier_length))
884 method_name += type_identifier_length;
885 debug_name = method_name;
888 /* Detect constructors by their style of name mangling. */
889 else if (debug_name[0] == '_' && debug_name[1] == '_')
891 const char *ctor_name = debug_name + 2;
892 const char *length_ptr = formatted_type_identifier_length;
893 while (*ctor_name == 'C' || *ctor_name == 'V')
895 /* Skip digits for length of type_encoding. */
896 while (*ctor_name == *length_ptr && *length_ptr)
897 length_ptr++, ctor_name++;
898 if (!strncmp (IDENTIFIER_POINTER (type_encoding), ctor_name,
899 type_identifier_length))
900 debug_name = ctor_name + type_identifier_length;
902 /* The other alternative is a destructor. */
906 /* Output the operation name just once, for the first method
910 fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
911 CHARS (IDENTIFIER_LENGTH (name) + 2);
916 dbxout_type (TREE_TYPE (fndecl), 0, show_arg_types);
918 dbxout_type_method_1 (fndecl, debug_name);
928 /* Emit a "range" type specification, which has the form:
929 "r<index type>;<lower bound>;<upper bound>;".
930 TYPE is an INTEGER_TYPE. */
933 dbxout_range_type (type)
936 fprintf (asmfile, "r");
937 if (TREE_TYPE (type))
938 dbxout_type (TREE_TYPE (type), 0, 0);
939 else if (TREE_CODE (type) != INTEGER_TYPE)
940 dbxout_type (type, 0, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
943 /* Traditionally, we made sure 'int' was type 1, and builtin types
944 were defined to be sub-ranges of int. Unfortunately, this
945 does not allow us to distinguish true sub-ranges from integer
946 types. So, instead we define integer (non-sub-range) types as
947 sub-ranges of themselves. This matters for Chill. If this isn't
948 a subrange type, then we want to define it in terms of itself.
949 However, in C, this may be an anonymous integer type, and we don't
950 want to emit debug info referring to it. Just calling
951 dbxout_type_index won't work anyways, because the type hasn't been
952 defined yet. We make this work for both cases by checked to see
953 whether this is a defined type, referring to it if it is, and using
955 if (TYPE_SYMTAB_ADDRESS (type) != 0)
956 dbxout_type_index (type);
958 dbxout_type_index (integer_type_node);
961 if (TYPE_MIN_VALUE (type) != 0
962 && host_integerp (TYPE_MIN_VALUE (type), 0))
964 fputc (';', asmfile);
965 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
966 tree_low_cst (TYPE_MIN_VALUE (type), 0));
969 fprintf (asmfile, ";0");
971 if (TYPE_MAX_VALUE (type) != 0
972 && host_integerp (TYPE_MAX_VALUE (type), 0))
974 fputc (';', asmfile);
975 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
976 tree_low_cst (TYPE_MAX_VALUE (type), 0));
977 fputc (';', asmfile);
980 fprintf (asmfile, ";-1;");
983 /* Output a reference to a type. If the type has not yet been
984 described in the dbx output, output its definition now.
985 For a type already defined, just refer to its definition
986 using the type number.
988 If FULL is nonzero, and the type has been described only with
989 a forward-reference, output the definition now.
990 If FULL is zero in this case, just refer to the forward-reference
991 using the number previously allocated.
993 If SHOW_ARG_TYPES is nonzero, we output a description of the argument
994 types for a METHOD_TYPE. */
997 dbxout_type (type, full, show_arg_types)
1003 static int anonymous_type_number = 0;
1005 if (TREE_CODE (type) == VECTOR_TYPE)
1006 type = TYPE_DEBUG_REPRESENTATION_TYPE (type);
1008 /* If there was an input error and we don't really have a type,
1009 avoid crashing and write something that is at least valid
1010 by assuming `int'. */
1011 if (type == error_mark_node)
1012 type = integer_type_node;
1015 /* Try to find the "main variant" with the same name but not const
1016 or volatile. (Since stabs does not distinguish const and volatile,
1017 there is no need to make them separate types. But types with
1018 different names are usefully distinguished.) */
1020 for (tem = TYPE_MAIN_VARIANT (type); tem; tem = TYPE_NEXT_VARIANT (tem))
1021 if (!TYPE_READONLY (tem) && !TYPE_VOLATILE (tem)
1022 && TYPE_NAME (tem) == TYPE_NAME (type))
1027 if (TYPE_NAME (type)
1028 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1029 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
1033 if (TYPE_SYMTAB_ADDRESS (type) == 0)
1035 /* Type has no dbx number assigned. Assign next available number. */
1036 TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
1038 /* Make sure type vector is long enough to record about this type. */
1040 if (next_type_number == typevec_len)
1043 = (struct typeinfo *) xrealloc (typevec,
1044 typevec_len * 2 * sizeof typevec[0]);
1045 memset ((char *) (typevec + typevec_len), 0,
1046 typevec_len * sizeof typevec[0]);
1050 #ifdef DBX_USE_BINCL
1051 typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
1052 = current_file->file_number;
1053 typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
1054 = current_file->next_type_number++;
1058 /* Output the number of this type, to refer to it. */
1059 dbxout_type_index (type);
1061 #ifdef DBX_TYPE_DEFINED
1062 if (DBX_TYPE_DEFINED (type))
1066 /* If this type's definition has been output or is now being output,
1069 switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
1074 /* If we have already had a cross reference,
1075 and either that's all we want or that's the best we could do,
1076 don't repeat the cross reference.
1077 Sun dbx crashes if we do. */
1078 if (! full || !COMPLETE_TYPE_P (type)
1079 /* No way in DBX fmt to describe a variable size. */
1080 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1088 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1089 leave the type-number completely undefined rather than output
1090 a cross-reference. If we have already used GNU debug info extensions,
1091 then it is OK to output a cross reference. This is necessary to get
1092 proper C++ debug output. */
1093 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
1094 || TREE_CODE (type) == QUAL_UNION_TYPE
1095 || TREE_CODE (type) == ENUMERAL_TYPE)
1096 && ! use_gnu_debug_info_extensions)
1097 /* We must use the same test here as we use twice below when deciding
1098 whether to emit a cross-reference. */
1099 if ((TYPE_NAME (type) != 0
1100 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1101 && DECL_IGNORED_P (TYPE_NAME (type)))
1103 || !COMPLETE_TYPE_P (type)
1104 /* No way in DBX fmt to describe a variable size. */
1105 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1107 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1112 /* Output a definition now. */
1114 fprintf (asmfile, "=");
1117 /* Mark it as defined, so that if it is self-referent
1118 we will not get into an infinite recursion of definitions. */
1120 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
1122 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1123 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1125 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0, 0);
1129 switch (TREE_CODE (type))
1133 /* For a void type, just define it as itself; ie, "5=5".
1134 This makes us consider it defined
1135 without saying what it is. The debugger will make it
1136 a void type when the reference is seen, and nothing will
1137 ever override that default. */
1138 dbxout_type_index (type);
1142 if (type == char_type_node && ! TREE_UNSIGNED (type))
1144 /* Output the type `char' as a subrange of itself!
1145 I don't understand this definition, just copied it
1146 from the output of pcc.
1147 This used to use `r2' explicitly and we used to
1148 take care to make sure that `char' was type number 2. */
1149 fprintf (asmfile, "r");
1150 dbxout_type_index (type);
1151 fprintf (asmfile, ";0;127;");
1154 /* If this is a subtype of another integer type, always prefer to
1155 write it as a subtype. */
1156 else if (TREE_TYPE (type) != 0
1157 && TREE_CODE (TREE_TYPE (type)) == INTEGER_CST)
1158 dbxout_range_type (type);
1162 /* If the size is non-standard, say what it is if we can use
1165 if (use_gnu_debug_info_extensions
1166 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1167 fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1169 /* If we can use GDB extensions and the size is wider than a
1170 long (the size used by GDB to read them) or we may have
1171 trouble writing the bounds the usual way, write them in
1172 octal. Note the test is for the *target's* size of "long",
1173 not that of the host. The host test is just to make sure we
1174 can write it out in case the host wide int is narrower than the
1177 /* For unsigned types, we use octal if they are the same size or
1178 larger. This is because we print the bounds as signed decimal,
1179 and hence they can't span same size unsigned types. */
1181 if (use_gnu_debug_info_extensions
1182 && TYPE_MIN_VALUE (type) != 0
1183 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
1184 && TYPE_MAX_VALUE (type) != 0
1185 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
1186 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
1187 || (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)
1188 && TREE_UNSIGNED (type))
1189 || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
1190 || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
1191 && TREE_UNSIGNED (type))))
1193 fprintf (asmfile, "r");
1194 dbxout_type_index (type);
1195 fprintf (asmfile, ";");
1196 print_int_cst_octal (TYPE_MIN_VALUE (type));
1197 fprintf (asmfile, ";");
1198 print_int_cst_octal (TYPE_MAX_VALUE (type));
1199 fprintf (asmfile, ";");
1203 /* Output other integer types as subranges of `int'. */
1204 dbxout_range_type (type);
1211 /* This used to say `r1' and we used to take care
1212 to make sure that `int' was type number 1. */
1213 fprintf (asmfile, "r");
1214 dbxout_type_index (integer_type_node);
1215 fputc (';', asmfile);
1216 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, int_size_in_bytes (type));
1217 fputs (";0;", asmfile);
1222 if (use_gnu_debug_info_extensions)
1224 fputs ("@s", asmfile);
1225 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1226 BITS_PER_UNIT * int_size_in_bytes (type));
1227 fputs (";-20;", asmfile);
1231 /* Output the type `char' as a subrange of itself.
1232 That is what pcc seems to do. */
1233 fprintf (asmfile, "r");
1234 dbxout_type_index (char_type_node);
1235 fprintf (asmfile, ";0;%d;", TREE_UNSIGNED (type) ? 255 : 127);
1241 if (use_gnu_debug_info_extensions)
1243 fputs ("@s", asmfile);
1244 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1245 BITS_PER_UNIT * int_size_in_bytes (type));
1246 fputs (";-16;", asmfile);
1248 else /* Define as enumeral type (False, True) */
1249 fprintf (asmfile, "eFalse:0,True:1,;");
1254 putc ('d', asmfile);
1256 dbxout_type (TREE_TYPE (type), 0, 0);
1260 /* Differs from the REAL_TYPE by its new data type number */
1262 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1264 fprintf (asmfile, "r");
1265 dbxout_type_index (type);
1266 fputc (';', asmfile);
1267 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1268 2 * int_size_in_bytes (TREE_TYPE (type)));
1269 fputs (";0;", asmfile);
1270 CHARS (12); /* The number is probably incorrect here. */
1274 /* Output a complex integer type as a structure,
1275 pending some other way to do it. */
1276 fputc ('s', asmfile);
1277 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, int_size_in_bytes (type));
1279 fprintf (asmfile, "real:");
1281 dbxout_type (TREE_TYPE (type), 0, 0);
1282 fprintf (asmfile, ",%d,%d;",
1283 0, TYPE_PRECISION (TREE_TYPE (type)));
1285 fprintf (asmfile, "imag:");
1287 dbxout_type (TREE_TYPE (type), 0, 0);
1288 fprintf (asmfile, ",%d,%d;;",
1289 TYPE_PRECISION (TREE_TYPE (type)),
1290 TYPE_PRECISION (TREE_TYPE (type)));
1296 if (use_gnu_debug_info_extensions)
1298 have_used_extensions = 1;
1299 fputs ("@s", asmfile);
1300 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1301 BITS_PER_UNIT * int_size_in_bytes (type));
1302 fputc (';', asmfile);
1303 /* Check if a bitstring type, which in Chill is
1304 different from a [power]set. */
1305 if (TYPE_STRING_FLAG (type))
1306 fprintf (asmfile, "@S;");
1308 putc ('S', asmfile);
1310 dbxout_type (TYPE_DOMAIN (type), 0, 0);
1314 /* Make arrays of packed bits look like bitstrings for chill. */
1315 if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
1317 have_used_extensions = 1;
1318 fputs ("@s", asmfile);
1319 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1320 BITS_PER_UNIT * int_size_in_bytes (type));
1321 fputc (';', asmfile);
1322 fprintf (asmfile, "@S;");
1323 putc ('S', asmfile);
1325 dbxout_type (TYPE_DOMAIN (type), 0, 0);
1328 /* Output "a" followed by a range type definition
1329 for the index type of the array
1330 followed by a reference to the target-type.
1331 ar1;0;N;M for a C array of type M and size N+1. */
1332 /* Check if a character string type, which in Chill is
1333 different from an array of characters. */
1334 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
1336 have_used_extensions = 1;
1337 fprintf (asmfile, "@S;");
1339 tem = TYPE_DOMAIN (type);
1342 fprintf (asmfile, "ar");
1343 dbxout_type_index (integer_type_node);
1344 fprintf (asmfile, ";0;-1;");
1348 fprintf (asmfile, "a");
1349 dbxout_range_type (tem);
1352 dbxout_type (TREE_TYPE (type), 0, 0);
1357 case QUAL_UNION_TYPE:
1359 int i, n_baseclasses = 0;
1361 if (TYPE_BINFO (type) != 0
1362 && TREE_CODE (TYPE_BINFO (type)) == TREE_VEC
1363 && TYPE_BINFO_BASETYPES (type) != 0)
1364 n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
1366 /* Output a structure type. We must use the same test here as we
1367 use in the DBX_NO_XREFS case above. */
1368 if ((TYPE_NAME (type) != 0
1369 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1370 && DECL_IGNORED_P (TYPE_NAME (type)))
1372 || !COMPLETE_TYPE_P (type)
1373 /* No way in DBX fmt to describe a variable size. */
1374 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1376 /* If the type is just a cross reference, output one
1377 and mark the type as partially described.
1378 If it later becomes defined, we will output
1379 its real definition.
1380 If the type has a name, don't nest its definition within
1381 another type's definition; instead, output an xref
1382 and let the definition come when the name is defined. */
1383 fputs ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu", asmfile);
1385 #if 0 /* This assertion is legitimately false in C++. */
1386 /* We shouldn't be outputting a reference to a type before its
1387 definition unless the type has a tag name.
1388 A typedef name without a tag name should be impossible. */
1389 if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
1392 if (TYPE_NAME (type) != 0)
1393 dbxout_type_name (type);
1395 fprintf (asmfile, "$$%d", anonymous_type_number++);
1396 fprintf (asmfile, ":");
1397 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1401 /* Identify record or union, and print its size. */
1402 fputc (((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'), asmfile);
1403 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1404 int_size_in_bytes (type));
1406 if (use_gnu_debug_info_extensions)
1410 have_used_extensions = 1;
1411 fprintf (asmfile, "!%d,", n_baseclasses);
1415 for (i = 0; i < n_baseclasses; i++)
1417 tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i);
1419 if (use_gnu_debug_info_extensions)
1421 have_used_extensions = 1;
1422 putc (TREE_VIA_VIRTUAL (child) ? '1' : '0', asmfile);
1423 putc (TREE_VIA_PUBLIC (child) ? '2' : '0', asmfile);
1424 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1425 (tree_low_cst (BINFO_OFFSET (child), 0)
1427 fputc (',', asmfile);
1429 dbxout_type (BINFO_TYPE (child), 0, 0);
1430 putc (';', asmfile);
1434 /* Print out the base class information with fields
1435 which have the same names at the types they hold. */
1436 dbxout_type_name (BINFO_TYPE (child));
1437 putc (':', asmfile);
1438 dbxout_type (BINFO_TYPE (child), full, 0);
1439 fputc (',', asmfile);
1440 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1441 tree_low_cst (BINFO_OFFSET (child), 0)
1443 fputc (',', asmfile);
1444 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1445 (tree_low_cst (DECL_SIZE (TYPE_NAME
1446 (BINFO_TYPE (child))), 0)
1448 fputc (';', asmfile);
1456 /* Write out the field declarations. */
1457 dbxout_type_fields (type);
1458 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
1460 have_used_extensions = 1;
1461 dbxout_type_methods (type);
1464 putc (';', asmfile);
1466 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
1467 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1468 && TYPE_VFIELD (type))
1470 have_used_extensions = 1;
1472 /* Tell GDB+ that it may keep reading. */
1473 putc ('~', asmfile);
1475 /* We need to write out info about what field this class
1476 uses as its "main" vtable pointer field, because if this
1477 field is inherited from a base class, GDB cannot necessarily
1478 figure out which field it's using in time. */
1479 if (TYPE_VFIELD (type))
1481 putc ('%', asmfile);
1482 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0, 0);
1484 putc (';', asmfile);
1490 /* We must use the same test here as we use in the DBX_NO_XREFS case
1491 above. We simplify it a bit since an enum will never have a variable
1493 if ((TYPE_NAME (type) != 0
1494 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1495 && DECL_IGNORED_P (TYPE_NAME (type)))
1497 || !COMPLETE_TYPE_P (type))
1499 fprintf (asmfile, "xe");
1501 dbxout_type_name (type);
1502 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1503 fprintf (asmfile, ":");
1506 #ifdef DBX_OUTPUT_ENUM
1507 DBX_OUTPUT_ENUM (asmfile, type);
1509 if (use_gnu_debug_info_extensions
1510 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1511 fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1512 putc ('e', asmfile);
1514 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
1516 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1517 if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
1518 fprintf (asmfile, HOST_WIDE_INT_PRINT_UNSIGNED,
1519 TREE_INT_CST_LOW (TREE_VALUE (tem)));
1520 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
1521 && (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
1522 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1523 TREE_INT_CST_LOW (TREE_VALUE (tem)));
1525 print_int_cst_octal (TREE_VALUE (tem));
1526 fprintf (asmfile, ",");
1527 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem)));
1528 if (TREE_CHAIN (tem) != 0)
1533 putc (';', asmfile);
1539 putc ('*', asmfile);
1541 dbxout_type (TREE_TYPE (type), 0, 0);
1545 if (use_gnu_debug_info_extensions)
1547 have_used_extensions = 1;
1548 putc ('#', asmfile);
1550 if (flag_minimal_debug && !show_arg_types)
1552 /* Normally, just output the return type.
1553 The argument types are encoded in the method name. */
1554 putc ('#', asmfile);
1556 dbxout_type (TREE_TYPE (type), 0, 0);
1557 putc (';', asmfile);
1562 /* When outputting destructors, we need to write
1563 the argument types out longhand. */
1564 dbxout_type (TYPE_METHOD_BASETYPE (type), 0, 0);
1565 putc (',', asmfile);
1567 dbxout_type (TREE_TYPE (type), 0, 0);
1568 dbxout_args (TYPE_ARG_TYPES (type));
1569 putc (';', asmfile);
1575 /* Treat it as a function type. */
1576 dbxout_type (TREE_TYPE (type), 0, 0);
1581 if (use_gnu_debug_info_extensions)
1583 have_used_extensions = 1;
1584 putc ('@', asmfile);
1586 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0, 0);
1587 putc (',', asmfile);
1589 dbxout_type (TREE_TYPE (type), 0, 0);
1593 /* Should print as an int, because it is really
1595 dbxout_type (integer_type_node, 0, 0);
1599 case REFERENCE_TYPE:
1600 if (use_gnu_debug_info_extensions)
1601 have_used_extensions = 1;
1602 putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
1604 dbxout_type (TREE_TYPE (type), 0, 0);
1608 putc ('f', asmfile);
1610 dbxout_type (TREE_TYPE (type), 0, 0);
1618 /* Print the value of integer constant C, in octal,
1619 handling double precision. */
1622 print_int_cst_octal (c)
1625 unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
1626 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
1627 int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
1628 unsigned int width = TYPE_PRECISION (TREE_TYPE (c));
1630 /* GDB wants constants with no extra leading "1" bits, so
1631 we need to remove any sign-extension that might be
1633 if (width == HOST_BITS_PER_WIDE_INT * 2)
1635 else if (width > HOST_BITS_PER_WIDE_INT)
1636 high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
1637 else if (width == HOST_BITS_PER_WIDE_INT)
1640 high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
1642 fprintf (asmfile, "0");
1646 print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
1647 print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
1651 unsigned HOST_WIDE_INT beg = high >> excess;
1652 unsigned HOST_WIDE_INT middle
1653 = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
1654 | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
1655 unsigned HOST_WIDE_INT end
1656 = low & (((unsigned HOST_WIDE_INT) 1
1657 << (HOST_BITS_PER_WIDE_INT / 3 * 3))
1660 fprintf (asmfile, "%o%01o", (int) beg, (int) middle);
1661 print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
1666 print_octal (value, digits)
1667 unsigned HOST_WIDE_INT value;
1672 for (i = digits - 1; i >= 0; i--)
1673 fprintf (asmfile, "%01o", (int) ((value >> (3 * i)) & 7));
1676 /* Output the name of type TYPE, with no punctuation.
1677 Such names can be set up either by typedef declarations
1678 or by struct, enum and union tags. */
1681 dbxout_type_name (type)
1685 if (TYPE_NAME (type) == 0)
1687 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
1689 t = TYPE_NAME (type);
1691 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1693 t = DECL_NAME (TYPE_NAME (type));
1698 fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
1699 CHARS (IDENTIFIER_LENGTH (t));
1702 /* Output a .stabs for the symbol defined by DECL,
1703 which must be a ..._DECL node in the normal namespace.
1704 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1705 LOCAL is nonzero if the scope is less than the entire file.
1706 Return 1 if a stabs might have been emitted. */
1709 dbxout_symbol (decl, local)
1711 int local ATTRIBUTE_UNUSED;
1713 tree type = TREE_TYPE (decl);
1714 tree context = NULL_TREE;
1717 /* Cast avoids warning in old compilers. */
1718 current_sym_code = (STAB_CODE_TYPE) 0;
1719 current_sym_value = 0;
1720 current_sym_addr = 0;
1722 /* Ignore nameless syms, but don't ignore type tags. */
1724 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
1725 || DECL_IGNORED_P (decl))
1728 dbxout_prepare_symbol (decl);
1730 /* The output will always start with the symbol name,
1731 so always count that in the length-output-so-far. */
1733 if (DECL_NAME (decl) != 0)
1734 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
1736 switch (TREE_CODE (decl))
1739 /* Enum values are defined by defining the enum type. */
1743 if (DECL_RTL (decl) == 0)
1745 if (DECL_EXTERNAL (decl))
1747 /* Don't mention a nested function under its parent. */
1748 context = decl_function_context (decl);
1749 if (context == current_function_decl)
1751 if (GET_CODE (DECL_RTL (decl)) != MEM
1752 || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
1756 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
1757 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1758 TREE_PUBLIC (decl) ? 'F' : 'f');
1761 current_sym_code = N_FUN;
1762 current_sym_addr = XEXP (DECL_RTL (decl), 0);
1764 if (TREE_TYPE (type))
1765 dbxout_type (TREE_TYPE (type), 0, 0);
1767 dbxout_type (void_type_node, 0, 0);
1769 /* For a nested function, when that function is compiled,
1770 mention the containing function name
1771 as well as (since dbx wants it) our own assembler-name. */
1773 fprintf (asmfile, ",%s,%s",
1774 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1775 IDENTIFIER_POINTER (DECL_NAME (context)));
1777 dbxout_finish_symbol (decl);
1782 /* This seems all wrong. Outputting most kinds of types gives no name
1783 at all. A true definition gives no name; a cross-ref for a
1784 structure can give the tag name, but not a type name.
1785 It seems that no typedef name is defined by outputting a type. */
1787 /* If this typedef name was defined by outputting the type,
1788 don't duplicate it. */
1789 if (typevec[TYPE_SYMTAB_ADDRESS (type)].status == TYPE_DEFINED
1790 && TYPE_NAME (TREE_TYPE (decl)) == decl)
1793 /* Don't output the same typedef twice.
1794 And don't output what language-specific stuff doesn't want output. */
1795 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
1804 if (DECL_NAME (decl))
1806 /* Nonzero means we must output a tag as well as a typedef. */
1809 /* Handle the case of a C++ structure or union
1810 where the TYPE_NAME is a TYPE_DECL
1811 which gives both a typedef name and a tag. */
1812 /* dbx requires the tag first and the typedef second. */
1813 if ((TREE_CODE (type) == RECORD_TYPE
1814 || TREE_CODE (type) == UNION_TYPE
1815 || TREE_CODE (type) == QUAL_UNION_TYPE)
1816 && TYPE_NAME (type) == decl
1817 && !(use_gnu_debug_info_extensions && have_used_extensions)
1818 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
1819 /* Distinguish the implicit typedefs of C++
1820 from explicit ones that might be found in C. */
1821 && DECL_ARTIFICIAL (decl))
1823 tree name = TYPE_NAME (type);
1824 if (TREE_CODE (name) == TYPE_DECL)
1825 name = DECL_NAME (name);
1827 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1828 current_sym_value = 0;
1829 current_sym_addr = 0;
1830 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1832 fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
1833 IDENTIFIER_POINTER (name));
1834 dbxout_type (type, 1, 0);
1835 dbxout_finish_symbol (NULL_TREE);
1838 /* Output typedef name. */
1839 fprintf (asmfile, "%s\"%s:", ASM_STABS_OP,
1840 IDENTIFIER_POINTER (DECL_NAME (decl)));
1842 /* Short cut way to output a tag also. */
1843 if ((TREE_CODE (type) == RECORD_TYPE
1844 || TREE_CODE (type) == UNION_TYPE
1845 || TREE_CODE (type) == QUAL_UNION_TYPE)
1846 && TYPE_NAME (type) == decl
1847 /* Distinguish the implicit typedefs of C++
1848 from explicit ones that might be found in C. */
1849 && DECL_ARTIFICIAL (decl))
1851 if (use_gnu_debug_info_extensions && have_used_extensions)
1853 putc ('T', asmfile);
1854 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
1856 #if 0 /* Now we generate the tag for this case up above. */
1862 putc ('t', asmfile);
1863 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1865 dbxout_type (type, 1, 0);
1866 dbxout_finish_symbol (decl);
1870 /* Don't output a tag if this is an incomplete type (TYPE_SIZE is
1871 zero). This prevents the sun4 Sun OS 4.x dbx from crashing. */
1873 if (tag_needed && TYPE_NAME (type) != 0
1874 && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
1875 || (DECL_NAME (TYPE_NAME (type)) != 0))
1876 && COMPLETE_TYPE_P (type)
1877 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
1879 /* For a TYPE_DECL with no name, but the type has a name,
1881 This is what represents `struct foo' with no typedef. */
1882 /* In C++, the name of a type is the corresponding typedef.
1883 In C, it is an IDENTIFIER_NODE. */
1884 tree name = TYPE_NAME (type);
1885 if (TREE_CODE (name) == TYPE_DECL)
1886 name = DECL_NAME (name);
1888 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1889 current_sym_value = 0;
1890 current_sym_addr = 0;
1891 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1893 fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
1894 IDENTIFIER_POINTER (name));
1895 dbxout_type (type, 1, 0);
1896 dbxout_finish_symbol (NULL_TREE);
1900 /* If an enum type has no name, it cannot be referred to,
1901 but we must output it anyway, since the enumeration constants
1902 can be referred to. */
1903 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
1905 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1906 current_sym_value = 0;
1907 current_sym_addr = 0;
1908 current_sym_nchars = 2;
1910 /* Some debuggers fail when given NULL names, so give this a
1911 harmless name of ` '. */
1912 fprintf (asmfile, "%s\" :T", ASM_STABS_OP);
1913 dbxout_type (type, 1, 0);
1914 dbxout_finish_symbol (NULL_TREE);
1917 /* Prevent duplicate output of a typedef. */
1918 TREE_ASM_WRITTEN (decl) = 1;
1923 /* Parm decls go in their own separate chains
1924 and are output by dbxout_reg_parms and dbxout_parms. */
1928 /* Named return value, treat like a VAR_DECL. */
1930 if (DECL_RTL (decl) == 0)
1932 /* Don't mention a variable that is external.
1933 Let the file that defines it describe it. */
1934 if (DECL_EXTERNAL (decl))
1937 /* If the variable is really a constant
1938 and not written in memory, inform the debugger. */
1939 if (TREE_STATIC (decl) && TREE_READONLY (decl)
1940 && DECL_INITIAL (decl) != 0
1941 && host_integerp (DECL_INITIAL (decl), 0)
1942 && ! TREE_ASM_WRITTEN (decl)
1943 && (DECL_CONTEXT (decl) == NULL_TREE
1944 || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK))
1946 if (TREE_PUBLIC (decl) == 0)
1948 /* The sun4 assembler does not grok this. */
1949 const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1951 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
1952 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
1954 HOST_WIDE_INT ival = tree_low_cst (DECL_INITIAL (decl), 0);
1955 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1956 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile, name, ival);
1958 fprintf (asmfile, "%s\"%s:c=i", ASM_STABS_OP, name);
1960 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, ival);
1961 fprintf (asmfile, "\",0x%x,0,0,0\n", N_LSYM);
1965 else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
1967 /* don't know how to do this yet. */
1971 /* else it is something we handle like a normal variable. */
1974 SET_DECL_RTL (decl, eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
1975 #ifdef LEAF_REG_REMAP
1976 if (current_function_uses_only_leaf_regs)
1977 leaf_renumber_regs_insn (DECL_RTL (decl));
1980 result = dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
1989 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1990 Add SUFFIX to its name, if SUFFIX is not 0.
1991 Describe the variable as residing in HOME
1992 (usually HOME is DECL_RTL (DECL), but not always).
1993 Returns 1 if the stab was really emitted. */
1996 dbxout_symbol_location (decl, type, suffix, home)
2004 /* Don't mention a variable at all
2005 if it was completely optimized into nothingness.
2007 If the decl was from an inline function, then its rtl
2008 is not identically the rtl that was used in this
2009 particular compilation. */
2010 if (GET_CODE (home) == REG)
2012 regno = REGNO (home);
2013 if (regno >= FIRST_PSEUDO_REGISTER)
2016 else if (GET_CODE (home) == SUBREG)
2020 while (GET_CODE (value) == SUBREG)
2022 offset += SUBREG_WORD (value);
2023 value = SUBREG_REG (value);
2025 if (GET_CODE (value) == REG)
2027 regno = REGNO (value);
2028 if (regno >= FIRST_PSEUDO_REGISTER)
2032 alter_subreg (home);
2035 /* The kind-of-variable letter depends on where
2036 the variable is and on the scope of its name:
2037 G and N_GSYM for static storage and global scope,
2038 S for static storage and file scope,
2039 V for static storage and local scope,
2040 for those two, use N_LCSYM if data is in bss segment,
2041 N_STSYM if in data segment, N_FUN otherwise.
2042 (We used N_FUN originally, then changed to N_STSYM
2043 to please GDB. However, it seems that confused ld.
2044 Now GDB has been fixed to like N_FUN, says Kingdon.)
2045 no letter at all, and N_LSYM, for auto variable,
2046 r and N_RSYM for register variable. */
2048 if (GET_CODE (home) == MEM
2049 && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
2051 if (TREE_PUBLIC (decl))
2054 current_sym_code = N_GSYM;
2058 current_sym_addr = XEXP (home, 0);
2060 letter = decl_function_context (decl) ? 'V' : 'S';
2062 /* This should be the same condition as in assemble_variable, but
2063 we don't have access to dont_output_data here. So, instead,
2064 we rely on the fact that error_mark_node initializers always
2065 end up in bss for C++ and never end up in bss for C. */
2066 if (DECL_INITIAL (decl) == 0
2067 || (!strcmp (lang_identify (), "cplusplus")
2068 && DECL_INITIAL (decl) == error_mark_node))
2069 current_sym_code = N_LCSYM;
2070 else if (DECL_IN_TEXT_SECTION (decl))
2071 /* This is not quite right, but it's the closest
2072 of all the codes that Unix defines. */
2073 current_sym_code = DBX_STATIC_CONST_VAR_CODE;
2076 /* Ultrix `as' seems to need this. */
2077 #ifdef DBX_STATIC_STAB_DATA_SECTION
2080 current_sym_code = N_STSYM;
2084 else if (regno >= 0)
2087 current_sym_code = N_RSYM;
2088 current_sym_value = DBX_REGISTER_NUMBER (regno);
2090 else if (GET_CODE (home) == MEM
2091 && (GET_CODE (XEXP (home, 0)) == MEM
2092 || (GET_CODE (XEXP (home, 0)) == REG
2093 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
2094 && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
2095 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2096 && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
2099 /* If the value is indirect by memory or by a register
2100 that isn't the frame pointer
2101 then it means the object is variable-sized and address through
2102 that register or stack slot. DBX has no way to represent this
2103 so all we can do is output the variable as a pointer.
2104 If it's not a parameter, ignore it.
2105 (VAR_DECLs like this can be made by integrate.c.) */
2107 if (GET_CODE (XEXP (home, 0)) == REG)
2110 current_sym_code = N_RSYM;
2111 current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
2115 current_sym_code = N_LSYM;
2116 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2117 We want the value of that CONST_INT. */
2119 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
2122 /* Effectively do build_pointer_type, but don't cache this type,
2123 since it might be temporary whereas the type it points to
2124 might have been saved for inlining. */
2125 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2126 type = make_node (POINTER_TYPE);
2127 TREE_TYPE (type) = TREE_TYPE (decl);
2129 else if (GET_CODE (home) == MEM
2130 && GET_CODE (XEXP (home, 0)) == REG)
2132 current_sym_code = N_LSYM;
2133 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2135 else if (GET_CODE (home) == MEM
2136 && GET_CODE (XEXP (home, 0)) == PLUS
2137 && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
2139 current_sym_code = N_LSYM;
2140 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2141 We want the value of that CONST_INT. */
2142 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2144 else if (GET_CODE (home) == MEM
2145 && GET_CODE (XEXP (home, 0)) == CONST)
2147 /* Handle an obscure case which can arise when optimizing and
2148 when there are few available registers. (This is *always*
2149 the case for i386/i486 targets). The RTL looks like
2150 (MEM (CONST ...)) even though this variable is a local `auto'
2151 or a local `register' variable. In effect, what has happened
2152 is that the reload pass has seen that all assignments and
2153 references for one such a local variable can be replaced by
2154 equivalent assignments and references to some static storage
2155 variable, thereby avoiding the need for a register. In such
2156 cases we're forced to lie to debuggers and tell them that
2157 this variable was itself `static'. */
2158 current_sym_code = N_LCSYM;
2160 current_sym_addr = XEXP (XEXP (home, 0), 0);
2162 else if (GET_CODE (home) == CONCAT)
2164 tree subtype = TREE_TYPE (type);
2166 /* If the variable's storage is in two parts,
2167 output each as a separate stab with a modified name. */
2168 if (WORDS_BIG_ENDIAN)
2169 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
2171 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
2173 /* Cast avoids warning in old compilers. */
2174 current_sym_code = (STAB_CODE_TYPE) 0;
2175 current_sym_value = 0;
2176 current_sym_addr = 0;
2177 dbxout_prepare_symbol (decl);
2179 if (WORDS_BIG_ENDIAN)
2180 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
2182 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
2186 /* Address might be a MEM, when DECL is a variable-sized object.
2187 Or it might be const0_rtx, meaning previous passes
2188 want us to ignore this variable. */
2191 /* Ok, start a symtab entry and output the variable name. */
2194 #ifdef DBX_STATIC_BLOCK_START
2195 DBX_STATIC_BLOCK_START (asmfile, current_sym_code);
2198 dbxout_symbol_name (decl, suffix, letter);
2199 dbxout_type (type, 0, 0);
2200 dbxout_finish_symbol (decl);
2202 #ifdef DBX_STATIC_BLOCK_END
2203 DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
2208 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2209 Then output LETTER to indicate the kind of location the symbol has. */
2212 dbxout_symbol_name (decl, suffix, letter)
2219 if (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)))
2220 /* One slight hitch: if this is a VAR_DECL which is a static
2221 class member, we must put out the mangled name instead of the
2222 DECL_NAME. Note also that static member (variable) names DO NOT begin
2223 with underscores in .stabs directives. */
2224 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2226 /* ...but if we're function-local, we don't want to include the junk
2227 added by ASM_FORMAT_PRIVATE_NAME. */
2228 name = IDENTIFIER_POINTER (DECL_NAME (decl));
2232 fprintf (asmfile, "%s\"%s%s:", ASM_STABS_OP, name,
2233 (suffix ? suffix : ""));
2235 if (letter) putc (letter, asmfile);
2239 dbxout_prepare_symbol (decl)
2240 tree decl ATTRIBUTE_UNUSED;
2243 const char *filename = DECL_SOURCE_FILE (decl);
2245 dbxout_source_file (asmfile, filename);
2250 dbxout_finish_symbol (sym)
2253 #ifdef DBX_FINISH_SYMBOL
2254 DBX_FINISH_SYMBOL (sym);
2257 if (use_gnu_debug_info_extensions && sym != 0)
2258 line = DECL_SOURCE_LINE (sym);
2260 fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line);
2261 if (current_sym_addr)
2262 output_addr_const (asmfile, current_sym_addr);
2264 fprintf (asmfile, "%d", current_sym_value);
2265 putc ('\n', asmfile);
2269 /* Output definitions of all the decls in a chain. Return non-zero if
2270 anything was output */
2279 result += dbxout_symbol (syms, 1);
2280 syms = TREE_CHAIN (syms);
2285 /* The following two functions output definitions of function parameters.
2286 Each parameter gets a definition locating it in the parameter list.
2287 Each parameter that is a register variable gets a second definition
2288 locating it in the register.
2290 Printing or argument lists in gdb uses the definitions that
2291 locate in the parameter list. But reference to the variable in
2292 expressions uses preferentially the definition as a register. */
2294 /* Output definitions, referring to storage in the parmlist,
2295 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2298 dbxout_parms (parms)
2301 for (; parms; parms = TREE_CHAIN (parms))
2302 if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node)
2304 dbxout_prepare_symbol (parms);
2306 /* Perform any necessary register eliminations on the parameter's rtl,
2307 so that the debugging output will be accurate. */
2308 DECL_INCOMING_RTL (parms)
2309 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
2310 SET_DECL_RTL (parms, eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
2311 #ifdef LEAF_REG_REMAP
2312 if (current_function_uses_only_leaf_regs)
2314 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
2315 leaf_renumber_regs_insn (DECL_RTL (parms));
2319 if (PARM_PASSED_IN_MEMORY (parms))
2321 rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
2323 /* ??? Here we assume that the parm address is indexed
2324 off the frame pointer or arg pointer.
2325 If that is not true, we produce meaningless results,
2326 but do not crash. */
2327 if (GET_CODE (addr) == PLUS
2328 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
2329 current_sym_value = INTVAL (XEXP (addr, 1));
2331 current_sym_value = 0;
2333 current_sym_code = N_PSYM;
2334 current_sym_addr = 0;
2337 if (DECL_NAME (parms))
2339 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2341 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2342 IDENTIFIER_POINTER (DECL_NAME (parms)),
2343 DBX_MEMPARM_STABS_LETTER);
2347 current_sym_nchars = 8;
2348 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2349 DBX_MEMPARM_STABS_LETTER);
2352 /* It is quite tempting to use:
2354 dbxout_type (TREE_TYPE (parms), 0, 0);
2356 as the next statement, rather than using DECL_ARG_TYPE(), so
2357 that gcc reports the actual type of the parameter, rather
2358 than the promoted type. This certainly makes GDB's life
2359 easier, at least for some ports. The change is a bad idea
2360 however, since GDB expects to be able access the type without
2361 performing any conversions. So for example, if we were
2362 passing a float to an unprototyped function, gcc will store a
2363 double on the stack, but if we emit a stab saying the type is a
2364 float, then gdb will only read in a single value, and this will
2365 produce an erropneous value. */
2366 dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
2367 current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
2368 dbxout_finish_symbol (parms);
2370 else if (GET_CODE (DECL_RTL (parms)) == REG)
2373 char regparm_letter;
2375 /* Parm passed in registers and lives in registers or nowhere. */
2377 current_sym_code = DBX_REGPARM_STABS_CODE;
2378 regparm_letter = DBX_REGPARM_STABS_LETTER;
2379 current_sym_addr = 0;
2381 /* If parm lives in a register, use that register;
2382 pretend the parm was passed there. It would be more consistent
2383 to describe the register where the parm was passed,
2384 but in practice that register usually holds something else.
2386 If we use DECL_RTL, then we must use the declared type of
2387 the variable, not the type that it arrived in. */
2388 if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2390 best_rtl = DECL_RTL (parms);
2391 parm_type = TREE_TYPE (parms);
2393 /* If the parm lives nowhere, use the register where it was
2394 passed. It is also better to use the declared type here. */
2397 best_rtl = DECL_INCOMING_RTL (parms);
2398 parm_type = TREE_TYPE (parms);
2400 current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
2403 if (DECL_NAME (parms))
2405 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2406 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2407 IDENTIFIER_POINTER (DECL_NAME (parms)),
2412 current_sym_nchars = 8;
2413 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2417 dbxout_type (parm_type, 0, 0);
2418 dbxout_finish_symbol (parms);
2420 else if (GET_CODE (DECL_RTL (parms)) == MEM
2421 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2422 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
2423 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
2424 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2425 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
2429 /* Parm was passed via invisible reference.
2430 That is, its address was passed in a register.
2431 Output it as if it lived in that register.
2432 The debugger will know from the type
2433 that it was actually passed by invisible reference. */
2435 char regparm_letter;
2436 /* Parm passed in registers and lives in registers or nowhere. */
2438 current_sym_code = DBX_REGPARM_STABS_CODE;
2439 if (use_gnu_debug_info_extensions)
2440 regparm_letter = GDB_INV_REF_REGPARM_STABS_LETTER;
2442 regparm_letter = DBX_REGPARM_STABS_LETTER;
2444 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2445 If it is an unallocated pseudo-reg, then use the register where
2446 it was passed instead. */
2447 if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
2448 current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2450 current_sym_value = REGNO (DECL_INCOMING_RTL (parms));
2452 current_sym_addr = 0;
2455 if (DECL_NAME (parms))
2457 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2459 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2460 IDENTIFIER_POINTER (DECL_NAME (parms)),
2465 current_sym_nchars = 8;
2466 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2470 dbxout_type (TREE_TYPE (parms), 0, 0);
2471 dbxout_finish_symbol (parms);
2473 else if (GET_CODE (DECL_RTL (parms)) == MEM
2474 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
2476 /* Parm was passed via invisible reference, with the reference
2477 living on the stack. DECL_RTL looks like
2478 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
2479 could look like (MEM (MEM (REG))). */
2480 const char *decl_name = (DECL_NAME (parms)
2481 ? IDENTIFIER_POINTER (DECL_NAME (parms))
2483 if (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 0)) == REG)
2484 current_sym_value = 0;
2487 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
2488 current_sym_addr = 0;
2491 fprintf (asmfile, "%s\"%s:v", ASM_STABS_OP, decl_name);
2492 dbxout_type (TREE_TYPE (parms), 0, 0);
2493 dbxout_finish_symbol (parms);
2495 else if (GET_CODE (DECL_RTL (parms)) == MEM
2496 && XEXP (DECL_RTL (parms), 0) != const0_rtx
2497 /* ??? A constant address for a parm can happen
2498 when the reg it lives in is equiv to a constant in memory.
2499 Should make this not happen, after 2.4. */
2500 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
2502 /* Parm was passed in registers but lives on the stack. */
2504 current_sym_code = N_PSYM;
2505 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2506 in which case we want the value of that CONST_INT,
2508 in which case we use a value of zero. */
2509 if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG)
2510 current_sym_value = 0;
2513 = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
2515 current_sym_addr = 0;
2517 /* Make a big endian correction if the mode of the type of the
2518 parameter is not the same as the mode of the rtl. */
2519 if (BYTES_BIG_ENDIAN
2520 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
2521 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
2523 current_sym_value +=
2524 GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
2525 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms)));
2529 if (DECL_NAME (parms))
2532 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2534 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2535 IDENTIFIER_POINTER (DECL_NAME (parms)),
2536 DBX_MEMPARM_STABS_LETTER);
2540 current_sym_nchars = 8;
2541 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2542 DBX_MEMPARM_STABS_LETTER);
2546 = DEBUGGER_ARG_OFFSET (current_sym_value,
2547 XEXP (DECL_RTL (parms), 0));
2548 dbxout_type (TREE_TYPE (parms), 0, 0);
2549 dbxout_finish_symbol (parms);
2554 /* Output definitions for the places where parms live during the function,
2555 when different from where they were passed, when the parms were passed
2558 It is not useful to do this for parms passed in registers
2559 that live during the function in different registers, because it is
2560 impossible to look in the passed register for the passed value,
2561 so we use the within-the-function register to begin with.
2563 PARMS is a chain of PARM_DECL nodes. */
2566 dbxout_reg_parms (parms)
2569 for (; parms; parms = TREE_CHAIN (parms))
2570 if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
2572 dbxout_prepare_symbol (parms);
2574 /* Report parms that live in registers during the function
2575 but were passed in memory. */
2576 if (GET_CODE (DECL_RTL (parms)) == REG
2577 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2578 dbxout_symbol_location (parms, TREE_TYPE (parms),
2579 0, DECL_RTL (parms));
2580 else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
2581 dbxout_symbol_location (parms, TREE_TYPE (parms),
2582 0, DECL_RTL (parms));
2583 /* Report parms that live in memory but not where they were passed. */
2584 else if (GET_CODE (DECL_RTL (parms)) == MEM
2585 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
2586 dbxout_symbol_location (parms, TREE_TYPE (parms),
2587 0, DECL_RTL (parms));
2591 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2592 output definitions of those names, in raw form */
2600 putc (',', asmfile);
2601 dbxout_type (TREE_VALUE (args), 0, 0);
2603 args = TREE_CHAIN (args);
2607 /* Given a chain of ..._TYPE nodes,
2608 find those which have typedef names and output those names.
2609 This is to ensure those types get output. */
2612 dbxout_types (types)
2613 register tree types;
2617 if (TYPE_NAME (types)
2618 && TREE_CODE (TYPE_NAME (types)) == TYPE_DECL
2619 && ! TREE_ASM_WRITTEN (TYPE_NAME (types)))
2620 dbxout_symbol (TYPE_NAME (types), 1);
2621 types = TREE_CHAIN (types);
2625 /* Output everything about a symbol block (a BLOCK node
2626 that represents a scope level),
2627 including recursive output of contained blocks.
2629 BLOCK is the BLOCK node.
2630 DEPTH is its depth within containing symbol blocks.
2631 ARGS is usually zero; but for the outermost block of the
2632 body of a function, it is a chain of PARM_DECLs for the function parameters.
2633 We output definitions of all the register parms
2634 as if they were local variables of that block.
2636 If -g1 was used, we count blocks just the same, but output nothing
2637 except for the outermost block.
2639 Actually, BLOCK may be several blocks chained together.
2640 We handle them all in sequence. */
2643 dbxout_block (block, depth, args)
2644 register tree block;
2650 #if DBX_BLOCKS_FUNCTION_RELATIVE
2651 const char *begin_label;
2652 if (current_function_func_begin_label != NULL_TREE)
2653 begin_label = IDENTIFIER_POINTER (current_function_func_begin_label);
2655 begin_label = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
2660 /* Ignore blocks never expanded or otherwise marked as real. */
2661 if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
2665 #ifdef DBX_LBRAC_FIRST
2668 /* In dbx format, the syms of a block come before the N_LBRAC.
2669 If nothing is output, we don't need the N_LBRAC, either. */
2671 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2672 did_output = dbxout_syms (BLOCK_VARS (block));
2674 dbxout_reg_parms (args);
2677 /* Now output an N_LBRAC symbol to represent the beginning of
2678 the block. Use the block's tree-walk order to generate
2679 the assembler symbols LBBn and LBEn
2680 that final will define around the code in this block. */
2681 if (depth > 0 && did_output)
2684 blocknum = BLOCK_NUMBER (block);
2685 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
2687 if (BLOCK_HANDLER_BLOCK (block))
2689 /* A catch block. Must precede N_LBRAC. */
2690 tree decl = BLOCK_VARS (block);
2693 #ifdef DBX_OUTPUT_CATCH
2694 DBX_OUTPUT_CATCH (asmfile, decl, buf);
2696 fprintf (asmfile, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP,
2697 IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
2698 assemble_name (asmfile, buf);
2699 fprintf (asmfile, "\n");
2701 decl = TREE_CHAIN (decl);
2705 #ifdef DBX_OUTPUT_LBRAC
2706 DBX_OUTPUT_LBRAC (asmfile, buf);
2708 fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_LBRAC);
2709 assemble_name (asmfile, buf);
2710 #if DBX_BLOCKS_FUNCTION_RELATIVE
2711 fputc ('-', asmfile);
2712 assemble_name (asmfile, begin_label);
2714 fprintf (asmfile, "\n");
2718 #ifdef DBX_LBRAC_FIRST
2719 /* On some weird machines, the syms of a block
2720 come after the N_LBRAC. */
2721 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2722 dbxout_syms (BLOCK_VARS (block));
2724 dbxout_reg_parms (args);
2727 /* Output the subblocks. */
2728 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
2730 /* Refer to the marker for the end of the block. */
2731 if (depth > 0 && did_output)
2734 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
2735 #ifdef DBX_OUTPUT_RBRAC
2736 DBX_OUTPUT_RBRAC (asmfile, buf);
2738 fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_RBRAC);
2739 assemble_name (asmfile, buf);
2740 #if DBX_BLOCKS_FUNCTION_RELATIVE
2741 fputc ('-', asmfile);
2742 assemble_name (asmfile, begin_label);
2744 fprintf (asmfile, "\n");
2748 block = BLOCK_CHAIN (block);
2752 /* Output the information about a function and its arguments and result.
2753 Usually this follows the function's code,
2754 but on some systems, it comes before. */
2757 dbxout_really_begin_function (decl)
2760 dbxout_symbol (decl, 0);
2761 dbxout_parms (DECL_ARGUMENTS (decl));
2762 if (DECL_NAME (DECL_RESULT (decl)) != 0)
2763 dbxout_symbol (DECL_RESULT (decl), 1);
2766 /* Called at beginning of output of function definition. */
2769 dbxout_begin_function (decl)
2770 tree decl ATTRIBUTE_UNUSED;
2772 #ifdef DBX_FUNCTION_FIRST
2773 dbxout_really_begin_function (decl);
2777 /* Output dbx data for a function definition.
2778 This includes a definition of the function name itself (a symbol),
2779 definitions of the parameters (locating them in the parameter list)
2780 and then output the block that makes up the function's body
2781 (including all the auto variables of the function). */
2784 dbxout_function (decl)
2787 #ifndef DBX_FUNCTION_FIRST
2788 dbxout_really_begin_function (decl);
2790 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
2791 #ifdef DBX_OUTPUT_FUNCTION_END
2792 DBX_OUTPUT_FUNCTION_END (asmfile, decl);
2794 #if defined(ASM_OUTPUT_SECTION_NAME)
2795 if (use_gnu_debug_info_extensions
2796 #if defined(NO_DBX_FUNCTION_END)
2797 && ! NO_DBX_FUNCTION_END
2800 dbxout_function_end ();
2803 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */