1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987, 1988, 1992 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* Output dbx-format symbol table data.
22 This consists of many symbol table entries, each of them
23 a .stabs assembler pseudo-op with four operands:
24 a "name" which is really a description of one symbol and its type,
25 a "code", which is a symbol defined in stab.h whose name starts with N_,
26 an unused operand always 0,
27 and a "value" which is an address or an offset.
28 The name is enclosed in doublequote characters.
30 Each function, variable, typedef, and structure tag
31 has a symbol table entry to define it.
32 The beginning and end of each level of name scoping within
33 a function are also marked by special symbol table entries.
35 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
36 and a data type number. The data type number may be followed by
37 "=" and a type definition; normally this will happen the first time
38 the type number is mentioned. The type definition may refer to
39 other types by number, and those type numbers may be followed
40 by "=" and nested definitions.
42 This can make the "name" quite long.
43 When a name is more than 80 characters, we split the .stabs pseudo-op
44 into two .stabs pseudo-ops, both sharing the same "code" and "value".
45 The first one is marked as continued with a double-backslash at the
48 The kind-of-symbol letter distinguished function names from global
49 variables from file-scope variables from parameters from auto
50 variables in memory from typedef names from register variables.
53 The "code" is mostly redundant with the kind-of-symbol letter
54 that goes in the "name", but not entirely: for symbols located
55 in static storage, the "code" says which segment the address is in,
56 which controls how it is relocated.
58 The "value" for a symbol in static storage
59 is the core address of the symbol (actually, the assembler
60 label for the symbol). For a symbol located in a stack slot
61 it is the stack offset; for one in a register, the register number.
62 For a typedef symbol, it is zero.
64 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
65 output while in the text section.
67 For more on data type definitions, see `dbxout_type'. */
69 /* Include these first, because they may define MIN and MAX. */
78 #include "insn-config.h"
85 #ifdef XCOFF_DEBUGGING_INFO
90 #define ASM_STABS_OP ".stabs"
94 #define ASM_STABN_OP ".stabn"
97 #ifndef DBX_DECL_STABS_CODE
98 #define DBX_DECL_STABS_CODE N_LSYM
101 #ifndef DBX_STATIC_CONST_VAR_CODE
102 #define DBX_STATIC_CONST_VAR_CODE N_FUN
105 #ifndef DBX_REGPARM_STABS_CODE
106 #define DBX_REGPARM_STABS_CODE N_RSYM
109 #ifndef DBX_REGPARM_STABS_LETTER
110 #define DBX_REGPARM_STABS_LETTER 'P'
113 /* Nonzero means if the type has methods, only output debugging
114 information if methods are actually written to the asm file. */
116 static int flag_minimal_debug
= 1;
118 /* Nonzero if we have actually used any of the GDB extensions
119 to the debugging format. The idea is that we use them for the
120 first time only if there's a strong reason, but once we have done that,
121 we use them whenever convenient. */
123 static int have_used_extensions
= 0;
127 /* Typical USG systems don't have stab.h, and they also have
128 no use for DBX-format debugging info. */
130 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
132 #ifdef DEBUG_SYMS_TEXT
133 #define FORCE_TEXT text_section ();
138 #if defined (USG) || defined (NO_STAB_H)
139 #include "gstab.h" /* If doing DBX on sysV, use our own stab.h. */
141 #include <stab.h> /* On BSD, use the system's stab.h. */
143 /* This is a GNU extension we need to reference in this file. */
150 #define STAB_CODE_TYPE enum __stab_debug_code
152 #define STAB_CODE_TYPE int
155 /* 1 if PARM is passed to this function in memory. */
157 #define PARM_PASSED_IN_MEMORY(PARM) \
158 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
160 /* A C expression for the integer offset value of an automatic variable
161 (N_LSYM) having address X (an RTX). */
162 #ifndef DEBUGGER_AUTO_OFFSET
163 #define DEBUGGER_AUTO_OFFSET(X) \
164 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
167 /* A C expression for the integer offset value of an argument (N_PSYM)
168 having address X (an RTX). The nominal offset is OFFSET. */
169 #ifndef DEBUGGER_ARG_OFFSET
170 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
173 /* Stream for writing to assembler file. */
175 static FILE *asmfile
;
177 /* Last source file name mentioned in a NOTE insn. */
179 static char *lastfile
;
181 /* Current working directory. */
185 enum typestatus
{TYPE_UNSEEN
, TYPE_XREF
, TYPE_DEFINED
};
187 /* Vector recording the status of describing C data types.
188 When we first notice a data type (a tree node),
189 we assign it a number using next_type_number.
190 That is its index in this vector.
191 The vector element says whether we have yet output
192 the definition of the type. TYPE_XREF says we have
193 output it as a cross-reference only. */
195 enum typestatus
*typevec
;
197 /* Number of elements of space allocated in `typevec'. */
199 static int typevec_len
;
201 /* In dbx output, each type gets a unique number.
202 This is the number for the next type output.
203 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
205 static int next_type_number
;
207 /* In dbx output, we must assign symbol-blocks id numbers
208 in the order in which their beginnings are encountered.
209 We output debugging info that refers to the beginning and
210 end of the ranges of code in each block
211 with assembler labels LBBn and LBEn, where n is the block number.
212 The labels are generated in final, which assigns numbers to the
213 blocks in the same way. */
215 static int next_block_number
;
217 /* These variables are for dbxout_symbol to communicate to
218 dbxout_finish_symbol.
219 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
220 current_sym_value and current_sym_addr are two ways to address the
221 value to store in the symtab entry.
222 current_sym_addr if nonzero represents the value as an rtx.
223 If that is zero, current_sym_value is used. This is used
224 when the value is an offset (such as for auto variables,
225 register variables and parms). */
227 static STAB_CODE_TYPE current_sym_code
;
228 static int current_sym_value
;
229 static rtx current_sym_addr
;
231 /* Number of chars of symbol-description generated so far for the
232 current symbol. Used by CHARS and CONTIN. */
234 static int current_sym_nchars
;
236 /* Report having output N chars of the current symbol-description. */
238 #define CHARS(N) (current_sym_nchars += (N))
240 /* Break the current symbol-description, generating a continuation,
241 if it has become long. */
243 #ifndef DBX_CONTIN_LENGTH
244 #define DBX_CONTIN_LENGTH 80
247 #if DBX_CONTIN_LENGTH > 0
249 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
254 void dbxout_types ();
256 void dbxout_symbol ();
257 static void dbxout_type_name ();
258 static void dbxout_type ();
259 static void dbxout_typedefs ();
260 static void dbxout_prepare_symbol ();
261 static void dbxout_finish_symbol ();
262 static void dbxout_continue ();
263 static void print_int_cst_octal ();
264 static void print_octal ();
266 #if 0 /* Not clear we will actually need this. */
268 /* Return the absolutized filename for the given relative
269 filename. Note that if that filename is already absolute, it may
270 still be returned in a modified form because this routine also
271 eliminates redundant slashes and single dots and eliminates double
272 dots to get a shortest possible filename from the given input
273 filename. The absolutization of relative filenames is made by
274 assuming that the given filename is to be taken as relative to
275 the first argument (cwd) or to the current directory if cwd is
279 abspath (rel_filename
)
282 /* Setup the current working directory as needed. */
284 = (char *) alloca (strlen (cwd
) + strlen (rel_filename
) + 1);
285 char *endp
= abs_buffer
;
289 /* Copy the filename (possibly preceded by the current working
290 directory name) into the absolutization buffer. */
295 if (rel_filename
[0] != '/')
298 while (*endp
++ = *src_p
++)
300 *(endp
-1) = '/'; /* overwrite null */
302 src_p
= rel_filename
;
303 while (*endp
++ = *src_p
++)
308 /* Now make a copy of abs_buffer into abs_buffer, shortening the
309 filename (by taking out slashes and dots) as we go. */
311 outp
= inp
= abs_buffer
;
312 *outp
++ = *inp
++; /* copy first slash */
317 else if (inp
[0] == '/' && outp
[-1] == '/')
322 else if (inp
[0] == '.' && outp
[-1] == '/')
326 else if (inp
[1] == '/')
331 else if ((inp
[1] == '.') && (inp
[2] == 0 || inp
[2] == '/'))
333 inp
+= (inp
[2] == '/') ? 3 : 2;
335 while (outp
>= abs_buffer
&& *outp
!= '/')
337 if (outp
< abs_buffer
)
339 /* Catch cases like /.. where we try to backup to a
340 point above the absolute root of the logical file
343 fprintf (stderr
, "%s: invalid file name: %s\n",
344 pname
, rel_filename
);
354 /* On exit, make sure that there is a trailing null, and make sure that
355 the last character of the returned string is *not* a slash. */
361 /* Make a copy (in the heap) of the stuff left in the absolutization
362 buffer and return a pointer to the copy. */
364 value
= (char *) oballoc (strlen (abs_buffer
) + 1);
365 strcpy (value
, abs_buffer
);
370 /* At the beginning of compilation, start writing the symbol table.
371 Initialize `typevec' and output the standard data types of C. */
374 dbxout_init (asm_file
, input_file_name
, syms
)
376 char *input_file_name
;
379 char ltext_label_name
[100];
384 typevec
= (enum typestatus
*) xmalloc (typevec_len
* sizeof typevec
[0]);
385 bzero (typevec
, typevec_len
* sizeof typevec
[0]);
387 /* Convert Ltext into the appropriate format for local labels in case
388 the system doesn't insert underscores in front of user generated
390 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
392 /* Put the current working directory in an N_SO symbol. */
393 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
394 but GDB always does. */
395 if (use_gdb_dbx_extensions
)
398 if (cwd
|| (cwd
= getpwd ()))
400 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
401 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile
, cwd
);
402 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
403 fprintf (asmfile
, "%s \"%s/\",%d,0,0,%s\n", ASM_STABS_OP
,
404 cwd
, N_SO
, <ext_label_name
[1]);
405 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
409 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
410 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
411 would give us an N_SOL, and we want an N_SO. */
412 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile
, input_file_name
);
413 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
414 /* We include outputting `Ltext:' here,
415 because that gives you a way to override it. */
416 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
417 fprintf (asmfile
, "%s \"%s\",%d,0,0,%s\n", ASM_STABS_OP
, input_file_name
,
418 N_SO
, <ext_label_name
[1]);
420 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Ltext", 0);
421 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
423 lastfile
= input_file_name
;
425 next_type_number
= 1;
426 next_block_number
= 2;
428 /* Make sure that types `int' and `char' have numbers 1 and 2.
429 Definitions of other integer types will refer to those numbers.
430 (Actually it should no longer matter what their numbers are.
431 Also, if any types with tags have been defined, dbxout_symbol
432 will output them first, so the numbers won't be 1 and 2. That
433 happens in C++. So it's a good thing it should no longer matter). */
435 #ifdef DBX_OUTPUT_STANDARD_TYPES
436 DBX_OUTPUT_STANDARD_TYPES (syms
);
438 dbxout_symbol (TYPE_NAME (integer_type_node
), 0);
439 dbxout_symbol (TYPE_NAME (char_type_node
), 0);
442 /* Get all permanent types that have typedef names,
443 and output them all, except for those already output. */
445 dbxout_typedefs (syms
);
448 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
449 in the reverse order from that which is found in SYMS. */
452 dbxout_typedefs (syms
)
457 dbxout_typedefs (TREE_CHAIN (syms
));
458 if (TREE_CODE (syms
) == TYPE_DECL
)
460 tree type
= TREE_TYPE (syms
);
462 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
463 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
464 dbxout_symbol (TYPE_NAME (type
), 0);
469 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
472 dbxout_source_file (file
, filename
)
476 char ltext_label_name
[100];
478 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
480 #ifdef DBX_OUTPUT_SOURCE_FILENAME
481 DBX_OUTPUT_SOURCE_FILENAME (file
, filename
);
483 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
484 fprintf (file
, "%s \"%s\",%d,0,0,%s\n", ASM_STABS_OP
,
485 filename
, N_SOL
, <ext_label_name
[1]);
491 /* At the end of compilation, finish writing the symbol table.
492 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
496 dbxout_finish (file
, filename
)
500 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
501 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file
, filename
);
502 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
505 /* Continue a symbol-description that gets too big.
506 End one symbol table entry with a double-backslash
507 and start a new one, eventually producing something like
508 .stabs "start......\\",code,0,value
509 .stabs "...rest",code,0,value */
514 #ifdef DBX_CONTIN_CHAR
515 fprintf (asmfile
, "%c", DBX_CONTIN_CHAR
);
517 fprintf (asmfile
, "\\\\");
519 dbxout_finish_symbol (0);
520 fprintf (asmfile
, "%s \"", ASM_STABS_OP
);
521 current_sym_nchars
= 0;
524 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
525 This must be a separate function because anonymous unions require
529 dbxout_type_fields (type
)
533 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
535 /* Output the name, type, position (in bits), size (in bits)
537 if (DECL_NAME (tem
) == NULL_TREE
538 && TREE_CODE (TREE_TYPE (tem
)) == UNION_TYPE
)
539 dbxout_type_fields (TREE_TYPE (tem
));
540 /* Omit here local type decls until we know how to support them. */
541 else if (TREE_CODE (tem
) == TYPE_DECL
)
543 /* Omit here the nameless fields that are used to skip bits. */
544 else if (DECL_NAME (tem
) != 0 && TREE_CODE (tem
) != CONST_DECL
)
546 /* Continue the line if necessary,
547 but not before the first field. */
548 if (tem
!= TYPE_FIELDS (type
))
551 if (use_gdb_dbx_extensions
552 && flag_minimal_debug
553 && TREE_CODE (tem
) == FIELD_DECL
554 && DECL_VIRTUAL_P (tem
)
555 && DECL_ASSEMBLER_NAME (tem
))
557 have_used_extensions
= 1;
558 CHARS (3 + IDENTIFIER_LENGTH (DECL_NAME (TYPE_NAME (DECL_FCONTEXT (tem
)))));
559 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
)), asmfile
);
560 dbxout_type (DECL_FCONTEXT (tem
), 0, 0);
561 fprintf (asmfile
, ":");
562 dbxout_type (TREE_TYPE (tem
), 0, 0);
563 fprintf (asmfile
, ",%d;",
564 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem
)));
568 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem
)));
569 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem
)));
571 if (use_gdb_dbx_extensions
572 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
573 || TREE_CODE (tem
) != FIELD_DECL
))
575 have_used_extensions
= 1;
577 putc ((TREE_PRIVATE (tem
) ? '0'
578 : TREE_PROTECTED (tem
) ? '1' : '2'),
583 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
584 && DECL_BIT_FIELD_TYPE (tem
))
585 ? DECL_BIT_FIELD_TYPE (tem
)
586 : TREE_TYPE (tem
), 0, 0);
588 if (TREE_CODE (tem
) == VAR_DECL
)
590 if (TREE_STATIC (tem
) && use_gdb_dbx_extensions
)
592 char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
));
593 have_used_extensions
= 1;
594 fprintf (asmfile
, ":%s;", name
);
595 CHARS (strlen (name
));
599 /* If TEM is non-static, GDB won't understand it. */
600 fprintf (asmfile
, ",0,0;");
603 else if (TREE_CODE (DECL_FIELD_BITPOS (tem
)) == INTEGER_CST
)
605 fprintf (asmfile
, ",%d,%d;",
606 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem
)),
607 TREE_INT_CST_LOW (DECL_SIZE (tem
)));
610 /* This has yet to be implemented. */
617 /* Subroutine of `dbxout_type_methods'. Output debug info about the
618 method described DECL. DEBUG_NAME is an encoding of the method's
619 type signature. ??? We may be able to do without DEBUG_NAME altogether
623 dbxout_type_method_1 (decl
, debug_name
)
627 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
630 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
632 else /* it's a METHOD_TYPE. */
634 /* A for normal functions.
635 B for `const' member functions.
636 C for `volatile' member functions.
637 D for `const volatile' member functions. */
638 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
640 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
643 if (DECL_VINDEX (decl
))
649 fprintf (asmfile
, ":%s;%c%c%c", debug_name
,
650 TREE_PRIVATE (decl
) ? '0' : TREE_PROTECTED (decl
) ? '1' : '2', c1
, c2
);
651 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
)) + 6
652 - (debug_name
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
653 if (DECL_VINDEX (decl
))
655 fprintf (asmfile
, "%d;",
656 TREE_INT_CST_LOW (DECL_VINDEX (decl
)));
657 dbxout_type (DECL_CONTEXT (decl
), 0, 0);
658 fprintf (asmfile
, ";");
663 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
667 dbxout_type_methods (type
)
670 /* C++: put out the method names and their parameter lists */
671 tree methods
= TYPE_METHODS (type
);
673 register tree fndecl
;
675 register int type_identifier_length
;
677 if (methods
== NULL_TREE
)
680 type_encoding
= DECL_NAME (TYPE_NAME (type
));
682 /* C++: Template classes break some assumptions made by this code about
683 the class names, constructor names, and encodings for assembler
684 label names. For now, disable output of dbx info for them. */
686 char *ptr
= IDENTIFIER_POINTER (type_encoding
);
687 /* Avoid strchr or index since those names aren't universal. */
688 while (*ptr
&& *ptr
!= '<') ptr
++;
695 warning ("dbx info for template class methods not yet supported");
701 type_identifier_length
= IDENTIFIER_LENGTH (type_encoding
);
703 if (TREE_CODE (methods
) == FUNCTION_DECL
)
705 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
706 fndecl
= TREE_VEC_ELT (methods
, 0);
707 else fndecl
= TREE_VEC_ELT (methods
, 1);
711 tree name
= DECL_NAME (fndecl
);
714 /* Group together all the methods for the same operation.
715 These differ in the types of the arguments. */
716 for (last
= NULL_TREE
;
717 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
718 fndecl
= TREE_CHAIN (fndecl
))
719 /* Output the name of the field (after overloading), as
720 well as the name of the field before overloading, along
721 with its parameter list */
723 /* This is the "mangled" name of the method.
724 It encodes the argument types. */
725 char *debug_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
));
732 if (DECL_IGNORED_P (fndecl
))
735 if (flag_minimal_debug
)
737 /* Detect ordinary methods because their mangled names
738 start with the operation name. */
739 if (!strncmp (IDENTIFIER_POINTER (name
), debug_name
,
740 IDENTIFIER_LENGTH (name
)))
742 debug_name
+= IDENTIFIER_LENGTH (name
);
743 if (debug_name
[0] == '_' && debug_name
[1] == '_')
745 char *method_name
= debug_name
+ 2;
746 /* Get past const and volatile qualifiers. */
747 while (*method_name
== 'C' || *method_name
== 'V')
749 if (! strncmp (method_name
,
750 IDENTIFIER_POINTER (type_encoding
),
751 type_identifier_length
))
752 method_name
+= type_identifier_length
;
753 debug_name
= method_name
;
756 /* Detect constructors by their style of name mangling. */
757 else if (debug_name
[0] == '_' && debug_name
[1] == '_')
759 char *ctor_name
= debug_name
+ 2;
760 while (*ctor_name
== 'C' || *ctor_name
== 'V')
762 if (!strncmp (IDENTIFIER_POINTER (type_encoding
), ctor_name
,
763 type_identifier_length
))
764 debug_name
= ctor_name
+ type_identifier_length
;
766 /* The other alternative is a destructor. */
770 /* Output the operation name just once, for the first method
774 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (name
));
775 CHARS (IDENTIFIER_LENGTH (name
) + 2);
780 dbxout_type (TREE_TYPE (fndecl
), 0, destructor
);
782 dbxout_type_method_1 (fndecl
, debug_name
);
789 /* Output a reference to a type. If the type has not yet been
790 described in the dbx output, output its definition now.
791 For a type already defined, just refer to its definition
792 using the type number.
794 If FULL is nonzero, and the type has been described only with
795 a forward-reference, output the definition now.
796 If FULL is zero in this case, just refer to the forward-reference
797 using the number previously allocated.
799 If SHOW_ARG_TYPES is nonzero, we output a description of the argument
800 types for a METHOD_TYPE. */
803 dbxout_type (type
, full
, show_arg_types
)
810 /* If there was an input error and we don't really have a type,
811 avoid crashing and write something that is at least valid
812 by assuming `int'. */
813 if (type
== error_mark_node
)
814 type
= integer_type_node
;
817 type
= TYPE_MAIN_VARIANT (type
);
819 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
820 && DECL_IGNORED_P (TYPE_NAME (type
)))
824 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
826 /* Type has no dbx number assigned. Assign next available number. */
827 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
829 /* Make sure type vector is long enough to record about this type. */
831 if (next_type_number
== typevec_len
)
833 typevec
= (enum typestatus
*) xrealloc (typevec
, typevec_len
* 2 * sizeof typevec
[0]);
834 bzero (typevec
+ typevec_len
, typevec_len
* sizeof typevec
[0]);
839 /* Output the number of this type, to refer to it. */
840 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
843 #ifdef DBX_TYPE_DEFINED
844 if (DBX_TYPE_DEFINED (type
))
848 /* If this type's definition has been output or is now being output,
851 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)])
856 /* If we have already had a cross reference,
857 and either that's all we want or that's the best we could do,
858 don't repeat the cross reference.
859 Sun dbx crashes if we do. */
860 if (! full
|| TYPE_SIZE (type
) == 0
861 /* No way in DBX fmt to describe a variable size. */
862 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
870 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
871 leave the type-number completely undefined rather than output
872 a cross-reference. */
873 if (TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
874 || TREE_CODE (type
) == ENUMERAL_TYPE
)
876 if ((TYPE_NAME (type
) != 0 && !full
)
877 || TYPE_SIZE (type
) == 0)
879 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_XREF
;
884 /* Output a definition now. */
886 fprintf (asmfile
, "=");
889 /* Mark it as defined, so that if it is self-referent
890 we will not get into an infinite recursion of definitions. */
892 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_DEFINED
;
894 switch (TREE_CODE (type
))
898 /* For a void type, just define it as itself; ie, "5=5".
899 This makes us consider it defined
900 without saying what it is. The debugger will make it
901 a void type when the reference is seen, and nothing will
902 ever override that default. */
903 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
908 if (type
== char_type_node
&& ! TREE_UNSIGNED (type
))
909 /* Output the type `char' as a subrange of itself!
910 I don't understand this definition, just copied it
911 from the output of pcc.
912 This used to use `r2' explicitly and we used to
913 take care to make sure that `char' was type number 2. */
914 fprintf (asmfile
, "r%d;0;127;", TYPE_SYMTAB_ADDRESS (type
));
916 else if (TYPE_PRECISION (type
) > BITS_PER_WORD
)
918 /* This used to say `r1' and we used to take care
919 to make sure that `int' was type number 1. */
920 fprintf (asmfile
, "r%d;", TYPE_SYMTAB_ADDRESS (integer_type_node
));
921 print_int_cst_octal (TYPE_MIN_VALUE (type
));
922 fprintf (asmfile
, ";");
923 print_int_cst_octal (TYPE_MAX_VALUE (type
));
924 fprintf (asmfile
, ";");
928 /* Output other integer types as subranges of `int'. */
929 /* This used to say `r1' and we used to take care
930 to make sure that `int' was type number 1. */
931 fprintf (asmfile
, "r%d;%d;%d;",
932 TYPE_SYMTAB_ADDRESS (integer_type_node
),
933 TREE_INT_CST_LOW (TYPE_MIN_VALUE (type
)),
934 TREE_INT_CST_LOW (TYPE_MAX_VALUE (type
)));
939 /* This used to say `r1' and we used to take care
940 to make sure that `int' was type number 1. */
941 fprintf (asmfile
, "r%d;%d;0;", TYPE_SYMTAB_ADDRESS (integer_type_node
),
942 TREE_INT_CST_LOW (size_in_bytes (type
)));
947 /* Output "a" followed by a range type definition
948 for the index type of the array
949 followed by a reference to the target-type.
950 ar1;0;N;M for an array of type M and size N. */
951 /* This used to say `r1' and we used to take care
952 to make sure that `int' was type number 1. */
953 fprintf (asmfile
, "ar%d;0;%d;", TYPE_SYMTAB_ADDRESS (integer_type_node
),
956 ? TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)))
959 dbxout_type (TREE_TYPE (type
), 0, 0);
965 int i
, n_baseclasses
= 0;
967 if (TYPE_BINFO (type
) != 0 && TYPE_BINFO_BASETYPES (type
) != 0)
968 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
970 /* Output a structure type. */
971 if ((TYPE_NAME (type
) != 0
972 #if 0 /* Tiemann says this creates output tha "confuses GDB".
973 Too bad the info is so vague. Hope this doesn't lose. */
974 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
975 && DECL_IGNORED_P (TYPE_NAME (type
)))
978 || TYPE_SIZE (type
) == 0
979 /* No way in DBX fmt to describe a variable size. */
980 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
982 /* If the type is just a cross reference, output one
983 and mark the type as partially described.
984 If it later becomes defined, we will output
986 If the type has a name, don't nest its definition within
987 another type's definition; instead, output an xref
988 and let the definition come when the name is defined. */
989 fprintf (asmfile
, (TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu");
991 #if 0 /* This assertion is legitimately false in C++. */
992 /* We shouldn't be outputting a reference to a type before its
993 definition unless the type has a tag name.
994 A typedef name without a tag name should be impossible. */
995 if (TREE_CODE (TYPE_NAME (type
)) != IDENTIFIER_NODE
)
998 dbxout_type_name (type
);
999 fprintf (asmfile
, ":");
1000 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_XREF
;
1003 tem
= size_in_bytes (type
);
1005 /* Identify record or union, and print its size. */
1006 fprintf (asmfile
, (TREE_CODE (type
) == RECORD_TYPE
) ? "s%d" : "u%d",
1007 TREE_INT_CST_LOW (tem
));
1009 if (use_gdb_dbx_extensions
)
1013 have_used_extensions
= 1;
1014 fprintf (asmfile
, "!%d,", n_baseclasses
);
1018 for (i
= 0; i
< n_baseclasses
; i
++)
1020 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)), i
);
1021 if (use_gdb_dbx_extensions
)
1023 have_used_extensions
= 1;
1024 putc (TREE_VIA_VIRTUAL (child
) ? '1'
1027 putc (TREE_VIA_PUBLIC (child
) ? '2'
1030 fprintf (asmfile
, "%d,",
1031 TREE_INT_CST_LOW (BINFO_OFFSET (child
)) * BITS_PER_UNIT
);
1033 dbxout_type (BINFO_TYPE (child
), 0, 0);
1034 putc (';', asmfile
);
1038 /* Print out the base class information with fields
1039 which have the same names at the types they hold. */
1040 dbxout_type_name (BINFO_TYPE (child
));
1041 putc (':', asmfile
);
1042 dbxout_type (BINFO_TYPE (child
), full
, 0);
1043 fprintf (asmfile
, ",%d,%d;",
1044 TREE_INT_CST_LOW (BINFO_OFFSET (child
)) * BITS_PER_UNIT
,
1045 TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child
)))) * BITS_PER_UNIT
);
1053 /* Write out the field declarations. */
1054 dbxout_type_fields (type
);
1055 if (use_gdb_dbx_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1057 have_used_extensions
= 1;
1058 dbxout_type_methods (type
);
1060 putc (';', asmfile
);
1062 if (use_gdb_dbx_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1063 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1064 && TYPE_VFIELD (type
))
1066 have_used_extensions
= 1;
1068 /* Tell GDB+ that it may keep reading. */
1069 putc ('~', asmfile
);
1071 /* We need to write out info about what field this class
1072 uses as its "main" vtable pointer field, because if this
1073 field is inherited from a base class, GDB cannot necessarily
1074 figure out which field it's using in time. */
1075 if (TYPE_VFIELD (type
))
1077 putc ('%', asmfile
);
1078 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0, 0);
1080 putc (';', asmfile
);
1086 if ((TYPE_NAME (type
) != 0 && !full
1087 && (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1088 && ! DECL_IGNORED_P (TYPE_NAME (type
))))
1089 || TYPE_SIZE (type
) == 0)
1091 fprintf (asmfile
, "xe");
1093 dbxout_type_name (type
);
1094 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_XREF
;
1095 fprintf (asmfile
, ":");
1098 putc ('e', asmfile
);
1100 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1102 fprintf (asmfile
, "%s:%d,", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)),
1103 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1104 CHARS (11 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)));
1105 if (TREE_CHAIN (tem
) != 0)
1108 putc (';', asmfile
);
1113 putc ('*', asmfile
);
1115 dbxout_type (TREE_TYPE (type
), 0, 0);
1119 if (use_gdb_dbx_extensions
)
1121 have_used_extensions
= 1;
1122 putc ('#', asmfile
);
1124 if (flag_minimal_debug
&& !show_arg_types
)
1126 /* Normally, just output the return type.
1127 The argument types are encoded in the method name. */
1128 putc ('#', asmfile
);
1129 dbxout_type (TREE_TYPE (type
), 0, 0);
1130 putc (';', asmfile
);
1135 /* When outputing destructors, we need to write
1136 the argument types out longhand. */
1137 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0, 0);
1138 putc (',', asmfile
);
1140 dbxout_type (TREE_TYPE (type
), 0, 0);
1141 dbxout_args (TYPE_ARG_TYPES (type
));
1142 putc (';', asmfile
);
1148 /* Treat it as a function type. */
1149 dbxout_type (TREE_TYPE (type
), 0, 0);
1154 if (use_gdb_dbx_extensions
)
1156 have_used_extensions
= 1;
1157 putc ('@', asmfile
);
1159 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0, 0);
1160 putc (',', asmfile
);
1162 dbxout_type (TREE_TYPE (type
), 0, 0);
1166 /* Should print as an int, because it is really
1168 dbxout_type (integer_type_node
, 0, 0);
1172 case REFERENCE_TYPE
:
1173 if (use_gdb_dbx_extensions
)
1174 have_used_extensions
= 1;
1175 putc (use_gdb_dbx_extensions
? '&' : '*', asmfile
);
1177 dbxout_type (TREE_TYPE (type
), 0, 0);
1181 putc ('f', asmfile
);
1183 dbxout_type (TREE_TYPE (type
), 0, 0);
1191 /* Print the value of integer constant C, in octal,
1192 handling double precision. */
1195 print_int_cst_octal (c
)
1198 unsigned int high
= TREE_INT_CST_HIGH (c
);
1199 unsigned int low
= TREE_INT_CST_LOW (c
);
1200 int excess
= (3 - (HOST_BITS_PER_INT
% 3));
1202 fprintf (asmfile
, "0");
1206 print_octal (high
, HOST_BITS_PER_INT
/ 3);
1207 print_octal (low
, HOST_BITS_PER_INT
/ 3);
1211 unsigned int beg
= high
>> excess
;
1213 = ((high
& ((1 << excess
) - 1)) << (3 - excess
)
1214 | (low
>> (HOST_BITS_PER_INT
/ 3 * 3)));
1215 unsigned int end
= low
& ((1 << (HOST_BITS_PER_INT
/ 3 * 3)) - 1);
1216 fprintf (asmfile
, "%o%01o", beg
, middle
);
1217 print_octal (end
, HOST_BITS_PER_INT
/ 3);
1222 print_octal (value
, digits
)
1228 for (i
= digits
- 1; i
>= 0; i
--)
1229 fprintf (asmfile
, "%01o", ((value
>> (3 * i
)) & 7));
1232 /* Output the name of type TYPE, with no punctuation.
1233 Such names can be set up either by typedef declarations
1234 or by struct, enum and union tags. */
1237 dbxout_type_name (type
)
1241 if (TYPE_NAME (type
) == 0)
1243 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
1245 t
= TYPE_NAME (type
);
1247 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1249 t
= DECL_NAME (TYPE_NAME (type
));
1254 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
1255 CHARS (IDENTIFIER_LENGTH (t
));
1258 /* Output a .stabs for the symbol defined by DECL,
1259 which must be a ..._DECL node in the normal namespace.
1260 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1261 LOCAL is nonzero if the scope is less than the entire file. */
1264 dbxout_symbol (decl
, local
)
1269 tree type
= TREE_TYPE (decl
);
1270 tree context
= NULL_TREE
;
1273 /* Cast avoids warning in old compilers. */
1274 current_sym_code
= (STAB_CODE_TYPE
) 0;
1275 current_sym_value
= 0;
1276 current_sym_addr
= 0;
1278 /* Ignore nameless syms, but don't ignore type tags. */
1280 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
1281 || DECL_IGNORED_P (decl
))
1284 dbxout_prepare_symbol (decl
);
1286 /* The output will always start with the symbol name,
1287 so always count that in the length-output-so-far. */
1289 if (DECL_NAME (decl
) != 0)
1290 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
1292 switch (TREE_CODE (decl
))
1295 /* Enum values are defined by defining the enum type. */
1299 if (DECL_RTL (decl
) == 0)
1301 if (TREE_EXTERNAL (decl
))
1303 /* Don't mention a nested function under its parent. */
1304 context
= decl_function_context (decl
);
1305 if (context
== current_function_decl
)
1307 if (GET_CODE (DECL_RTL (decl
)) != MEM
1308 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
1312 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
1313 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1314 TREE_PUBLIC (decl
) ? 'F' : 'f');
1316 current_sym_code
= N_FUN
;
1317 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1319 if (TREE_TYPE (type
))
1320 dbxout_type (TREE_TYPE (type
), 0, 0);
1322 dbxout_type (void_type_node
, 0, 0);
1324 /* For a nested function, when that function is compiled,
1325 mention the containing function name
1326 as well as (since dbx wants it) our own assembler-name. */
1328 fprintf (asmfile
, ",%s,%s",
1329 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1330 IDENTIFIER_POINTER (DECL_NAME (context
)));
1332 dbxout_finish_symbol (decl
);
1337 /* This seems all wrong. Outputting most kinds of types gives no name
1338 at all. A true definition gives no name; a cross-ref for a
1339 structure can give the tag name, but not a type name.
1340 It seems that no typedef name is defined by outputting a type. */
1342 /* If this typedef name was defined by outputting the type,
1343 don't duplicate it. */
1344 if (typevec
[TYPE_SYMTAB_ADDRESS (type
)] == TYPE_DEFINED
1345 && TYPE_NAME (TREE_TYPE (decl
)) == decl
)
1348 /* Don't output the same typedef twice.
1349 And don't output what language-specific stuff doesn't want output. */
1350 if (TREE_ASM_WRITTEN (decl
) || DECL_IGNORED_P (decl
))
1358 if (DECL_NAME (decl
))
1360 /* Nonzero means we must output a tag as well as a typedef. */
1363 /* Output typedef name. */
1364 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
,
1365 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1367 /* Short cut way to output a tag also. */
1368 if ((TREE_CODE (type
) == RECORD_TYPE
1369 || TREE_CODE (type
) == UNION_TYPE
)
1370 && TYPE_NAME (type
) == decl
)
1372 if (use_gdb_dbx_extensions
&& have_used_extensions
)
1374 putc ('T', asmfile
);
1375 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
1381 putc ('t', asmfile
);
1382 current_sym_code
= DBX_DECL_STABS_CODE
;
1384 dbxout_type (type
, 1, 0);
1385 dbxout_finish_symbol (decl
);
1388 if (tag_needed
&& TYPE_NAME (type
) != 0
1389 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1391 /* For a TYPE_DECL with no name, but the type has a name,
1393 This is what represents `struct foo' with no typedef. */
1394 /* In C++, the name of a type is the corresponding typedef.
1395 In C, it is an IDENTIFIER_NODE. */
1396 tree name
= TYPE_NAME (type
);
1397 if (TREE_CODE (name
) == TYPE_DECL
)
1398 name
= DECL_NAME (name
);
1400 current_sym_code
= DBX_DECL_STABS_CODE
;
1401 current_sym_value
= 0;
1402 current_sym_addr
= 0;
1403 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1405 fprintf (asmfile
, "%s \"%s:T", ASM_STABS_OP
,
1406 IDENTIFIER_POINTER (name
));
1407 dbxout_type (type
, 1, 0);
1408 dbxout_finish_symbol (0);
1411 /* Prevent duplicate output of a typedef. */
1412 TREE_ASM_WRITTEN (decl
) = 1;
1417 /* Parm decls go in their own separate chains
1418 and are output by dbxout_reg_parms and dbxout_parms. */
1422 /* Named return value, treat like a VAR_DECL. */
1424 if (DECL_RTL (decl
) == 0)
1426 /* Don't mention a variable that is external.
1427 Let the file that defines it describe it. */
1428 if (TREE_EXTERNAL (decl
))
1431 /* If the variable is really a constant
1432 and not written in memory, inform the debugger. */
1433 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
1434 && DECL_INITIAL (decl
) != 0
1435 && ! TREE_ASM_WRITTEN (decl
)
1436 && (DECL_FIELD_CONTEXT (decl
) == NULL_TREE
1437 || TREE_CODE (DECL_FIELD_CONTEXT (decl
)) == BLOCK
))
1439 if (TREE_PUBLIC (decl
) == 0)
1441 /* The sun4 assembler does not grok this. */
1442 char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1443 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
1444 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
1446 int ival
= TREE_INT_CST_LOW (DECL_INITIAL (decl
));
1447 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1448 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile
, name
, ival
);
1450 fprintf (asmfile
, "%s \"%s:c=i%d\",0x%x,0,0,0\n",
1451 ASM_STABS_OP
, name
, ival
, N_LSYM
);
1455 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
1457 /* don't know how to do this yet. */
1461 /* else it is something we handle like a normal variable. */
1464 DECL_RTL (decl
) = eliminate_regs (DECL_RTL (decl
));
1465 #ifdef LEAF_REG_REMAP
1467 leaf_renumber_regs_insn (DECL_RTL (decl
));
1470 /* Don't mention a variable at all
1471 if it was completely optimized into nothingness.
1473 If DECL was from an inline function, then it's rtl
1474 is not identically the rtl that was used in this
1475 particular compilation. */
1476 if (GET_CODE (DECL_RTL (decl
)) == REG
)
1478 regno
= REGNO (DECL_RTL (decl
));
1479 if (regno
>= FIRST_PSEUDO_REGISTER
)
1480 regno
= reg_renumber
[REGNO (DECL_RTL (decl
))];
1484 else if (GET_CODE (DECL_RTL (decl
)) == SUBREG
)
1486 rtx value
= DECL_RTL (decl
);
1488 while (GET_CODE (value
) == SUBREG
)
1490 offset
+= SUBREG_WORD (value
);
1491 value
= SUBREG_REG (value
);
1493 if (GET_CODE (value
) == REG
)
1495 regno
= REGNO (value
);
1496 if (regno
>= FIRST_PSEUDO_REGISTER
)
1497 regno
= reg_renumber
[REGNO (value
)];
1503 /* The kind-of-variable letter depends on where
1504 the variable is and on the scope of its name:
1505 G and N_GSYM for static storage and global scope,
1506 S for static storage and file scope,
1507 V for static storage and local scope,
1508 for those two, use N_LCSYM if data is in bss segment,
1509 N_STSYM if in data segment, N_FUN otherwise.
1510 (We used N_FUN originally, then changed to N_STSYM
1511 to please GDB. However, it seems that confused ld.
1512 Now GDB has been fixed to like N_FUN, says Kingdon.)
1513 no letter at all, and N_LSYM, for auto variable,
1514 r and N_RSYM for register variable. */
1516 if (GET_CODE (DECL_RTL (decl
)) == MEM
1517 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == SYMBOL_REF
)
1519 if (TREE_PUBLIC (decl
))
1522 current_sym_code
= N_GSYM
;
1526 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1528 letter
= decl_function_context (decl
) ? 'V' : 'S';
1530 if (!DECL_INITIAL (decl
))
1531 current_sym_code
= N_LCSYM
;
1532 else if (TREE_READONLY (decl
) && ! TREE_THIS_VOLATILE (decl
))
1533 /* This is not quite right, but it's the closest
1534 of all the codes that Unix defines. */
1535 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
1538 /* Ultrix `as' seems to need this. */
1539 #ifdef DBX_STATIC_STAB_DATA_SECTION
1542 current_sym_code
= N_STSYM
;
1546 else if (regno
>= 0)
1549 current_sym_code
= N_RSYM
;
1550 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
1552 else if (GET_CODE (DECL_RTL (decl
)) == SUBREG
)
1554 rtx value
= DECL_RTL (decl
);
1556 while (GET_CODE (value
) == SUBREG
)
1558 offset
+= SUBREG_WORD (value
);
1559 value
= SUBREG_REG (value
);
1562 current_sym_code
= N_RSYM
;
1563 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (value
) + offset
);
1565 else if (GET_CODE (DECL_RTL (decl
)) == MEM
1566 && (GET_CODE (XEXP (DECL_RTL (decl
), 0)) == MEM
1567 || (GET_CODE (XEXP (DECL_RTL (decl
), 0)) == REG
1568 && REGNO (XEXP (DECL_RTL (decl
), 0)) != FRAME_POINTER_REGNUM
)))
1569 /* If the value is indirect by memory or by a register
1570 that isn't the frame pointer
1571 then it means the object is variable-sized and address through
1572 that register or stack slot. DBX has no way to represent this
1573 so all we can do is output the variable as a pointer.
1574 If it's not a parameter, ignore it.
1575 (VAR_DECLs like this can be made by integrate.c.) */
1577 if (GET_CODE (XEXP (DECL_RTL (decl
), 0)) == REG
)
1580 current_sym_code
= N_RSYM
;
1581 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (DECL_RTL (decl
), 0)));
1585 current_sym_code
= N_LSYM
;
1586 /* DECL_RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
1587 We want the value of that CONST_INT. */
1589 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (DECL_RTL (decl
), 0), 0));
1592 /* Effectively do build_pointer_type, but don't cache this type,
1593 since it might be temporary whereas the type it points to
1594 might have been saved for inlining. */
1595 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
1596 type
= make_node (POINTER_TYPE
);
1597 TREE_TYPE (type
) = TREE_TYPE (decl
);
1599 else if (GET_CODE (DECL_RTL (decl
)) == MEM
1600 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == REG
)
1602 current_sym_code
= N_LSYM
;
1603 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (DECL_RTL (decl
), 0));
1605 else if (GET_CODE (DECL_RTL (decl
)) == MEM
1606 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == PLUS
1607 && GET_CODE (XEXP (XEXP (DECL_RTL (decl
), 0), 1)) == CONST_INT
)
1609 current_sym_code
= N_LSYM
;
1610 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
1611 We want the value of that CONST_INT. */
1612 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (DECL_RTL (decl
), 0));
1614 else if (GET_CODE (DECL_RTL (decl
)) == MEM
1615 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == CONST
)
1617 /* Handle an obscure case which can arise when optimizing and
1618 when there are few available registers. (This is *always*
1619 the case for i386/i486 targets). The DECL_RTL looks like
1620 (MEM (CONST ...)) even though this variable is a local `auto'
1621 or a local `register' variable. In effect, what has happened
1622 is that the reload pass has seen that all assignments and
1623 references for one such a local variable can be replaced by
1624 equivalent assignments and references to some static storage
1625 variable, thereby avoiding the need for a register. In such
1626 cases we're forced to lie to debuggers and tell them that
1627 this variable was itself `static'. */
1628 current_sym_code
= N_LCSYM
;
1630 current_sym_addr
= XEXP (XEXP (DECL_RTL (decl
), 0), 0);
1633 /* Address might be a MEM, when DECL is a variable-sized object.
1634 Or it might be const0_rtx, meaning previous passes
1635 want us to ignore this variable. */
1638 /* Ok, start a symtab entry and output the variable name. */
1641 #ifdef DBX_STATIC_BLOCK_START
1642 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
1645 /* One slight hitch: if this is a VAR_DECL which is a static
1646 class member, we must put out the mangled name instead of the
1650 /* Note also that static member (variable) names DO NOT begin
1651 with underscores in .stabs directives. */
1652 if (DECL_LANG_SPECIFIC (decl
))
1653 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
1655 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1656 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
, name
);
1658 if (letter
) putc (letter
, asmfile
);
1659 dbxout_type (type
, 0, 0);
1660 dbxout_finish_symbol (decl
);
1662 #ifdef DBX_STATIC_BLOCK_END
1663 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
1670 dbxout_prepare_symbol (decl
)
1674 char *filename
= DECL_SOURCE_FILE (decl
);
1676 dbxout_source_file (asmfile
, filename
);
1681 dbxout_finish_symbol (sym
)
1684 #ifdef DBX_FINISH_SYMBOL
1685 DBX_FINISH_SYMBOL (sym
);
1690 line
= DECL_SOURCE_LINE (sym
);
1693 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
1694 if (current_sym_addr
)
1695 output_addr_const (asmfile
, current_sym_addr
);
1697 fprintf (asmfile
, "%d", current_sym_value
);
1698 putc ('\n', asmfile
);
1702 /* Output definitions of all the decls in a chain. */
1710 dbxout_symbol (syms
, 1);
1711 syms
= TREE_CHAIN (syms
);
1715 /* The following two functions output definitions of function parameters.
1716 Each parameter gets a definition locating it in the parameter list.
1717 Each parameter that is a register variable gets a second definition
1718 locating it in the register.
1720 Printing or argument lists in gdb uses the definitions that
1721 locate in the parameter list. But reference to the variable in
1722 expressions uses preferentially the definition as a register. */
1724 /* Output definitions, referring to storage in the parmlist,
1725 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
1728 dbxout_parms (parms
)
1731 for (; parms
; parms
= TREE_CHAIN (parms
))
1732 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
1734 dbxout_prepare_symbol (parms
);
1736 /* Perform any necessary register eliminations on the parameter's rtl,
1737 so that the debugging output will be accurate. */
1738 DECL_INCOMING_RTL (parms
)
1739 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, 0);
1740 DECL_RTL (parms
) = eliminate_regs (DECL_RTL (parms
), 0, 0);
1741 #ifdef LEAF_REG_REMAP
1744 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
1745 leaf_renumber_regs_insn (DECL_RTL (parms
));
1749 if (PARM_PASSED_IN_MEMORY (parms
))
1751 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
1753 /* ??? Here we assume that the parm address is indexed
1754 off the frame pointer or arg pointer.
1755 If that is not true, we produce meaningless results,
1756 but do not crash. */
1757 if (GET_CODE (addr
) == PLUS
1758 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
1759 current_sym_value
= INTVAL (XEXP (addr
, 1));
1761 current_sym_value
= 0;
1763 current_sym_code
= N_PSYM
;
1764 current_sym_addr
= 0;
1767 if (DECL_NAME (parms
))
1769 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
1771 fprintf (asmfile
, "%s \"%s:p", ASM_STABS_OP
,
1772 IDENTIFIER_POINTER (DECL_NAME (parms
)));
1776 current_sym_nchars
= 8;
1777 fprintf (asmfile
, "%s \"(anon):p", ASM_STABS_OP
);
1780 if (GET_CODE (DECL_RTL (parms
)) == REG
1781 && REGNO (DECL_RTL (parms
)) >= 0
1782 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
1783 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
1786 int original_value
= current_sym_value
;
1788 /* This is the case where the parm is passed as an int or double
1789 and it is converted to a char, short or float and stored back
1790 in the parmlist. In this case, describe the parm
1791 with the variable's declared type, and adjust the address
1792 if the least significant bytes (which we are using) are not
1794 #if BYTES_BIG_ENDIAN
1795 if (TREE_TYPE (parms
) != DECL_ARG_TYPE (parms
))
1796 current_sym_value
+= (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms
)))
1797 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
))));
1800 if (GET_CODE (DECL_RTL (parms
)) == MEM
1801 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == PLUS
1802 && GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == CONST_INT
1803 && INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == current_sym_value
)
1804 dbxout_type (TREE_TYPE (parms
), 0, 0);
1807 current_sym_value
= original_value
;
1808 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
1811 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
1812 dbxout_finish_symbol (parms
);
1814 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
1817 char regparm_letter
;
1818 /* Parm passed in registers and lives in registers or nowhere. */
1820 current_sym_code
= DBX_REGPARM_STABS_CODE
;
1821 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
1822 current_sym_addr
= 0;
1824 /* If parm lives in a register, use that register;
1825 pretend the parm was passed there. It would be more consistent
1826 to describe the register where the parm was passed,
1827 but in practice that register usually holds something else. */
1828 if (REGNO (DECL_RTL (parms
)) >= 0
1829 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
1830 best_rtl
= DECL_RTL (parms
);
1831 /* If the parm lives nowhere,
1832 use the register where it was passed. */
1834 best_rtl
= DECL_INCOMING_RTL (parms
);
1835 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
1838 if (DECL_NAME (parms
))
1840 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
1841 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
1842 IDENTIFIER_POINTER (DECL_NAME (parms
)),
1847 current_sym_nchars
= 8;
1848 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
1852 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
1853 dbxout_finish_symbol (parms
);
1855 else if (GET_CODE (DECL_RTL (parms
)) == MEM
1856 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
1857 && rtx_equal_p (XEXP (DECL_RTL (parms
), 0),
1858 DECL_INCOMING_RTL (parms
)))
1860 /* Parm was passed via invisible reference.
1861 That is, its address was passed in a register.
1862 Output it as if it lived in that register.
1863 The debugger will know from the type
1864 that it was actually passed by invisible reference. */
1866 char regparm_letter
;
1867 /* Parm passed in registers and lives in registers or nowhere. */
1869 current_sym_code
= DBX_REGPARM_STABS_CODE
;
1870 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
1872 /* DECL_RTL looks like (MEM (REG...). Get the register number. */
1873 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
1874 current_sym_addr
= 0;
1877 if (DECL_NAME (parms
))
1879 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
1881 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
1882 IDENTIFIER_POINTER (DECL_NAME (parms
)),
1883 DBX_REGPARM_STABS_LETTER
);
1887 current_sym_nchars
= 8;
1888 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
1889 DBX_REGPARM_STABS_LETTER
);
1892 dbxout_type (TREE_TYPE (parms
), 0, 0);
1893 dbxout_finish_symbol (parms
);
1895 else if (GET_CODE (DECL_RTL (parms
)) == MEM
1896 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
)
1898 /* Parm was passed in registers but lives on the stack. */
1900 current_sym_code
= N_PSYM
;
1901 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
1902 in which case we want the value of that CONST_INT,
1903 or (MEM (REG ...)) or (MEM (MEM ...)),
1904 in which case we use a value of zero. */
1905 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
1906 || GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
1907 current_sym_value
= 0;
1909 current_sym_value
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
1910 current_sym_addr
= 0;
1913 if (DECL_NAME (parms
))
1915 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
1917 fprintf (asmfile
, "%s \"%s:p", ASM_STABS_OP
,
1918 IDENTIFIER_POINTER (DECL_NAME (parms
)));
1922 current_sym_nchars
= 8;
1923 fprintf (asmfile
, "%s \"(anon):p", ASM_STABS_OP
);
1927 = DEBUGGER_ARG_OFFSET (current_sym_value
,
1928 XEXP (DECL_RTL (parms
), 0));
1929 dbxout_type (TREE_TYPE (parms
), 0, 0);
1930 dbxout_finish_symbol (parms
);
1935 /* Output definitions for the places where parms live during the function,
1936 when different from where they were passed, when the parms were passed
1939 It is not useful to do this for parms passed in registers
1940 that live during the function in different registers, because it is
1941 impossible to look in the passed register for the passed value,
1942 so we use the within-the-function register to begin with.
1944 PARMS is a chain of PARM_DECL nodes. */
1947 dbxout_reg_parms (parms
)
1950 for (; parms
; parms
= TREE_CHAIN (parms
))
1951 if (DECL_NAME (parms
))
1953 dbxout_prepare_symbol (parms
);
1955 /* Report parms that live in registers during the function
1956 but were passed in memory. */
1957 if (GET_CODE (DECL_RTL (parms
)) == REG
1958 && REGNO (DECL_RTL (parms
)) >= 0
1959 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
1960 && PARM_PASSED_IN_MEMORY (parms
))
1962 current_sym_code
= N_RSYM
;
1963 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms
)));
1964 current_sym_addr
= 0;
1967 if (DECL_NAME (parms
))
1969 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
1970 fprintf (asmfile
, "%s \"%s:r", ASM_STABS_OP
,
1971 IDENTIFIER_POINTER (DECL_NAME (parms
)));
1975 current_sym_nchars
= 8;
1976 fprintf (asmfile
, "%s \"(anon):r", ASM_STABS_OP
);
1978 dbxout_type (TREE_TYPE (parms
), 0, 0);
1979 dbxout_finish_symbol (parms
);
1981 /* Report parms that live in memory but not where they were passed. */
1982 else if (GET_CODE (DECL_RTL (parms
)) == MEM
1983 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == PLUS
1984 && GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == CONST_INT
1985 && PARM_PASSED_IN_MEMORY (parms
)
1986 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
1988 #if 0 /* ??? It is not clear yet what should replace this. */
1989 int offset
= DECL_OFFSET (parms
) / BITS_PER_UNIT
;
1990 /* A parm declared char is really passed as an int,
1991 so it occupies the least significant bytes.
1992 On a big-endian machine those are not the low-numbered ones. */
1993 #if BYTES_BIG_ENDIAN
1994 if (offset
!= -1 && TREE_TYPE (parms
) != DECL_ARG_TYPE (parms
))
1995 offset
+= (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms
)))
1996 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
))));
1998 if (INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) != offset
) {...}
2000 current_sym_code
= N_LSYM
;
2001 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (DECL_RTL (parms
), 0));
2002 current_sym_addr
= 0;
2004 if (DECL_NAME (parms
))
2006 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2007 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
,
2008 IDENTIFIER_POINTER (DECL_NAME (parms
)));
2012 current_sym_nchars
= 8;
2013 fprintf (asmfile
, "%s \"(anon):", ASM_STABS_OP
);
2015 dbxout_type (TREE_TYPE (parms
), 0, 0);
2016 dbxout_finish_symbol (parms
);
2021 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2022 output definitions of those names, in raw form */
2030 putc (',', asmfile
);
2031 dbxout_type (TREE_VALUE (args
), 0, 0);
2033 args
= TREE_CHAIN (args
);
2037 /* Given a chain of ..._TYPE nodes,
2038 find those which have typedef names and output those names.
2039 This is to ensure those types get output. */
2042 dbxout_types (types
)
2043 register tree types
;
2047 if (TYPE_NAME (types
)
2048 && TREE_CODE (TYPE_NAME (types
)) == TYPE_DECL
2049 && ! TREE_ASM_WRITTEN (TYPE_NAME (types
)))
2050 dbxout_symbol (TYPE_NAME (types
), 1);
2051 types
= TREE_CHAIN (types
);
2055 /* Output everything about a symbol block (a BLOCK node
2056 that represents a scope level),
2057 including recursive output of contained blocks.
2059 BLOCK is the BLOCK node.
2060 DEPTH is its depth within containing symbol blocks.
2061 ARGS is usually zero; but for the outermost block of the
2062 body of a function, it is a chain of PARM_DECLs for the function parameters.
2063 We output definitions of all the register parms
2064 as if they were local variables of that block.
2066 If -g1 was used, we count blocks just the same, but output nothing
2067 except for the outermost block.
2069 Actually, BLOCK may be several blocks chained together.
2070 We handle them all in sequence. */
2073 dbxout_block (block
, depth
, args
)
2074 register tree block
;
2082 /* Ignore blocks never expanded or otherwise marked as real. */
2083 if (TREE_USED (block
))
2085 #ifndef DBX_LBRAC_FIRST
2086 /* In dbx format, the syms of a block come before the N_LBRAC. */
2087 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2088 dbxout_syms (BLOCK_VARS (block
));
2090 dbxout_reg_parms (args
);
2093 /* Now output an N_LBRAC symbol to represent the beginning of
2094 the block. Use the block's tree-walk order to generate
2095 the assembler symbols LBBn and LBEn
2096 that final will define around the code in this block. */
2097 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2100 blocknum
= next_block_number
++;
2101 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
2103 if (BLOCK_HANDLER_BLOCK (block
))
2105 /* A catch block. Must precede N_LBRAC. */
2106 tree decl
= BLOCK_VARS (block
);
2109 #ifdef DBX_OUTPUT_CATCH
2110 DBX_OUTPUT_CATCH (asmfile
, decl
, buf
);
2112 fprintf (asmfile
, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP
,
2113 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
2114 assemble_name (asmfile
, buf
);
2115 fprintf (asmfile
, "\n");
2117 decl
= TREE_CHAIN (decl
);
2121 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_LBRAC
);
2122 assemble_name (asmfile
, buf
);
2123 fprintf (asmfile
, "\n");
2126 /* Count blocks the same way regardless of debug_info_level. */
2127 next_block_number
++;
2129 #ifdef DBX_LBRAC_FIRST
2130 /* On some weird machines, the syms of a block
2131 come after the N_LBRAC. */
2132 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2133 dbxout_syms (BLOCK_VARS (block
));
2135 dbxout_reg_parms (args
);
2138 /* Output the subblocks. */
2139 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, 0);
2141 /* Refer to the marker for the end of the block. */
2142 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2145 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
2146 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_RBRAC
);
2147 assemble_name (asmfile
, buf
);
2148 fprintf (asmfile
, "\n");
2151 block
= BLOCK_CHAIN (block
);
2155 /* Output the information about a function and its arguments and result.
2156 Usually this follows the function's code,
2157 but on some systems, it comes before. */
2160 dbxout_really_begin_function (decl
)
2163 dbxout_symbol (decl
, 0);
2164 dbxout_parms (DECL_ARGUMENTS (decl
));
2165 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
2166 dbxout_symbol (DECL_RESULT (decl
), 1);
2169 /* Called at beginning of output of function definition. */
2172 dbxout_begin_function (decl
)
2175 #ifdef DBX_FUNCTION_FIRST
2176 dbxout_really_begin_function (decl
);
2180 /* Output dbx data for a function definition.
2181 This includes a definition of the function name itself (a symbol),
2182 definitions of the parameters (locating them in the parameter list)
2183 and then output the block that makes up the function's body
2184 (including all the auto variables of the function). */
2187 dbxout_function (decl
)
2190 #ifndef DBX_FUNCTION_FIRST
2191 dbxout_really_begin_function (decl
);
2193 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
2194 #ifdef DBX_OUTPUT_FUNCTION_END
2195 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
2198 #endif /* DBX_DEBUGGING_INFO */