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 /* 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, 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 /* Subtroutine 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
)])
864 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
865 leave the type-number completely undefined rather than output
866 a cross-reference. */
867 if (TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
868 || TREE_CODE (type
) == ENUMERAL_TYPE
)
870 if ((TYPE_NAME (type
) != 0 && !full
)
871 || TYPE_SIZE (type
) == 0)
873 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_XREF
;
878 /* Output a definition now. */
880 fprintf (asmfile
, "=");
883 /* Mark it as defined, so that if it is self-referent
884 we will not get into an infinite recursion of definitions. */
886 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_DEFINED
;
888 switch (TREE_CODE (type
))
892 /* For a void type, just define it as itself; ie, "5=5".
893 This makes us consider it defined
894 without saying what it is. The debugger will make it
895 a void type when the reference is seen, and nothing will
896 ever override that default. */
897 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
902 if (type
== char_type_node
&& ! TREE_UNSIGNED (type
))
903 /* Output the type `char' as a subrange of itself!
904 I don't understand this definition, just copied it
905 from the output of pcc.
906 This used to use `r2' explicitly and we used to
907 take care to make sure that `char' was type number 2. */
908 fprintf (asmfile
, "r%d;0;127;", TYPE_SYMTAB_ADDRESS (type
));
910 else if (TYPE_PRECISION (type
) > BITS_PER_WORD
)
912 /* This used to say `r1' and we used to take care
913 to make sure that `int' was type number 1. */
914 fprintf (asmfile
, "r%d;", TYPE_SYMTAB_ADDRESS (integer_type_node
));
915 print_int_cst_octal (TYPE_MIN_VALUE (type
));
916 fprintf (asmfile
, ";");
917 print_int_cst_octal (TYPE_MAX_VALUE (type
));
918 fprintf (asmfile
, ";");
922 /* Output other integer types as subranges of `int'. */
923 /* This used to say `r1' and we used to take care
924 to make sure that `int' was type number 1. */
925 fprintf (asmfile
, "r%d;%d;%d;",
926 TYPE_SYMTAB_ADDRESS (integer_type_node
),
927 TREE_INT_CST_LOW (TYPE_MIN_VALUE (type
)),
928 TREE_INT_CST_LOW (TYPE_MAX_VALUE (type
)));
933 /* This used to say `r1' and we used to take care
934 to make sure that `int' was type number 1. */
935 fprintf (asmfile
, "r%d;%d;0;", TYPE_SYMTAB_ADDRESS (integer_type_node
),
936 TREE_INT_CST_LOW (size_in_bytes (type
)));
941 /* Output "a" followed by a range type definition
942 for the index type of the array
943 followed by a reference to the target-type.
944 ar1;0;N;M for an array of type M and size N. */
945 /* This used to say `r1' and we used to take care
946 to make sure that `int' was type number 1. */
947 fprintf (asmfile
, "ar%d;0;%d;", TYPE_SYMTAB_ADDRESS (integer_type_node
),
950 ? TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)))
953 dbxout_type (TREE_TYPE (type
), 0, 0);
959 int i
, n_baseclasses
= 0;
961 if (TYPE_BINFO (type
) != 0 && TYPE_BINFO_BASETYPES (type
) != 0)
962 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
964 /* Output a structure type. */
965 if ((TYPE_NAME (type
) != 0
966 #if 0 /* Tiemann says this creates output tha "confuses GDB".
967 Too bad the info is so vague. Hope this doesn't lose. */
968 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
969 && DECL_IGNORED_P (TYPE_NAME (type
)))
972 || TYPE_SIZE (type
) == 0
973 /* No way in DBX fmt to describe a variable size. */
974 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
976 /* If the type is just a cross reference, output one
977 and mark the type as partially described.
978 If it later becomes defined, we will output
980 If the type has a name, don't nest its definition within
981 another type's definition; instead, output an xref
982 and let the definition come when the name is defined. */
983 fprintf (asmfile
, (TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu");
985 #if 0 /* This assertion is legitimately false in C++. */
986 /* We shouldn't be outputting a reference to a type before its
987 definition unless the type has a tag name.
988 A typedef name without a tag name should be impossible. */
989 if (TREE_CODE (TYPE_NAME (type
)) != IDENTIFIER_NODE
)
992 dbxout_type_name (type
);
993 fprintf (asmfile
, ":");
994 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_XREF
;
997 tem
= size_in_bytes (type
);
999 /* Identify record or union, and print its size. */
1000 fprintf (asmfile
, (TREE_CODE (type
) == RECORD_TYPE
) ? "s%d" : "u%d",
1001 TREE_INT_CST_LOW (tem
));
1003 if (use_gdb_dbx_extensions
)
1007 have_used_extensions
= 1;
1008 fprintf (asmfile
, "!%d,", n_baseclasses
);
1012 for (i
= 0; i
< n_baseclasses
; i
++)
1014 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)), i
);
1015 if (use_gdb_dbx_extensions
)
1017 have_used_extensions
= 1;
1018 putc (TREE_VIA_VIRTUAL (child
) ? '1'
1021 putc (TREE_VIA_PUBLIC (child
) ? '2'
1024 fprintf (asmfile
, "%d,",
1025 TREE_INT_CST_LOW (BINFO_OFFSET (child
)) * BITS_PER_UNIT
);
1027 dbxout_type (BINFO_TYPE (child
), 0, 0);
1028 putc (';', asmfile
);
1032 /* Print out the base class information with fields
1033 which have the same names at the types they hold. */
1034 dbxout_type_name (BINFO_TYPE (child
));
1035 putc (':', asmfile
);
1036 dbxout_type (BINFO_TYPE (child
), full
, 0);
1037 fprintf (asmfile
, ",%d,%d;",
1038 TREE_INT_CST_LOW (BINFO_OFFSET (child
)) * BITS_PER_UNIT
,
1039 TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child
)))) * BITS_PER_UNIT
);
1047 /* Write out the field declarations. */
1048 dbxout_type_fields (type
);
1049 if (use_gdb_dbx_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1051 have_used_extensions
= 1;
1052 dbxout_type_methods (type
);
1054 putc (';', asmfile
);
1056 if (use_gdb_dbx_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1057 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1058 && TYPE_VFIELD (type
))
1060 have_used_extensions
= 1;
1062 /* Tell GDB+ that it may keep reading. */
1063 putc ('~', asmfile
);
1065 /* We need to write out info about what field this class
1066 uses as its "main" vtable pointer field, because if this
1067 field is inherited from a base class, GDB cannot necessarily
1068 figure out which field it's using in time. */
1069 if (TYPE_VFIELD (type
))
1071 putc ('%', asmfile
);
1072 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0, 0);
1074 putc (';', asmfile
);
1080 if ((TYPE_NAME (type
) != 0 && !full
1081 && (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1082 && ! DECL_IGNORED_P (TYPE_NAME (type
))))
1083 || TYPE_SIZE (type
) == 0)
1085 fprintf (asmfile
, "xe");
1087 dbxout_type_name (type
);
1088 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_XREF
;
1089 fprintf (asmfile
, ":");
1092 putc ('e', asmfile
);
1094 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1096 fprintf (asmfile
, "%s:%d,", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)),
1097 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1098 CHARS (11 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)));
1099 if (TREE_CHAIN (tem
) != 0)
1102 putc (';', asmfile
);
1107 putc ('*', asmfile
);
1109 dbxout_type (TREE_TYPE (type
), 0, 0);
1113 if (use_gdb_dbx_extensions
)
1115 have_used_extensions
= 1;
1116 putc ('#', asmfile
);
1118 if (flag_minimal_debug
&& !show_arg_types
)
1120 /* Normally, just output the return type.
1121 The argument types are encoded in the method name. */
1122 putc ('#', asmfile
);
1123 dbxout_type (TREE_TYPE (type
), 0, 0);
1124 putc (';', asmfile
);
1129 /* When outputing destructors, we need to write
1130 the argument types out longhand. */
1131 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0, 0);
1132 putc (',', asmfile
);
1134 dbxout_type (TREE_TYPE (type
), 0, 0);
1135 dbxout_args (TYPE_ARG_TYPES (type
));
1136 putc (';', asmfile
);
1142 /* Treat it as a function type. */
1143 dbxout_type (TREE_TYPE (type
), 0, 0);
1148 if (use_gdb_dbx_extensions
)
1150 have_used_extensions
= 1;
1151 putc ('@', asmfile
);
1153 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0, 0);
1154 putc (',', asmfile
);
1156 dbxout_type (TREE_TYPE (type
), 0, 0);
1160 /* Should print as an int, because it is really
1162 dbxout_type (integer_type_node
, 0, 0);
1166 case REFERENCE_TYPE
:
1167 if (use_gdb_dbx_extensions
)
1168 have_used_extensions
= 1;
1169 putc (use_gdb_dbx_extensions
? '&' : '*', asmfile
);
1171 dbxout_type (TREE_TYPE (type
), 0, 0);
1175 putc ('f', asmfile
);
1177 dbxout_type (TREE_TYPE (type
), 0, 0);
1185 /* Print the value of integer constant C, in octal,
1186 handling double precision. */
1189 print_int_cst_octal (c
)
1192 unsigned int high
= TREE_INT_CST_HIGH (c
);
1193 unsigned int low
= TREE_INT_CST_LOW (c
);
1194 int excess
= (3 - (HOST_BITS_PER_INT
% 3));
1196 fprintf (asmfile
, "0");
1200 print_octal (high
, HOST_BITS_PER_INT
/ 3);
1201 print_octal (low
, HOST_BITS_PER_INT
/ 3);
1205 unsigned int beg
= high
>> excess
;
1207 = ((high
& ((1 << excess
) - 1)) << (3 - excess
)
1208 | (low
>> (HOST_BITS_PER_INT
/ 3 * 3)));
1209 unsigned int end
= low
& ((1 << (HOST_BITS_PER_INT
/ 3 * 3)) - 1);
1210 fprintf (asmfile
, "%o%01o", beg
, middle
);
1211 print_octal (end
, HOST_BITS_PER_INT
/ 3);
1216 print_octal (value
, digits
)
1222 for (i
= digits
- 1; i
>= 0; i
--)
1223 fprintf (asmfile
, "%01o", ((value
>> (3 * i
)) & 7));
1226 /* Output the name of type TYPE, with no punctuation.
1227 Such names can be set up either by typedef declarations
1228 or by struct, enum and union tags. */
1231 dbxout_type_name (type
)
1235 if (TYPE_NAME (type
) == 0)
1237 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
1239 t
= TYPE_NAME (type
);
1241 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1243 t
= DECL_NAME (TYPE_NAME (type
));
1248 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
1249 CHARS (IDENTIFIER_LENGTH (t
));
1252 /* Output a .stabs for the symbol defined by DECL,
1253 which must be a ..._DECL node in the normal namespace.
1254 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1255 LOCAL is nonzero if the scope is less than the entire file. */
1258 dbxout_symbol (decl
, local
)
1263 tree type
= TREE_TYPE (decl
);
1264 tree context
= NULL_TREE
;
1267 /* Cast avoids warning in old compilers. */
1268 current_sym_code
= (STAB_CODE_TYPE
) 0;
1269 current_sym_value
= 0;
1270 current_sym_addr
= 0;
1272 /* Ignore nameless syms, but don't ignore type tags. */
1274 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
1275 || DECL_IGNORED_P (decl
))
1278 dbxout_prepare_symbol (decl
);
1280 /* The output will always start with the symbol name,
1281 so always count that in the length-output-so-far. */
1283 if (DECL_NAME (decl
) != 0)
1284 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
1286 switch (TREE_CODE (decl
))
1289 /* Enum values are defined by defining the enum type. */
1293 if (DECL_RTL (decl
) == 0)
1295 if (TREE_EXTERNAL (decl
))
1297 /* Don't mention a nested function under its parent. */
1298 context
= decl_function_context (decl
);
1299 if (context
== current_function_decl
)
1301 if (GET_CODE (DECL_RTL (decl
)) != MEM
1302 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
1306 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
1307 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1308 TREE_PUBLIC (decl
) ? 'F' : 'f');
1310 current_sym_code
= N_FUN
;
1311 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1313 if (TREE_TYPE (type
))
1314 dbxout_type (TREE_TYPE (type
), 0, 0);
1316 dbxout_type (void_type_node
, 0, 0);
1318 /* For a nested function, when that function is compiled,
1319 mention the containing function name
1320 as well as (since dbx wants it) our own assembler-name. */
1322 fprintf (asmfile
, ",%s,%s",
1323 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1324 IDENTIFIER_POINTER (DECL_NAME (context
)));
1326 dbxout_finish_symbol (decl
);
1331 /* This seems all wrong. Outputting most kinds of types gives no name
1332 at all. A true definition gives no name; a cross-ref for a
1333 structure can give the tag name, but not a type name.
1334 It seems that no typedef name is defined by outputting a type. */
1336 /* If this typedef name was defined by outputting the type,
1337 don't duplicate it. */
1338 if (typevec
[TYPE_SYMTAB_ADDRESS (type
)] == TYPE_DEFINED
1339 && TYPE_NAME (TREE_TYPE (decl
)) == decl
)
1342 /* Don't output the same typedef twice.
1343 And don't output what language-specific stuff doesn't want output. */
1344 if (TREE_ASM_WRITTEN (decl
) || DECL_IGNORED_P (decl
))
1352 if (DECL_NAME (decl
))
1354 /* Nonzero means we must output a tag as well as a typedef. */
1357 /* Output typedef name. */
1358 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
,
1359 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1361 /* Short cut way to output a tag also. */
1362 if ((TREE_CODE (type
) == RECORD_TYPE
1363 || TREE_CODE (type
) == UNION_TYPE
)
1364 && TYPE_NAME (type
) == decl
)
1366 if (use_gdb_dbx_extensions
&& have_used_extensions
)
1368 putc ('T', asmfile
);
1369 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
1375 putc ('t', asmfile
);
1376 current_sym_code
= DBX_DECL_STABS_CODE
;
1378 dbxout_type (type
, 1, 0);
1379 dbxout_finish_symbol (decl
);
1382 if (tag_needed
&& TYPE_NAME (type
) != 0
1383 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1385 /* For a TYPE_DECL with no name, but the type has a name,
1387 This is what represents `struct foo' with no typedef. */
1388 /* In C++, the name of a type is the corresponding typedef.
1389 In C, it is an IDENTIFIER_NODE. */
1390 tree name
= TYPE_NAME (type
);
1391 if (TREE_CODE (name
) == TYPE_DECL
)
1392 name
= DECL_NAME (name
);
1394 current_sym_code
= DBX_DECL_STABS_CODE
;
1395 current_sym_value
= 0;
1396 current_sym_addr
= 0;
1397 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1399 fprintf (asmfile
, "%s \"%s:T", ASM_STABS_OP
,
1400 IDENTIFIER_POINTER (name
));
1401 dbxout_type (type
, 1, 0);
1402 dbxout_finish_symbol (0);
1405 /* Prevent duplicate output of a typedef. */
1406 TREE_ASM_WRITTEN (decl
) = 1;
1411 /* Parm decls go in their own separate chains
1412 and are output by dbxout_reg_parms and dbxout_parms. */
1416 /* Named return value, treat like a VAR_DECL. */
1418 if (DECL_RTL (decl
) == 0)
1420 /* Don't mention a variable that is external.
1421 Let the file that defines it describe it. */
1422 if (TREE_EXTERNAL (decl
))
1425 /* If the variable is really a constant
1426 and not written in memory, inform the debugger. */
1427 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
1428 && DECL_INITIAL (decl
) != 0
1429 && ! TREE_ASM_WRITTEN (decl
)
1430 && (DECL_FIELD_CONTEXT (decl
) == NULL_TREE
1431 || TREE_CODE (DECL_FIELD_CONTEXT (decl
)) == BLOCK
))
1433 if (TREE_PUBLIC (decl
) == 0)
1435 /* The sun4 assembler does not grok this. */
1436 char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1437 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
1438 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
1440 int ival
= TREE_INT_CST_LOW (DECL_INITIAL (decl
));
1441 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1442 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile
, name
, ival
);
1444 fprintf (asmfile
, "%s \"%s:c=i%d\",0x%x,0,0,0\n",
1445 ASM_STABS_OP
, name
, ival
, N_LSYM
);
1449 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
1451 /* don't know how to do this yet. */
1455 /* else it is something we handle like a normal variable. */
1458 DECL_RTL (decl
) = eliminate_regs (DECL_RTL (decl
));
1459 #ifdef LEAF_REG_REMAP
1461 leaf_renumber_regs_insn (DECL_RTL (decl
));
1464 /* Don't mention a variable at all
1465 if it was completely optimized into nothingness.
1467 If DECL was from an inline function, then it's rtl
1468 is not identically the rtl that was used in this
1469 particular compilation. */
1470 if (GET_CODE (DECL_RTL (decl
)) == REG
)
1472 regno
= REGNO (DECL_RTL (decl
));
1473 if (regno
>= FIRST_PSEUDO_REGISTER
)
1474 regno
= reg_renumber
[REGNO (DECL_RTL (decl
))];
1478 else if (GET_CODE (DECL_RTL (decl
)) == SUBREG
)
1480 rtx value
= DECL_RTL (decl
);
1482 while (GET_CODE (value
) == SUBREG
)
1484 offset
+= SUBREG_WORD (value
);
1485 value
= SUBREG_REG (value
);
1487 if (GET_CODE (value
) == REG
)
1489 regno
= REGNO (value
);
1490 if (regno
>= FIRST_PSEUDO_REGISTER
)
1491 regno
= reg_renumber
[REGNO (value
)];
1497 /* The kind-of-variable letter depends on where
1498 the variable is and on the scope of its name:
1499 G and N_GSYM for static storage and global scope,
1500 S for static storage and file scope,
1501 V for static storage and local scope,
1502 for those two, use N_LCSYM if data is in bss segment,
1503 N_STSYM if in data segment, N_FUN otherwise.
1504 (We used N_FUN originally, then changed to N_STSYM
1505 to please GDB. However, it seems that confused ld.
1506 Now GDB has been fixed to like N_FUN, says Kingdon.)
1507 no letter at all, and N_LSYM, for auto variable,
1508 r and N_RSYM for register variable. */
1510 if (GET_CODE (DECL_RTL (decl
)) == MEM
1511 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == SYMBOL_REF
)
1513 if (TREE_PUBLIC (decl
))
1516 current_sym_code
= N_GSYM
;
1520 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1522 letter
= decl_function_context (decl
) ? 'V' : 'S';
1524 if (!DECL_INITIAL (decl
))
1525 current_sym_code
= N_LCSYM
;
1526 else if (TREE_READONLY (decl
) && ! TREE_THIS_VOLATILE (decl
))
1527 /* This is not quite right, but it's the closest
1528 of all the codes that Unix defines. */
1529 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
1532 /* Ultrix `as' seems to need this. */
1533 #ifdef DBX_STATIC_STAB_DATA_SECTION
1536 current_sym_code
= N_STSYM
;
1540 else if (regno
>= 0)
1543 current_sym_code
= N_RSYM
;
1544 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
1546 else if (GET_CODE (DECL_RTL (decl
)) == SUBREG
)
1548 rtx value
= DECL_RTL (decl
);
1550 while (GET_CODE (value
) == SUBREG
)
1552 offset
+= SUBREG_WORD (value
);
1553 value
= SUBREG_REG (value
);
1556 current_sym_code
= N_RSYM
;
1557 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (value
) + offset
);
1559 else if (GET_CODE (DECL_RTL (decl
)) == MEM
1560 && (GET_CODE (XEXP (DECL_RTL (decl
), 0)) == MEM
1561 || (GET_CODE (XEXP (DECL_RTL (decl
), 0)) == REG
1562 && REGNO (XEXP (DECL_RTL (decl
), 0)) != FRAME_POINTER_REGNUM
)))
1563 /* If the value is indirect by memory or by a register
1564 that isn't the frame pointer
1565 then it means the object is variable-sized and address through
1566 that register or stack slot. DBX has no way to represent this
1567 so all we can do is output the variable as a pointer.
1568 If it's not a parameter, ignore it.
1569 (VAR_DECLs like this can be made by integrate.c.) */
1571 if (GET_CODE (XEXP (DECL_RTL (decl
), 0)) == REG
)
1574 current_sym_code
= N_RSYM
;
1575 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (DECL_RTL (decl
), 0)));
1579 current_sym_code
= N_LSYM
;
1580 /* DECL_RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
1581 We want the value of that CONST_INT. */
1583 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (DECL_RTL (decl
), 0), 0));
1586 /* Effectively do build_pointer_type, but don't cache this type,
1587 since it might be temporary whereas the type it points to
1588 might have been saved for inlining. */
1589 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
1590 type
= make_node (POINTER_TYPE
);
1591 TREE_TYPE (type
) = TREE_TYPE (decl
);
1593 else if (GET_CODE (DECL_RTL (decl
)) == MEM
1594 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == REG
)
1596 current_sym_code
= N_LSYM
;
1597 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (DECL_RTL (decl
), 0));
1599 else if (GET_CODE (DECL_RTL (decl
)) == MEM
1600 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == PLUS
1601 && GET_CODE (XEXP (XEXP (DECL_RTL (decl
), 0), 1)) == CONST_INT
)
1603 current_sym_code
= N_LSYM
;
1604 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
1605 We want the value of that CONST_INT. */
1606 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (DECL_RTL (decl
), 0));
1608 else if (GET_CODE (DECL_RTL (decl
)) == MEM
1609 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == CONST
)
1611 /* Handle an obscure case which can arise when optimizing and
1612 when there are few available registers. (This is *always*
1613 the case for i386/i486 targets). The DECL_RTL looks like
1614 (MEM (CONST ...)) even though this variable is a local `auto'
1615 or a local `register' variable. In effect, what has happened
1616 is that the reload pass has seen that all assignments and
1617 references for one such a local variable can be replaced by
1618 equivalent assignments and references to some static storage
1619 variable, thereby avoiding the need for a register. In such
1620 cases we're forced to lie to debuggers and tell them that
1621 this variable was itself `static'. */
1622 current_sym_code
= N_LCSYM
;
1624 current_sym_addr
= XEXP (XEXP (DECL_RTL (decl
), 0), 0);
1627 /* Address might be a MEM, when DECL is a variable-sized object.
1628 Or it might be const0_rtx, meaning previous passes
1629 want us to ignore this variable. */
1632 /* Ok, start a symtab entry and output the variable name. */
1635 #ifdef DBX_STATIC_BLOCK_START
1636 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
1639 /* One slight hitch: if this is a VAR_DECL which is a static
1640 class member, we must put out the mangled name instead of the
1644 /* Note also that static member (variable) names DO NOT begin
1645 with underscores in .stabs directives. */
1646 if (DECL_LANG_SPECIFIC (decl
))
1647 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
1649 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1650 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
, name
);
1652 if (letter
) putc (letter
, asmfile
);
1653 dbxout_type (type
, 0, 0);
1654 dbxout_finish_symbol (decl
);
1656 #ifdef DBX_STATIC_BLOCK_END
1657 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
1664 dbxout_prepare_symbol (decl
)
1668 char *filename
= DECL_SOURCE_FILE (decl
);
1670 dbxout_source_file (asmfile
, filename
);
1675 dbxout_finish_symbol (sym
)
1678 #ifdef DBX_FINISH_SYMBOL
1679 DBX_FINISH_SYMBOL (sym
);
1684 line
= DECL_SOURCE_LINE (sym
);
1687 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
1688 if (current_sym_addr
)
1689 output_addr_const (asmfile
, current_sym_addr
);
1691 fprintf (asmfile
, "%d", current_sym_value
);
1692 putc ('\n', asmfile
);
1696 /* Output definitions of all the decls in a chain. */
1704 dbxout_symbol (syms
, 1);
1705 syms
= TREE_CHAIN (syms
);
1709 /* The following two functions output definitions of function parameters.
1710 Each parameter gets a definition locating it in the parameter list.
1711 Each parameter that is a register variable gets a second definition
1712 locating it in the register.
1714 Printing or argument lists in gdb uses the definitions that
1715 locate in the parameter list. But reference to the variable in
1716 expressions uses preferentially the definition as a register. */
1718 /* Output definitions, referring to storage in the parmlist,
1719 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
1722 dbxout_parms (parms
)
1725 for (; parms
; parms
= TREE_CHAIN (parms
))
1726 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
1728 dbxout_prepare_symbol (parms
);
1730 /* Perform any necessary register eliminations on the parameter's rtl,
1731 so that the debugging output will be accurate. */
1732 DECL_INCOMING_RTL (parms
)
1733 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, 0);
1734 DECL_RTL (parms
) = eliminate_regs (DECL_RTL (parms
), 0, 0);
1735 #ifdef LEAF_REG_REMAP
1738 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
1739 leaf_renumber_regs_insn (DECL_RTL (parms
));
1743 if (PARM_PASSED_IN_MEMORY (parms
))
1745 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
1747 /* ??? Here we assume that the parm address is indexed
1748 off the frame pointer or arg pointer.
1749 If that is not true, we produce meaningless results,
1750 but do not crash. */
1751 if (GET_CODE (addr
) == PLUS
1752 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
1753 current_sym_value
= INTVAL (XEXP (addr
, 1));
1755 current_sym_value
= 0;
1757 current_sym_code
= N_PSYM
;
1758 current_sym_addr
= 0;
1761 if (DECL_NAME (parms
))
1763 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
1765 fprintf (asmfile
, "%s \"%s:p", ASM_STABS_OP
,
1766 IDENTIFIER_POINTER (DECL_NAME (parms
)));
1770 current_sym_nchars
= 8;
1771 fprintf (asmfile
, "%s \"(anon):p", ASM_STABS_OP
);
1774 if (GET_CODE (DECL_RTL (parms
)) == REG
1775 && REGNO (DECL_RTL (parms
)) >= 0
1776 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
1777 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
1780 int original_value
= current_sym_value
;
1782 /* This is the case where the parm is passed as an int or double
1783 and it is converted to a char, short or float and stored back
1784 in the parmlist. In this case, describe the parm
1785 with the variable's declared type, and adjust the address
1786 if the least significant bytes (which we are using) are not
1788 #if BYTES_BIG_ENDIAN
1789 if (TREE_TYPE (parms
) != DECL_ARG_TYPE (parms
))
1790 current_sym_value
+= (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms
)))
1791 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
))));
1794 if (GET_CODE (DECL_RTL (parms
)) == MEM
1795 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == PLUS
1796 && GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == CONST_INT
1797 && INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == current_sym_value
)
1798 dbxout_type (TREE_TYPE (parms
), 0, 0);
1801 current_sym_value
= original_value
;
1802 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
1805 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
1806 dbxout_finish_symbol (parms
);
1808 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
1811 char regparm_letter
;
1812 /* Parm passed in registers and lives in registers or nowhere. */
1814 current_sym_code
= DBX_REGPARM_STABS_CODE
;
1815 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
1816 current_sym_addr
= 0;
1818 /* If parm lives in a register, use that register;
1819 pretend the parm was passed there. It would be more consistent
1820 to describe the register where the parm was passed,
1821 but in practice that register usually holds something else. */
1822 if (REGNO (DECL_RTL (parms
)) >= 0
1823 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
1824 best_rtl
= DECL_RTL (parms
);
1825 /* If the parm lives nowhere,
1826 use the register where it was passed. */
1828 best_rtl
= DECL_INCOMING_RTL (parms
);
1829 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
1832 if (DECL_NAME (parms
))
1834 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
1835 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
1836 IDENTIFIER_POINTER (DECL_NAME (parms
)),
1841 current_sym_nchars
= 8;
1842 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
1846 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
1847 dbxout_finish_symbol (parms
);
1849 else if (GET_CODE (DECL_RTL (parms
)) == MEM
1850 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
)
1852 /* Parm was passed in registers but lives on the stack. */
1854 current_sym_code
= N_PSYM
;
1855 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
1856 in which case we want the value of that CONST_INT,
1857 or (MEM (REG ...)) or (MEM (MEM ...)),
1858 in which case we use a value of zero. */
1859 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
1860 || GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
1861 current_sym_value
= 0;
1863 current_sym_value
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
1864 current_sym_addr
= 0;
1867 if (DECL_NAME (parms
))
1869 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
1871 fprintf (asmfile
, "%s \"%s:p", ASM_STABS_OP
,
1872 IDENTIFIER_POINTER (DECL_NAME (parms
)));
1876 current_sym_nchars
= 8;
1877 fprintf (asmfile
, "%s \"(anon):p", ASM_STABS_OP
);
1881 = DEBUGGER_ARG_OFFSET (current_sym_value
,
1882 XEXP (DECL_RTL (parms
), 0));
1883 dbxout_type (TREE_TYPE (parms
), 0, 0);
1884 dbxout_finish_symbol (parms
);
1889 /* Output definitions for the places where parms live during the function,
1890 when different from where they were passed, when the parms were passed
1893 It is not useful to do this for parms passed in registers
1894 that live during the function in different registers, because it is
1895 impossible to look in the passed register for the passed value,
1896 so we use the within-the-function register to begin with.
1898 PARMS is a chain of PARM_DECL nodes. */
1901 dbxout_reg_parms (parms
)
1904 for (; parms
; parms
= TREE_CHAIN (parms
))
1905 if (DECL_NAME (parms
))
1907 dbxout_prepare_symbol (parms
);
1909 /* Report parms that live in registers during the function
1910 but were passed in memory. */
1911 if (GET_CODE (DECL_RTL (parms
)) == REG
1912 && REGNO (DECL_RTL (parms
)) >= 0
1913 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
1914 && PARM_PASSED_IN_MEMORY (parms
))
1916 current_sym_code
= N_RSYM
;
1917 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms
)));
1918 current_sym_addr
= 0;
1921 if (DECL_NAME (parms
))
1923 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
1924 fprintf (asmfile
, "%s \"%s:r", ASM_STABS_OP
,
1925 IDENTIFIER_POINTER (DECL_NAME (parms
)));
1929 current_sym_nchars
= 8;
1930 fprintf (asmfile
, "%s \"(anon):r", ASM_STABS_OP
);
1932 dbxout_type (TREE_TYPE (parms
), 0, 0);
1933 dbxout_finish_symbol (parms
);
1935 /* Report parms that live in memory but not where they were passed. */
1936 else if (GET_CODE (DECL_RTL (parms
)) == MEM
1937 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == PLUS
1938 && GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == CONST_INT
1939 && PARM_PASSED_IN_MEMORY (parms
)
1940 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
1942 #if 0 /* ??? It is not clear yet what should replace this. */
1943 int offset
= DECL_OFFSET (parms
) / BITS_PER_UNIT
;
1944 /* A parm declared char is really passed as an int,
1945 so it occupies the least significant bytes.
1946 On a big-endian machine those are not the low-numbered ones. */
1947 #if BYTES_BIG_ENDIAN
1948 if (offset
!= -1 && TREE_TYPE (parms
) != DECL_ARG_TYPE (parms
))
1949 offset
+= (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms
)))
1950 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
))));
1952 if (INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) != offset
) {...}
1954 current_sym_code
= N_LSYM
;
1955 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (DECL_RTL (parms
), 0));
1956 current_sym_addr
= 0;
1958 if (DECL_NAME (parms
))
1960 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
1961 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
,
1962 IDENTIFIER_POINTER (DECL_NAME (parms
)));
1966 current_sym_nchars
= 8;
1967 fprintf (asmfile
, "%s \"(anon):", ASM_STABS_OP
);
1969 dbxout_type (TREE_TYPE (parms
), 0, 0);
1970 dbxout_finish_symbol (parms
);
1975 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
1976 output definitions of those names, in raw form */
1984 putc (',', asmfile
);
1985 dbxout_type (TREE_VALUE (args
), 0, 0);
1987 args
= TREE_CHAIN (args
);
1991 /* Given a chain of ..._TYPE nodes,
1992 find those which have typedef names and output those names.
1993 This is to ensure those types get output. */
1996 dbxout_types (types
)
1997 register tree types
;
2001 if (TYPE_NAME (types
)
2002 && TREE_CODE (TYPE_NAME (types
)) == TYPE_DECL
2003 && ! TREE_ASM_WRITTEN (TYPE_NAME (types
)))
2004 dbxout_symbol (TYPE_NAME (types
), 1);
2005 types
= TREE_CHAIN (types
);
2009 /* Output everything about a symbol block (a BLOCK node
2010 that represents a scope level),
2011 including recursive output of contained blocks.
2013 BLOCK is the BLOCK node.
2014 DEPTH is its depth within containing symbol blocks.
2015 ARGS is usually zero; but for the outermost block of the
2016 body of a function, it is a chain of PARM_DECLs for the function parameters.
2017 We output definitions of all the register parms
2018 as if they were local variables of that block.
2020 If -g1 was used, we count blocks just the same, but output nothing
2021 except for the outermost block.
2023 Actually, BLOCK may be several blocks chained together.
2024 We handle them all in sequence. */
2027 dbxout_block (block
, depth
, args
)
2028 register tree block
;
2036 /* Ignore blocks never expanded or otherwise marked as real. */
2037 if (TREE_USED (block
))
2039 #ifndef DBX_LBRAC_FIRST
2040 /* In dbx format, the syms of a block come before the N_LBRAC. */
2041 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2042 dbxout_syms (BLOCK_VARS (block
));
2044 dbxout_reg_parms (args
);
2047 /* Now output an N_LBRAC symbol to represent the beginning of
2048 the block. Use the block's tree-walk order to generate
2049 the assembler symbols LBBn and LBEn
2050 that final will define around the code in this block. */
2051 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2054 blocknum
= next_block_number
++;
2055 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
2057 if (BLOCK_HANDLER_BLOCK (block
))
2059 /* A catch block. Must precede N_LBRAC. */
2060 tree decl
= BLOCK_VARS (block
);
2063 #ifdef DBX_OUTPUT_CATCH
2064 DBX_OUTPUT_CATCH (asmfile
, decl
, buf
);
2066 fprintf (asmfile
, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP
,
2067 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
2068 assemble_name (asmfile
, buf
);
2069 fprintf (asmfile
, "\n");
2071 decl
= TREE_CHAIN (decl
);
2075 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_LBRAC
);
2076 assemble_name (asmfile
, buf
);
2077 fprintf (asmfile
, "\n");
2080 /* Count blocks the same way regardless of debug_info_level. */
2081 next_block_number
++;
2083 #ifdef DBX_LBRAC_FIRST
2084 /* On some weird machines, the syms of a block
2085 come after the N_LBRAC. */
2086 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2087 dbxout_syms (BLOCK_VARS (block
));
2089 dbxout_reg_parms (args
);
2092 /* Output the subblocks. */
2093 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, 0);
2095 /* Refer to the marker for the end of the block. */
2096 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2099 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
2100 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_RBRAC
);
2101 assemble_name (asmfile
, buf
);
2102 fprintf (asmfile
, "\n");
2105 block
= BLOCK_CHAIN (block
);
2109 /* Output the information about a function and its arguments and result.
2110 Usually this follows the function's code,
2111 but on some systems, it comes before. */
2114 dbxout_really_begin_function (decl
)
2117 dbxout_symbol (decl
, 0);
2118 dbxout_parms (DECL_ARGUMENTS (decl
));
2119 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
2120 dbxout_symbol (DECL_RESULT (decl
), 1);
2123 /* Called at beginning of output of function definition. */
2126 dbxout_begin_function (decl
)
2129 #ifdef DBX_FUNCTION_FIRST
2130 dbxout_really_begin_function (decl
);
2134 /* Output dbx data for a function definition.
2135 This includes a definition of the function name itself (a symbol),
2136 definitions of the parameters (locating them in the parameter list)
2137 and then output the block that makes up the function's body
2138 (including all the auto variables of the function). */
2141 dbxout_function (decl
)
2144 #ifndef DBX_FUNCTION_FIRST
2145 dbxout_really_begin_function (decl
);
2147 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
2148 #ifdef DBX_OUTPUT_FUNCTION_END
2149 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
2152 #endif /* DBX_DEBUGGING_INFO */