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 (MIPS)
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 /* Subtroutine 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);
561 fprintf (asmfile
, ":");
562 dbxout_type (TREE_TYPE (tem
), 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);
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;
595 #if 0 /* ??? Comment below makes it clear this is unacceptable. */
596 /* Adding 1 here only works on systems
597 which flush an initial underscore from
598 the .stabs entry. This loses for static names
599 which have an initial leading '_' on systems which
600 don't use leading underscores. */
605 fprintf (asmfile
, ":%s;", name
);
606 CHARS (strlen (name
));
610 /* If TEM is non-static, GDB won't understand it. */
611 fprintf (asmfile
, ",0,0;");
614 else if (TREE_CODE (DECL_FIELD_BITPOS (tem
)) == INTEGER_CST
)
616 fprintf (asmfile
, ",%d,%d;",
617 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem
)),
618 TREE_INT_CST_LOW (DECL_SIZE (tem
)));
621 /* This has yet to be implemented. */
628 /* Subtroutine of `dbxout_type_methods'. Output debug info about the
629 method described DECL. DEBUG_NAME is an encoding of the method's
630 type signature. ??? We may be able to do without DEBUG_NAME altogether
634 dbxout_type_method_1 (decl
, debug_name
)
638 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
641 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
643 else /* it's a METHOD_TYPE. */
645 /* A for normal functions.
646 B for `const' member functions.
647 C for `volatile' member functions.
648 D for `const volatile' member functions. */
649 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
651 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
654 if (DECL_VINDEX (decl
))
660 fprintf (asmfile
, ":%s;%c%c%c", debug_name
,
661 TREE_PRIVATE (decl
) ? '0' : TREE_PROTECTED (decl
) ? '1' : '2', c1
, c2
);
662 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
)) + 6
663 - (debug_name
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
664 if (DECL_VINDEX (decl
))
666 fprintf (asmfile
, "%d;",
667 TREE_INT_CST_LOW (DECL_VINDEX (decl
)));
668 dbxout_type (DECL_CONTEXT (decl
), 0);
669 fprintf (asmfile
, ";");
674 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
678 dbxout_type_methods (type
)
681 /* C++: put out the method names and their parameter lists */
683 tree methods
= TYPE_METHODS (type
);
684 register tree fndecl
;
686 register int type_identifier_length
;
688 if (methods
== NULL_TREE
)
691 ctor_name
= DECL_NAME (TYPE_NAME (type
));
692 type_identifier_length
= IDENTIFIER_LENGTH (ctor_name
);
693 if (TREE_CODE (methods
) == FUNCTION_DECL
)
695 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
696 fndecl
= TREE_VEC_ELT (methods
, 0);
697 else fndecl
= TREE_VEC_ELT (methods
, 1);
699 if (TREE_CODE (type
) == RECORD_TYPE
&& DECL_NAME (fndecl
) == ctor_name
)
704 /* Destructors lie in a special place.
705 n.b. TYPE_HAS_DESTRUCTOR == TYPE_LANG_FLAG_2 */
706 if (TYPE_LANG_FLAG_2 (type
))
709 fndecl
= ctor
= TREE_CHAIN (dtor
);
722 /* Output the name of the field (after overloading), as
723 well as the name of the field before overloading, along
724 with its parameter list. */
725 char *debug_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (ctor
));
726 int old_minimal_debug
= flag_minimal_debug
;
730 if (DECL_NAME (ctor
) == ctor_name
&& ! DECL_IGNORED_P (ctor
))
734 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (DECL_NAME (ctor
)));
735 CHARS (IDENTIFIER_LENGTH (DECL_NAME (ctor
)) + 3);
740 /* Always output destructors with full information. */
741 flag_minimal_debug
= 0;
743 dbxout_type (TREE_TYPE (ctor
), 0);
744 flag_minimal_debug
= old_minimal_debug
;
746 if (flag_minimal_debug
&& ctor
!= dtor
)
748 /* Cut down on debugging information by not outputting
749 the parts of the name we can just as easily
750 have the debugger figure out. */
754 /* Get past const and volatile qualifiers. */
755 while (*debug_name
== 'C' || *debug_name
== 'V')
757 /* Get past numeric type length prefix. */
758 while (*debug_name
>= '0' && *debug_name
<= '9')
760 /* Get past type of `this'. */
761 debug_name
+= type_identifier_length
;
763 dbxout_type_method_1 (ctor
, debug_name
);
769 ctor
= TREE_CHAIN (ctor
);
770 if (ctor
== NULL_TREE
|| DECL_NAME (ctor
) != ctor_name
)
783 tree name
= DECL_NAME (fndecl
);
784 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (name
));
785 CHARS (IDENTIFIER_LENGTH (name
) + 3);
787 for (last
= NULL_TREE
;
788 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
789 fndecl
= TREE_CHAIN (fndecl
))
790 /* Output the name of the field (after overloading), as
791 well as the name of the field before overloading, along
792 with its parameter list */
794 char *debug_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
));
799 dbxout_type (TREE_TYPE (fndecl
), 0);
800 if (flag_minimal_debug
)
802 debug_name
+= IDENTIFIER_LENGTH (DECL_NAME (fndecl
)) + 2;
803 /* Get past const and volatile qualifiers. */
804 while (*debug_name
== 'C' || *debug_name
== 'V')
806 while (*debug_name
>= '0' && *debug_name
<= '9')
808 debug_name
+= type_identifier_length
;
810 dbxout_type_method_1 (fndecl
, debug_name
);
817 /* Output a reference to a type. If the type has not yet been
818 described in the dbx output, output its definition now.
819 For a type already defined, just refer to its definition
820 using the type number.
822 If FULL is nonzero, and the type has been described only with
823 a forward-reference, output the definition now.
824 If FULL is zero in this case, just refer to the forward-reference
825 using the number previously allocated. */
828 dbxout_type (type
, full
)
834 /* If there was an input error and we don't really have a type,
835 avoid crashing and write something that is at least valid
836 by assuming `int'. */
837 if (type
== error_mark_node
)
838 type
= integer_type_node
;
841 type
= TYPE_MAIN_VARIANT (type
);
843 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
844 && DECL_IGNORED_P (TYPE_NAME (type
)))
848 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
850 /* Type has no dbx number assigned. Assign next available number. */
851 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
853 /* Make sure type vector is long enough to record about this type. */
855 if (next_type_number
== typevec_len
)
857 typevec
= (enum typestatus
*) xrealloc (typevec
, typevec_len
* 2 * sizeof typevec
[0]);
858 bzero (typevec
+ typevec_len
, typevec_len
* sizeof typevec
[0]);
863 /* Output the number of this type, to refer to it. */
864 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
867 #ifdef DBX_TYPE_DEFINED
868 if (DBX_TYPE_DEFINED (type
))
872 /* If this type's definition has been output or is now being output,
875 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)])
888 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
889 leave the type-number completely undefined rather than output
890 a cross-reference. */
891 if (TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
892 || TREE_CODE (type
) == ENUMERAL_TYPE
)
894 if ((TYPE_NAME (type
) != 0 && !full
)
895 || TYPE_SIZE (type
) == 0)
897 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_XREF
;
902 /* Output a definition now. */
904 fprintf (asmfile
, "=");
907 /* Mark it as defined, so that if it is self-referent
908 we will not get into an infinite recursion of definitions. */
910 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_DEFINED
;
912 switch (TREE_CODE (type
))
916 /* For a void type, just define it as itself; ie, "5=5".
917 This makes us consider it defined
918 without saying what it is. The debugger will make it
919 a void type when the reference is seen, and nothing will
920 ever override that default. */
921 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
926 if (type
== char_type_node
&& ! TREE_UNSIGNED (type
))
927 /* Output the type `char' as a subrange of itself!
928 I don't understand this definition, just copied it
929 from the output of pcc.
930 This used to use `r2' explicitly and we used to
931 take care to make sure that `char' was type number 2. */
932 fprintf (asmfile
, "r%d;0;127;", TYPE_SYMTAB_ADDRESS (type
));
934 else if (TYPE_PRECISION (type
) > BITS_PER_WORD
)
936 /* This used to say `r1' and we used to take care
937 to make sure that `int' was type number 1. */
938 fprintf (asmfile
, "r%d;", TYPE_SYMTAB_ADDRESS (integer_type_node
));
939 print_int_cst_octal (TYPE_MIN_VALUE (type
));
940 fprintf (asmfile
, ";");
941 print_int_cst_octal (TYPE_MAX_VALUE (type
));
942 fprintf (asmfile
, ";");
946 /* Output other integer types as subranges of `int'. */
947 /* This used to say `r1' and we used to take care
948 to make sure that `int' was type number 1. */
949 fprintf (asmfile
, "r%d;%d;%d;",
950 TYPE_SYMTAB_ADDRESS (integer_type_node
),
951 TREE_INT_CST_LOW (TYPE_MIN_VALUE (type
)),
952 TREE_INT_CST_LOW (TYPE_MAX_VALUE (type
)));
957 /* This used to say `r1' and we used to take care
958 to make sure that `int' was type number 1. */
959 fprintf (asmfile
, "r%d;%d;0;", TYPE_SYMTAB_ADDRESS (integer_type_node
),
960 TREE_INT_CST_LOW (size_in_bytes (type
)));
965 /* Output "a" followed by a range type definition
966 for the index type of the array
967 followed by a reference to the target-type.
968 ar1;0;N;M for an array of type M and size N. */
969 /* This used to say `r1' and we used to take care
970 to make sure that `int' was type number 1. */
971 fprintf (asmfile
, "ar%d;0;%d;", TYPE_SYMTAB_ADDRESS (integer_type_node
),
974 ? TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)))
977 dbxout_type (TREE_TYPE (type
), 0);
983 int i
, n_baseclasses
= 0;
985 if (TYPE_BINFO (type
) != 0 && TYPE_BINFO_BASETYPES (type
) != 0)
986 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
988 /* Output a structure type. */
989 if ((TYPE_NAME (type
) != 0
990 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
991 && DECL_IGNORED_P (TYPE_NAME (type
)))
993 || TYPE_SIZE (type
) == 0)
995 /* If the type is just a cross reference, output one
996 and mark the type as partially described.
997 If it later becomes defined, we will output
999 If the type has a name, don't nest its definition within
1000 another type's definition; instead, output an xref
1001 and let the definition come when the name is defined. */
1002 fprintf (asmfile
, (TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu");
1004 #if 0 /* This assertion is legitimately false in C++. */
1005 /* We shouldn't be outputting a reference to a type before its
1006 definition unless the type has a tag name.
1007 A typedef name without a tag name should be impossible. */
1008 if (TREE_CODE (TYPE_NAME (type
)) != IDENTIFIER_NODE
)
1011 dbxout_type_name (type
);
1012 fprintf (asmfile
, ":");
1013 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_XREF
;
1016 tem
= size_in_bytes (type
);
1018 /* The code below assumes the size is an integer constant. */
1019 if (TREE_CODE (tem
) != INTEGER_CST
)
1022 /* Identify record or union, and print its size. */
1023 fprintf (asmfile
, (TREE_CODE (type
) == RECORD_TYPE
) ? "s%d" : "u%d",
1024 TREE_INT_CST_LOW (tem
));
1026 if (use_gdb_dbx_extensions
)
1030 have_used_extensions
= 1;
1031 fprintf (asmfile
, "!%d,", n_baseclasses
);
1035 for (i
= 0; i
< n_baseclasses
; i
++)
1037 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)), i
);
1038 if (use_gdb_dbx_extensions
)
1040 have_used_extensions
= 1;
1041 putc (TREE_VIA_VIRTUAL (child
) ? '1'
1044 putc (TREE_VIA_PUBLIC (child
) ? '2'
1047 fprintf (asmfile
, "%d,",
1048 TREE_INT_CST_LOW (BINFO_OFFSET (child
)) * BITS_PER_UNIT
);
1050 dbxout_type (BINFO_TYPE (child
), 0);
1051 putc (';', asmfile
);
1055 /* Print out the base class information with fields
1056 which have the same names at the types they hold. */
1057 dbxout_type_name (BINFO_TYPE (child
));
1058 putc (':', asmfile
);
1059 dbxout_type (BINFO_TYPE (child
), full
);
1060 fprintf (asmfile
, ",%d,%d;",
1061 TREE_INT_CST_LOW (BINFO_OFFSET (child
)) * BITS_PER_UNIT
,
1062 TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child
)))) * BITS_PER_UNIT
);
1070 /* Write out the field declarations. */
1071 dbxout_type_fields (type
);
1072 if (use_gdb_dbx_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1074 have_used_extensions
= 1;
1075 dbxout_type_methods (type
);
1077 putc (';', asmfile
);
1079 if (use_gdb_dbx_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1080 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1081 && TYPE_VFIELD (type
))
1083 have_used_extensions
= 1;
1085 /* Tell GDB+ that it may keep reading. */
1086 putc ('~', asmfile
);
1088 /* We need to write out info about what field this class
1089 uses as its "main" vtable pointer field, because if this
1090 field is inherited from a base class, GDB cannot necessarily
1091 figure out which field it's using in time. */
1092 if (TYPE_VFIELD (type
))
1094 putc ('%', asmfile
);
1095 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0);
1097 putc (';', asmfile
);
1103 if ((TYPE_NAME (type
) != 0 && !full
1104 && (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1105 && ! DECL_IGNORED_P (TYPE_NAME (type
))))
1106 || TYPE_SIZE (type
) == 0)
1108 fprintf (asmfile
, "xe");
1110 dbxout_type_name (type
);
1111 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_XREF
;
1112 fprintf (asmfile
, ":");
1115 putc ('e', asmfile
);
1117 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1119 fprintf (asmfile
, "%s:%d,", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)),
1120 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1121 CHARS (11 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)));
1122 if (TREE_CHAIN (tem
) != 0)
1125 putc (';', asmfile
);
1130 putc ('*', asmfile
);
1132 dbxout_type (TREE_TYPE (type
), 0);
1136 if (use_gdb_dbx_extensions
)
1138 have_used_extensions
= 1;
1139 putc ('#', asmfile
);
1141 if (flag_minimal_debug
)
1143 putc ('#', asmfile
);
1144 dbxout_type (TREE_TYPE (type
), 0);
1145 putc (';', asmfile
);
1150 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0);
1151 putc (',', asmfile
);
1153 dbxout_type (TREE_TYPE (type
), 0);
1154 dbxout_args (TYPE_ARG_TYPES (type
));
1155 putc (';', asmfile
);
1161 /* Treat it as a function type. */
1162 dbxout_type (TREE_TYPE (type
), 0);
1167 if (use_gdb_dbx_extensions
)
1169 have_used_extensions
= 1;
1170 putc ('@', asmfile
);
1172 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0);
1173 putc (',', asmfile
);
1175 dbxout_type (TREE_TYPE (type
), 0);
1179 /* Should print as an int, because it is really
1181 dbxout_type (integer_type_node
, 0);
1185 case REFERENCE_TYPE
:
1186 if (use_gdb_dbx_extensions
)
1187 have_used_extensions
= 1;
1188 putc (use_gdb_dbx_extensions
? '&' : '*', asmfile
);
1190 dbxout_type (TREE_TYPE (type
), 0);
1194 putc ('f', asmfile
);
1196 dbxout_type (TREE_TYPE (type
), 0);
1204 /* Print the value of integer constant C, in octal,
1205 handling double precision. */
1208 print_int_cst_octal (c
)
1211 unsigned int high
= TREE_INT_CST_HIGH (c
);
1212 unsigned int low
= TREE_INT_CST_LOW (c
);
1213 int excess
= (3 - (HOST_BITS_PER_INT
% 3));
1215 fprintf (asmfile
, "0");
1219 print_octal (high
, HOST_BITS_PER_INT
/ 3);
1220 print_octal (low
, HOST_BITS_PER_INT
/ 3);
1224 unsigned int beg
= high
>> excess
;
1226 = ((high
& ((1 << excess
) - 1)) << (3 - excess
)
1227 | (low
>> (HOST_BITS_PER_INT
/ 3 * 3)));
1228 unsigned int end
= low
& ((1 << (HOST_BITS_PER_INT
/ 3 * 3)) - 1);
1229 fprintf (asmfile
, "%o%01o", beg
, middle
);
1230 print_octal (end
, HOST_BITS_PER_INT
/ 3);
1235 print_octal (value
, digits
)
1241 for (i
= digits
- 1; i
>= 0; i
--)
1242 fprintf (asmfile
, "%01o", ((value
>> (3 * i
)) & 7));
1245 /* Output the name of type TYPE, with no punctuation.
1246 Such names can be set up either by typedef declarations
1247 or by struct, enum and union tags. */
1250 dbxout_type_name (type
)
1254 if (TYPE_NAME (type
) == 0)
1256 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
1258 t
= TYPE_NAME (type
);
1260 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1262 t
= DECL_NAME (TYPE_NAME (type
));
1267 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
1268 CHARS (IDENTIFIER_LENGTH (t
));
1271 /* Output a .stabs for the symbol defined by DECL,
1272 which must be a ..._DECL node in the normal namespace.
1273 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1274 LOCAL is nonzero if the scope is less than the entire file. */
1277 dbxout_symbol (decl
, local
)
1282 tree type
= TREE_TYPE (decl
);
1283 tree context
= NULL_TREE
;
1286 /* Cast avoids warning in old compilers. */
1287 current_sym_code
= (STAB_CODE_TYPE
) 0;
1288 current_sym_value
= 0;
1289 current_sym_addr
= 0;
1291 /* Ignore nameless syms, but don't ignore type tags. */
1293 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
1294 || DECL_IGNORED_P (decl
))
1297 dbxout_prepare_symbol (decl
);
1299 /* The output will always start with the symbol name,
1300 so always count that in the length-output-so-far. */
1302 if (DECL_NAME (decl
) != 0)
1303 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
1305 switch (TREE_CODE (decl
))
1308 /* Enum values are defined by defining the enum type. */
1312 if (DECL_RTL (decl
) == 0)
1314 if (TREE_EXTERNAL (decl
))
1316 /* Don't mention a nested function under its parent. */
1317 context
= decl_function_context (decl
);
1318 if (context
== current_function_decl
)
1320 if (GET_CODE (DECL_RTL (decl
)) != MEM
1321 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
1325 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
1326 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1327 TREE_PUBLIC (decl
) ? 'F' : 'f');
1329 current_sym_code
= N_FUN
;
1330 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1332 if (TREE_TYPE (type
))
1333 dbxout_type (TREE_TYPE (type
), 0);
1335 dbxout_type (void_type_node
, 0);
1337 /* For a nested function, when that function is compiled,
1338 mention the containing function name
1339 as well as (since dbx wants it) our own assembler-name. */
1341 fprintf (asmfile
, ",%s,%s",
1342 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1343 IDENTIFIER_POINTER (DECL_NAME (context
)));
1345 dbxout_finish_symbol (decl
);
1350 /* This seems all wrong. Outputting most kinds of types gives no name
1351 at all. A true definition gives no name; a cross-ref for a
1352 structure can give the tag name, but not a type name.
1353 It seems that no typedef name is defined by outputting a type. */
1355 /* If this typedef name was defined by outputting the type,
1356 don't duplicate it. */
1357 if (typevec
[TYPE_SYMTAB_ADDRESS (type
)] == TYPE_DEFINED
1358 && TYPE_NAME (TREE_TYPE (decl
)) == decl
)
1361 /* Don't output the same typedef twice.
1362 And don't output what language-specific stuff doesn't want output. */
1363 if (TREE_ASM_WRITTEN (decl
) || DECL_IGNORED_P (decl
))
1368 if (DECL_NAME (decl
))
1370 /* Output typedef name. */
1371 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
,
1372 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1374 /* If there is a typedecl for this type with the same name
1375 as the tag, output an abbreviated form for that typedecl. */
1376 if (use_gdb_dbx_extensions
&& have_used_extensions
1377 && (TREE_CODE (type
) == RECORD_TYPE
1378 || TREE_CODE (type
) == UNION_TYPE
)
1379 && (TYPE_NAME (type
) == decl
))
1381 putc ('T', asmfile
);
1382 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
1384 putc ('t', asmfile
);
1385 current_sym_code
= DBX_DECL_STABS_CODE
;
1387 dbxout_type (type
, 1);
1388 dbxout_finish_symbol (decl
);
1390 else if (TYPE_NAME (type
) != 0 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1392 /* Output a tag (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);
1408 dbxout_finish_symbol (0);
1411 /* Prevent duplicate output of a typedef. */
1412 TREE_ASM_WRITTEN (decl
) = 1;
1416 /* Parm decls go in their own separate chains
1417 and are output by dbxout_reg_parms and dbxout_parms. */
1421 /* Named return value, treat like a VAR_DECL. */
1423 if (DECL_RTL (decl
) == 0)
1425 /* Don't mention a variable that is external.
1426 Let the file that defines it describe it. */
1427 if (TREE_EXTERNAL (decl
))
1430 /* If the variable is really a constant
1431 and not written in memory, inform the debugger. */
1432 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
1433 && DECL_INITIAL (decl
) != 0
1434 && ! TREE_ASM_WRITTEN (decl
)
1435 && (DECL_FIELD_CONTEXT (decl
) == NULL_TREE
1436 || TREE_CODE (DECL_FIELD_CONTEXT (decl
)) == BLOCK
))
1438 if (TREE_PUBLIC (decl
) == 0)
1440 /* The sun4 assembler does not grok this. */
1441 char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1442 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
1443 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
1445 int ival
= TREE_INT_CST_LOW (DECL_INITIAL (decl
));
1446 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1447 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile
, name
, ival
);
1449 fprintf (asmfile
, "%s \"%s:c=i%d\",0x%x,0,0,0\n",
1450 ASM_STABS_OP
, name
, ival
, N_LSYM
);
1454 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
1456 /* don't know how to do this yet. */
1460 /* else it is something we handle like a normal variable. */
1463 DECL_RTL (decl
) = eliminate_regs (DECL_RTL (decl
));
1464 #ifdef LEAF_REG_REMAP
1466 leaf_renumber_regs_insn (DECL_RTL (decl
));
1469 /* Don't mention a variable at all
1470 if it was completely optimized into nothingness.
1472 If DECL was from an inline function, then it's rtl
1473 is not identically the rtl that was used in this
1474 particular compilation. */
1475 if (GET_CODE (DECL_RTL (decl
)) == REG
)
1477 regno
= REGNO (DECL_RTL (decl
));
1478 if (regno
>= FIRST_PSEUDO_REGISTER
)
1479 regno
= reg_renumber
[REGNO (DECL_RTL (decl
))];
1483 else if (GET_CODE (DECL_RTL (decl
)) == SUBREG
)
1485 rtx value
= DECL_RTL (decl
);
1487 while (GET_CODE (value
) == SUBREG
)
1489 offset
+= SUBREG_WORD (value
);
1490 value
= SUBREG_REG (value
);
1492 if (GET_CODE (value
) == REG
)
1494 regno
= REGNO (value
);
1495 if (regno
>= FIRST_PSEUDO_REGISTER
)
1496 regno
= reg_renumber
[REGNO (value
)];
1502 /* The kind-of-variable letter depends on where
1503 the variable is and on the scope of its name:
1504 G and N_GSYM for static storage and global scope,
1505 S for static storage and file scope,
1506 V for static storage and local scope,
1507 for those two, use N_LCSYM if data is in bss segment,
1508 N_STSYM if in data segment, N_FUN otherwise.
1509 (We used N_FUN originally, then changed to N_STSYM
1510 to please GDB. However, it seems that confused ld.
1511 Now GDB has been fixed to like N_FUN, says Kingdon.)
1512 no letter at all, and N_LSYM, for auto variable,
1513 r and N_RSYM for register variable. */
1515 if (GET_CODE (DECL_RTL (decl
)) == MEM
1516 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == SYMBOL_REF
)
1518 if (TREE_PUBLIC (decl
))
1521 current_sym_code
= N_GSYM
;
1525 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1527 letter
= TREE_PERMANENT (decl
) ? 'S' : 'V';
1529 if (!DECL_INITIAL (decl
))
1530 current_sym_code
= N_LCSYM
;
1531 else if (TREE_READONLY (decl
) && ! TREE_THIS_VOLATILE (decl
))
1532 /* This is not quite right, but it's the closest
1533 of all the codes that Unix defines. */
1534 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
1537 /* Ultrix `as' seems to need this. */
1538 #ifdef DBX_STATIC_STAB_DATA_SECTION
1541 current_sym_code
= N_STSYM
;
1545 else if (regno
>= 0)
1548 current_sym_code
= N_RSYM
;
1549 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
1551 else if (GET_CODE (DECL_RTL (decl
)) == SUBREG
)
1553 rtx value
= DECL_RTL (decl
);
1555 while (GET_CODE (value
) == SUBREG
)
1557 offset
+= SUBREG_WORD (value
);
1558 value
= SUBREG_REG (value
);
1561 current_sym_code
= N_RSYM
;
1562 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (value
) + offset
);
1564 else if (GET_CODE (DECL_RTL (decl
)) == MEM
1565 && (GET_CODE (XEXP (DECL_RTL (decl
), 0)) == MEM
1566 || (GET_CODE (XEXP (DECL_RTL (decl
), 0)) == REG
1567 && REGNO (XEXP (DECL_RTL (decl
), 0)) != FRAME_POINTER_REGNUM
)))
1568 /* If the value is indirect by memory or by a register
1569 that isn't the frame pointer
1570 then it means the object is variable-sized and address through
1571 that register or stack slot. DBX has no way to represent this
1572 so all we can do is output the variable as a pointer.
1573 If it's not a parameter, ignore it.
1574 (VAR_DECLs like this can be made by integrate.c.) */
1576 if (GET_CODE (XEXP (DECL_RTL (decl
), 0)) == REG
)
1579 current_sym_code
= N_RSYM
;
1580 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (DECL_RTL (decl
), 0)));
1584 current_sym_code
= N_LSYM
;
1585 /* DECL_RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
1586 We want the value of that CONST_INT. */
1588 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (DECL_RTL (decl
), 0), 0));
1591 /* Effectively do build_pointer_type, but don't cache this type,
1592 since it might be temporary whereas the type it points to
1593 might have been saved for inlining. */
1594 type
= make_node (REFERENCE_TYPE
);
1595 TREE_TYPE (type
) = TREE_TYPE (decl
);
1597 else if (GET_CODE (DECL_RTL (decl
)) == MEM
1598 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == REG
)
1600 current_sym_code
= N_LSYM
;
1601 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (DECL_RTL (decl
), 0));
1603 else if (GET_CODE (DECL_RTL (decl
)) == MEM
1604 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == PLUS
1605 && GET_CODE (XEXP (XEXP (DECL_RTL (decl
), 0), 1)) == CONST_INT
)
1607 current_sym_code
= N_LSYM
;
1608 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
1609 We want the value of that CONST_INT. */
1610 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (DECL_RTL (decl
), 0));
1612 else if (GET_CODE (DECL_RTL (decl
)) == MEM
1613 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == CONST
)
1615 /* Handle an obscure case which can arise when optimizing and
1616 when there are few available registers. (This is *always*
1617 the case for i386/i486 targets). The DECL_RTL looks like
1618 (MEM (CONST ...)) even though this variable is a local `auto'
1619 or a local `register' variable. In effect, what has happened
1620 is that the reload pass has seen that all assignments and
1621 references for one such a local variable can be replaced by
1622 equivalent assignments and references to some static storage
1623 variable, thereby avoiding the need for a register. In such
1624 cases we're forced to lie to debuggers and tell them that
1625 this variable was itself `static'. */
1626 current_sym_code
= N_LCSYM
;
1628 current_sym_addr
= XEXP (XEXP (DECL_RTL (decl
), 0), 0);
1631 /* Address might be a MEM, when DECL is a variable-sized object.
1632 Or it might be const0_rtx, meaning previous passes
1633 want us to ignore this variable. */
1636 /* Ok, start a symtab entry and output the variable name. */
1639 #ifdef DBX_STATIC_BLOCK_START
1640 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
1643 /* One slight hitch: if this is a VAR_DECL which is a static
1644 class member, we must put out the mangled name instead of the
1648 /* Note also that static member (variable) names DO NOT begin
1649 with underscores in .stabs directives. */
1650 if (DECL_LANG_SPECIFIC (decl
))
1652 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
1654 #if 0 /* Tiemann says get rid of this. */
1655 /* Adding 1 here only works on systems
1656 which flush an initial underscore. */
1662 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1663 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
, name
);
1665 if (letter
) putc (letter
, asmfile
);
1666 dbxout_type (type
, 0);
1667 dbxout_finish_symbol (decl
);
1669 #ifdef DBX_STATIC_BLOCK_END
1670 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
1677 dbxout_prepare_symbol (decl
)
1681 char *filename
= DECL_SOURCE_FILE (decl
);
1683 dbxout_source_file (asmfile
, filename
);
1688 dbxout_finish_symbol (sym
)
1691 #ifdef DBX_FINISH_SYMBOL
1692 DBX_FINISH_SYMBOL (sym
);
1697 line
= DECL_SOURCE_LINE (sym
);
1700 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
1701 if (current_sym_addr
)
1702 output_addr_const (asmfile
, current_sym_addr
);
1704 fprintf (asmfile
, "%d", current_sym_value
);
1705 putc ('\n', asmfile
);
1709 /* Output definitions of all the decls in a chain. */
1717 dbxout_symbol (syms
, 1);
1718 syms
= TREE_CHAIN (syms
);
1722 /* The following two functions output definitions of function parameters.
1723 Each parameter gets a definition locating it in the parameter list.
1724 Each parameter that is a register variable gets a second definition
1725 locating it in the register.
1727 Printing or argument lists in gdb uses the definitions that
1728 locate in the parameter list. But reference to the variable in
1729 expressions uses preferentially the definition as a register. */
1731 /* Output definitions, referring to storage in the parmlist,
1732 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
1735 dbxout_parms (parms
)
1738 for (; parms
; parms
= TREE_CHAIN (parms
))
1739 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
1741 dbxout_prepare_symbol (parms
);
1743 /* Perform any necessary register eliminations on the parameter's rtl,
1744 so that the debugging output will be accurate. */
1745 DECL_INCOMING_RTL (parms
)
1746 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, 0);
1747 DECL_RTL (parms
) = eliminate_regs (DECL_RTL (parms
), 0, 0);
1748 #ifdef LEAF_REG_REMAP
1751 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
1752 leaf_renumber_regs_insn (DECL_RTL (parms
));
1756 if (PARM_PASSED_IN_MEMORY (parms
))
1758 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
1760 /* ??? Here we assume that the parm address is indexed
1761 off the frame pointer or arg pointer.
1762 If that is not true, we produce meaningless results,
1763 but do not crash. */
1764 if (GET_CODE (addr
) == PLUS
1765 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
1766 current_sym_value
= INTVAL (XEXP (addr
, 1));
1768 current_sym_value
= 0;
1770 current_sym_code
= N_PSYM
;
1771 current_sym_addr
= 0;
1774 if (DECL_NAME (parms
))
1776 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
1778 fprintf (asmfile
, "%s \"%s:p", ASM_STABS_OP
,
1779 IDENTIFIER_POINTER (DECL_NAME (parms
)));
1783 current_sym_nchars
= 8;
1784 fprintf (asmfile
, "%s \"(anon):p", ASM_STABS_OP
);
1787 if (GET_CODE (DECL_RTL (parms
)) == REG
1788 && REGNO (DECL_RTL (parms
)) >= 0
1789 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
1790 dbxout_type (DECL_ARG_TYPE (parms
), 0);
1793 int original_value
= current_sym_value
;
1795 /* This is the case where the parm is passed as an int or double
1796 and it is converted to a char, short or float and stored back
1797 in the parmlist. In this case, describe the parm
1798 with the variable's declared type, and adjust the address
1799 if the least significant bytes (which we are using) are not
1801 #if BYTES_BIG_ENDIAN
1802 if (TREE_TYPE (parms
) != DECL_ARG_TYPE (parms
))
1803 current_sym_value
+= (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms
)))
1804 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
))));
1807 if (GET_CODE (DECL_RTL (parms
)) == MEM
1808 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == PLUS
1809 && GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == CONST_INT
1810 && INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == current_sym_value
)
1811 dbxout_type (TREE_TYPE (parms
), 0);
1814 current_sym_value
= original_value
;
1815 dbxout_type (DECL_ARG_TYPE (parms
), 0);
1818 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
1819 dbxout_finish_symbol (parms
);
1821 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
1824 char regparm_letter
;
1825 /* Parm passed in registers and lives in registers or nowhere. */
1827 current_sym_code
= DBX_REGPARM_STABS_CODE
;
1828 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
1829 current_sym_addr
= 0;
1831 /* If parm lives in a register, use that register;
1832 pretend the parm was passed there. It would be more consistent
1833 to describe the register where the parm was passed,
1834 but in practice that register usually holds something else. */
1835 if (REGNO (DECL_RTL (parms
)) >= 0
1836 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
1837 best_rtl
= DECL_RTL (parms
);
1838 /* If the parm lives nowhere,
1839 use the register where it was passed. */
1841 best_rtl
= DECL_INCOMING_RTL (parms
);
1842 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
1845 if (DECL_NAME (parms
))
1847 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
1848 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
1849 IDENTIFIER_POINTER (DECL_NAME (parms
)),
1854 current_sym_nchars
= 8;
1855 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
1859 dbxout_type (DECL_ARG_TYPE (parms
), 0);
1860 dbxout_finish_symbol (parms
);
1862 else if (GET_CODE (DECL_RTL (parms
)) == MEM
1863 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
)
1865 /* Parm was passed in registers but lives on the stack. */
1867 current_sym_code
= N_PSYM
;
1868 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
1869 in which case we want the value of that CONST_INT,
1870 or (MEM (REG ...)) or (MEM (MEM ...)),
1871 in which case we use a value of zero. */
1872 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
1873 || GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
1874 current_sym_value
= 0;
1876 current_sym_value
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
1877 current_sym_addr
= 0;
1880 if (DECL_NAME (parms
))
1882 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
1884 fprintf (asmfile
, "%s \"%s:p", ASM_STABS_OP
,
1885 IDENTIFIER_POINTER (DECL_NAME (parms
)));
1889 current_sym_nchars
= 8;
1890 fprintf (asmfile
, "%s \"(anon):p", ASM_STABS_OP
);
1894 = DEBUGGER_ARG_OFFSET (current_sym_value
,
1895 XEXP (DECL_RTL (parms
), 0));
1896 dbxout_type (TREE_TYPE (parms
), 0);
1897 dbxout_finish_symbol (parms
);
1902 /* Output definitions for the places where parms live during the function,
1903 when different from where they were passed, when the parms were passed
1906 It is not useful to do this for parms passed in registers
1907 that live during the function in different registers, because it is
1908 impossible to look in the passed register for the passed value,
1909 so we use the within-the-function register to begin with.
1911 PARMS is a chain of PARM_DECL nodes. */
1914 dbxout_reg_parms (parms
)
1917 for (; parms
; parms
= TREE_CHAIN (parms
))
1918 if (DECL_NAME (parms
))
1920 dbxout_prepare_symbol (parms
);
1922 /* Report parms that live in registers during the function
1923 but were passed in memory. */
1924 if (GET_CODE (DECL_RTL (parms
)) == REG
1925 && REGNO (DECL_RTL (parms
)) >= 0
1926 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
1927 && PARM_PASSED_IN_MEMORY (parms
))
1929 current_sym_code
= N_RSYM
;
1930 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms
)));
1931 current_sym_addr
= 0;
1934 if (DECL_NAME (parms
))
1936 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
1937 fprintf (asmfile
, "%s \"%s:r", ASM_STABS_OP
,
1938 IDENTIFIER_POINTER (DECL_NAME (parms
)));
1942 current_sym_nchars
= 8;
1943 fprintf (asmfile
, "%s \"(anon):r", ASM_STABS_OP
);
1945 dbxout_type (TREE_TYPE (parms
), 0);
1946 dbxout_finish_symbol (parms
);
1948 /* Report parms that live in memory but not where they were passed. */
1949 else if (GET_CODE (DECL_RTL (parms
)) == MEM
1950 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == PLUS
1951 && GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == CONST_INT
1952 && PARM_PASSED_IN_MEMORY (parms
)
1953 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
1955 #if 0 /* ??? It is not clear yet what should replace this. */
1956 int offset
= DECL_OFFSET (parms
) / BITS_PER_UNIT
;
1957 /* A parm declared char is really passed as an int,
1958 so it occupies the least significant bytes.
1959 On a big-endian machine those are not the low-numbered ones. */
1960 #if BYTES_BIG_ENDIAN
1961 if (offset
!= -1 && TREE_TYPE (parms
) != DECL_ARG_TYPE (parms
))
1962 offset
+= (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms
)))
1963 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
))));
1965 if (INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) != offset
) {...}
1967 current_sym_code
= N_LSYM
;
1968 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (DECL_RTL (parms
), 0));
1969 current_sym_addr
= 0;
1971 if (DECL_NAME (parms
))
1973 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
1974 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
,
1975 IDENTIFIER_POINTER (DECL_NAME (parms
)));
1979 current_sym_nchars
= 8;
1980 fprintf (asmfile
, "%s \"(anon):", ASM_STABS_OP
);
1982 dbxout_type (TREE_TYPE (parms
), 0);
1983 dbxout_finish_symbol (parms
);
1988 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
1989 output definitions of those names, in raw form */
1997 putc (',', asmfile
);
1998 dbxout_type (TREE_VALUE (args
), 0);
2000 args
= TREE_CHAIN (args
);
2004 /* Given a chain of ..._TYPE nodes,
2005 find those which have typedef names and output those names.
2006 This is to ensure those types get output. */
2009 dbxout_types (types
)
2010 register tree types
;
2014 if (TYPE_NAME (types
)
2015 && TREE_CODE (TYPE_NAME (types
)) == TYPE_DECL
2016 && ! TREE_ASM_WRITTEN (TYPE_NAME (types
)))
2017 dbxout_symbol (TYPE_NAME (types
), 1);
2018 types
= TREE_CHAIN (types
);
2022 /* Output everything about a symbol block (a BLOCK node
2023 that represents a scope level),
2024 including recursive output of contained blocks.
2026 BLOCK is the BLOCK node.
2027 DEPTH is its depth within containing symbol blocks.
2028 ARGS is usually zero; but for the outermost block of the
2029 body of a function, it is a chain of PARM_DECLs for the function parameters.
2030 We output definitions of all the register parms
2031 as if they were local variables of that block.
2033 If -g1 was used, we count blocks just the same, but output nothing
2034 except for the outermost block.
2036 Actually, BLOCK may be several blocks chained together.
2037 We handle them all in sequence. */
2040 dbxout_block (block
, depth
, args
)
2041 register tree block
;
2049 /* Ignore blocks never expanded or otherwise marked as real. */
2050 if (TREE_USED (block
))
2052 #ifndef DBX_LBRAC_FIRST
2053 /* In dbx format, the syms of a block come before the N_LBRAC. */
2054 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2055 dbxout_syms (BLOCK_VARS (block
));
2057 dbxout_reg_parms (args
);
2060 /* Now output an N_LBRAC symbol to represent the beginning of
2061 the block. Use the block's tree-walk order to generate
2062 the assembler symbols LBBn and LBEn
2063 that final will define around the code in this block. */
2064 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2067 blocknum
= next_block_number
++;
2068 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
2070 if (BLOCK_HANDLER_BLOCK (block
))
2072 /* A catch block. Must precede N_LBRAC. */
2073 tree decl
= BLOCK_VARS (block
);
2076 #ifdef DBX_OUTPUT_CATCH
2077 DBX_OUTPUT_CATCH (asmfile
, decl
, buf
);
2079 fprintf (asmfile
, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP
,
2080 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
2081 assemble_name (asmfile
, buf
);
2082 fprintf (asmfile
, "\n");
2084 decl
= TREE_CHAIN (decl
);
2088 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_LBRAC
);
2089 assemble_name (asmfile
, buf
);
2090 fprintf (asmfile
, "\n");
2093 /* Count blocks the same way regardless of debug_info_level. */
2094 next_block_number
++;
2096 #ifdef DBX_LBRAC_FIRST
2097 /* On some weird machines, the syms of a block
2098 come after the N_LBRAC. */
2099 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2100 dbxout_syms (BLOCK_VARS (block
));
2102 dbxout_reg_parms (args
);
2105 /* Output the subblocks. */
2106 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, 0);
2108 /* Refer to the marker for the end of the block. */
2109 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2112 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
2113 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_RBRAC
);
2114 assemble_name (asmfile
, buf
);
2115 fprintf (asmfile
, "\n");
2118 block
= BLOCK_CHAIN (block
);
2122 /* Output the information about a function and its arguments and result.
2123 Usually this follows the function's code,
2124 but on some systems, it comes before. */
2127 dbxout_really_begin_function (decl
)
2130 dbxout_symbol (decl
, 0);
2131 dbxout_parms (DECL_ARGUMENTS (decl
));
2132 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
2133 dbxout_symbol (DECL_RESULT (decl
), 1);
2136 /* Called at beginning of output of function definition. */
2139 dbxout_begin_function (decl
)
2142 #ifdef DBX_FUNCTION_FIRST
2143 dbxout_really_begin_function (decl
);
2147 /* Output dbx data for a function definition.
2148 This includes a definition of the function name itself (a symbol),
2149 definitions of the parameters (locating them in the parameter list)
2150 and then output the block that makes up the function's body
2151 (including all the auto variables of the function). */
2154 dbxout_function (decl
)
2157 #ifndef DBX_FUNCTION_FIRST
2158 dbxout_really_begin_function (decl
);
2160 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
2161 #ifdef DBX_OUTPUT_FUNCTION_END
2162 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
2165 #endif /* DBX_DEBUGGING_INFO */