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
))
1349 if (DECL_NAME (decl
))
1351 /* Output typedef name. */
1352 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
,
1353 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1355 /* If there is a typedecl for this type with the same name
1356 as the tag, output an abbreviated form for that typedecl. */
1357 if (use_gdb_dbx_extensions
&& have_used_extensions
1358 && (TREE_CODE (type
) == RECORD_TYPE
1359 || TREE_CODE (type
) == UNION_TYPE
)
1360 && (TYPE_NAME (type
) == decl
))
1362 putc ('T', asmfile
);
1363 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
1365 putc ('t', asmfile
);
1366 current_sym_code
= DBX_DECL_STABS_CODE
;
1368 dbxout_type (type
, 1, 0);
1369 dbxout_finish_symbol (decl
);
1371 else if (TYPE_NAME (type
) != 0 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1373 /* Output a tag (a TYPE_DECL with no name, but the type has a name).
1374 This is what represents `struct foo' with no typedef. */
1375 /* In C++, the name of a type is the corresponding typedef.
1376 In C, it is an IDENTIFIER_NODE. */
1377 tree name
= TYPE_NAME (type
);
1378 if (TREE_CODE (name
) == TYPE_DECL
)
1379 name
= DECL_NAME (name
);
1381 current_sym_code
= DBX_DECL_STABS_CODE
;
1382 current_sym_value
= 0;
1383 current_sym_addr
= 0;
1384 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1386 fprintf (asmfile
, "%s \"%s:T", ASM_STABS_OP
,
1387 IDENTIFIER_POINTER (name
));
1388 dbxout_type (type
, 1, 0);
1389 dbxout_finish_symbol (0);
1392 /* Prevent duplicate output of a typedef. */
1393 TREE_ASM_WRITTEN (decl
) = 1;
1397 /* Parm decls go in their own separate chains
1398 and are output by dbxout_reg_parms and dbxout_parms. */
1402 /* Named return value, treat like a VAR_DECL. */
1404 if (DECL_RTL (decl
) == 0)
1406 /* Don't mention a variable that is external.
1407 Let the file that defines it describe it. */
1408 if (TREE_EXTERNAL (decl
))
1411 /* If the variable is really a constant
1412 and not written in memory, inform the debugger. */
1413 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
1414 && DECL_INITIAL (decl
) != 0
1415 && ! TREE_ASM_WRITTEN (decl
)
1416 && (DECL_FIELD_CONTEXT (decl
) == NULL_TREE
1417 || TREE_CODE (DECL_FIELD_CONTEXT (decl
)) == BLOCK
))
1419 if (TREE_PUBLIC (decl
) == 0)
1421 /* The sun4 assembler does not grok this. */
1422 char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1423 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
1424 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
1426 int ival
= TREE_INT_CST_LOW (DECL_INITIAL (decl
));
1427 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1428 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile
, name
, ival
);
1430 fprintf (asmfile
, "%s \"%s:c=i%d\",0x%x,0,0,0\n",
1431 ASM_STABS_OP
, name
, ival
, N_LSYM
);
1435 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
1437 /* don't know how to do this yet. */
1441 /* else it is something we handle like a normal variable. */
1444 DECL_RTL (decl
) = eliminate_regs (DECL_RTL (decl
));
1445 #ifdef LEAF_REG_REMAP
1447 leaf_renumber_regs_insn (DECL_RTL (decl
));
1450 /* Don't mention a variable at all
1451 if it was completely optimized into nothingness.
1453 If DECL was from an inline function, then it's rtl
1454 is not identically the rtl that was used in this
1455 particular compilation. */
1456 if (GET_CODE (DECL_RTL (decl
)) == REG
)
1458 regno
= REGNO (DECL_RTL (decl
));
1459 if (regno
>= FIRST_PSEUDO_REGISTER
)
1460 regno
= reg_renumber
[REGNO (DECL_RTL (decl
))];
1464 else if (GET_CODE (DECL_RTL (decl
)) == SUBREG
)
1466 rtx value
= DECL_RTL (decl
);
1468 while (GET_CODE (value
) == SUBREG
)
1470 offset
+= SUBREG_WORD (value
);
1471 value
= SUBREG_REG (value
);
1473 if (GET_CODE (value
) == REG
)
1475 regno
= REGNO (value
);
1476 if (regno
>= FIRST_PSEUDO_REGISTER
)
1477 regno
= reg_renumber
[REGNO (value
)];
1483 /* The kind-of-variable letter depends on where
1484 the variable is and on the scope of its name:
1485 G and N_GSYM for static storage and global scope,
1486 S for static storage and file scope,
1487 V for static storage and local scope,
1488 for those two, use N_LCSYM if data is in bss segment,
1489 N_STSYM if in data segment, N_FUN otherwise.
1490 (We used N_FUN originally, then changed to N_STSYM
1491 to please GDB. However, it seems that confused ld.
1492 Now GDB has been fixed to like N_FUN, says Kingdon.)
1493 no letter at all, and N_LSYM, for auto variable,
1494 r and N_RSYM for register variable. */
1496 if (GET_CODE (DECL_RTL (decl
)) == MEM
1497 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == SYMBOL_REF
)
1499 if (TREE_PUBLIC (decl
))
1502 current_sym_code
= N_GSYM
;
1506 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1508 letter
= TREE_PERMANENT (decl
) ? 'S' : 'V';
1510 if (!DECL_INITIAL (decl
))
1511 current_sym_code
= N_LCSYM
;
1512 else if (TREE_READONLY (decl
) && ! TREE_THIS_VOLATILE (decl
))
1513 /* This is not quite right, but it's the closest
1514 of all the codes that Unix defines. */
1515 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
1518 /* Ultrix `as' seems to need this. */
1519 #ifdef DBX_STATIC_STAB_DATA_SECTION
1522 current_sym_code
= N_STSYM
;
1526 else if (regno
>= 0)
1529 current_sym_code
= N_RSYM
;
1530 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
1532 else if (GET_CODE (DECL_RTL (decl
)) == SUBREG
)
1534 rtx value
= DECL_RTL (decl
);
1536 while (GET_CODE (value
) == SUBREG
)
1538 offset
+= SUBREG_WORD (value
);
1539 value
= SUBREG_REG (value
);
1542 current_sym_code
= N_RSYM
;
1543 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (value
) + offset
);
1545 else if (GET_CODE (DECL_RTL (decl
)) == MEM
1546 && (GET_CODE (XEXP (DECL_RTL (decl
), 0)) == MEM
1547 || (GET_CODE (XEXP (DECL_RTL (decl
), 0)) == REG
1548 && REGNO (XEXP (DECL_RTL (decl
), 0)) != FRAME_POINTER_REGNUM
)))
1549 /* If the value is indirect by memory or by a register
1550 that isn't the frame pointer
1551 then it means the object is variable-sized and address through
1552 that register or stack slot. DBX has no way to represent this
1553 so all we can do is output the variable as a pointer.
1554 If it's not a parameter, ignore it.
1555 (VAR_DECLs like this can be made by integrate.c.) */
1557 if (GET_CODE (XEXP (DECL_RTL (decl
), 0)) == REG
)
1560 current_sym_code
= N_RSYM
;
1561 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (DECL_RTL (decl
), 0)));
1565 current_sym_code
= N_LSYM
;
1566 /* DECL_RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
1567 We want the value of that CONST_INT. */
1569 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (DECL_RTL (decl
), 0), 0));
1572 /* Effectively do build_pointer_type, but don't cache this type,
1573 since it might be temporary whereas the type it points to
1574 might have been saved for inlining. */
1575 type
= make_node (REFERENCE_TYPE
);
1576 TREE_TYPE (type
) = TREE_TYPE (decl
);
1578 else if (GET_CODE (DECL_RTL (decl
)) == MEM
1579 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == REG
)
1581 current_sym_code
= N_LSYM
;
1582 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (DECL_RTL (decl
), 0));
1584 else if (GET_CODE (DECL_RTL (decl
)) == MEM
1585 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == PLUS
1586 && GET_CODE (XEXP (XEXP (DECL_RTL (decl
), 0), 1)) == CONST_INT
)
1588 current_sym_code
= N_LSYM
;
1589 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
1590 We want the value of that CONST_INT. */
1591 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (DECL_RTL (decl
), 0));
1593 else if (GET_CODE (DECL_RTL (decl
)) == MEM
1594 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == CONST
)
1596 /* Handle an obscure case which can arise when optimizing and
1597 when there are few available registers. (This is *always*
1598 the case for i386/i486 targets). The DECL_RTL looks like
1599 (MEM (CONST ...)) even though this variable is a local `auto'
1600 or a local `register' variable. In effect, what has happened
1601 is that the reload pass has seen that all assignments and
1602 references for one such a local variable can be replaced by
1603 equivalent assignments and references to some static storage
1604 variable, thereby avoiding the need for a register. In such
1605 cases we're forced to lie to debuggers and tell them that
1606 this variable was itself `static'. */
1607 current_sym_code
= N_LCSYM
;
1609 current_sym_addr
= XEXP (XEXP (DECL_RTL (decl
), 0), 0);
1612 /* Address might be a MEM, when DECL is a variable-sized object.
1613 Or it might be const0_rtx, meaning previous passes
1614 want us to ignore this variable. */
1617 /* Ok, start a symtab entry and output the variable name. */
1620 #ifdef DBX_STATIC_BLOCK_START
1621 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
1624 /* One slight hitch: if this is a VAR_DECL which is a static
1625 class member, we must put out the mangled name instead of the
1629 /* Note also that static member (variable) names DO NOT begin
1630 with underscores in .stabs directives. */
1631 if (DECL_LANG_SPECIFIC (decl
))
1632 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
1634 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1635 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
, name
);
1637 if (letter
) putc (letter
, asmfile
);
1638 dbxout_type (type
, 0, 0);
1639 dbxout_finish_symbol (decl
);
1641 #ifdef DBX_STATIC_BLOCK_END
1642 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
1649 dbxout_prepare_symbol (decl
)
1653 char *filename
= DECL_SOURCE_FILE (decl
);
1655 dbxout_source_file (asmfile
, filename
);
1660 dbxout_finish_symbol (sym
)
1663 #ifdef DBX_FINISH_SYMBOL
1664 DBX_FINISH_SYMBOL (sym
);
1669 line
= DECL_SOURCE_LINE (sym
);
1672 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
1673 if (current_sym_addr
)
1674 output_addr_const (asmfile
, current_sym_addr
);
1676 fprintf (asmfile
, "%d", current_sym_value
);
1677 putc ('\n', asmfile
);
1681 /* Output definitions of all the decls in a chain. */
1689 dbxout_symbol (syms
, 1);
1690 syms
= TREE_CHAIN (syms
);
1694 /* The following two functions output definitions of function parameters.
1695 Each parameter gets a definition locating it in the parameter list.
1696 Each parameter that is a register variable gets a second definition
1697 locating it in the register.
1699 Printing or argument lists in gdb uses the definitions that
1700 locate in the parameter list. But reference to the variable in
1701 expressions uses preferentially the definition as a register. */
1703 /* Output definitions, referring to storage in the parmlist,
1704 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
1707 dbxout_parms (parms
)
1710 for (; parms
; parms
= TREE_CHAIN (parms
))
1711 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
1713 dbxout_prepare_symbol (parms
);
1715 /* Perform any necessary register eliminations on the parameter's rtl,
1716 so that the debugging output will be accurate. */
1717 DECL_INCOMING_RTL (parms
)
1718 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, 0);
1719 DECL_RTL (parms
) = eliminate_regs (DECL_RTL (parms
), 0, 0);
1720 #ifdef LEAF_REG_REMAP
1723 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
1724 leaf_renumber_regs_insn (DECL_RTL (parms
));
1728 if (PARM_PASSED_IN_MEMORY (parms
))
1730 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
1732 /* ??? Here we assume that the parm address is indexed
1733 off the frame pointer or arg pointer.
1734 If that is not true, we produce meaningless results,
1735 but do not crash. */
1736 if (GET_CODE (addr
) == PLUS
1737 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
1738 current_sym_value
= INTVAL (XEXP (addr
, 1));
1740 current_sym_value
= 0;
1742 current_sym_code
= N_PSYM
;
1743 current_sym_addr
= 0;
1746 if (DECL_NAME (parms
))
1748 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
1750 fprintf (asmfile
, "%s \"%s:p", ASM_STABS_OP
,
1751 IDENTIFIER_POINTER (DECL_NAME (parms
)));
1755 current_sym_nchars
= 8;
1756 fprintf (asmfile
, "%s \"(anon):p", ASM_STABS_OP
);
1759 if (GET_CODE (DECL_RTL (parms
)) == REG
1760 && REGNO (DECL_RTL (parms
)) >= 0
1761 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
1762 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
1765 int original_value
= current_sym_value
;
1767 /* This is the case where the parm is passed as an int or double
1768 and it is converted to a char, short or float and stored back
1769 in the parmlist. In this case, describe the parm
1770 with the variable's declared type, and adjust the address
1771 if the least significant bytes (which we are using) are not
1773 #if BYTES_BIG_ENDIAN
1774 if (TREE_TYPE (parms
) != DECL_ARG_TYPE (parms
))
1775 current_sym_value
+= (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms
)))
1776 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
))));
1779 if (GET_CODE (DECL_RTL (parms
)) == MEM
1780 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == PLUS
1781 && GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == CONST_INT
1782 && INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == current_sym_value
)
1783 dbxout_type (TREE_TYPE (parms
), 0, 0);
1786 current_sym_value
= original_value
;
1787 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
1790 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
1791 dbxout_finish_symbol (parms
);
1793 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
1796 char regparm_letter
;
1797 /* Parm passed in registers and lives in registers or nowhere. */
1799 current_sym_code
= DBX_REGPARM_STABS_CODE
;
1800 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
1801 current_sym_addr
= 0;
1803 /* If parm lives in a register, use that register;
1804 pretend the parm was passed there. It would be more consistent
1805 to describe the register where the parm was passed,
1806 but in practice that register usually holds something else. */
1807 if (REGNO (DECL_RTL (parms
)) >= 0
1808 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
1809 best_rtl
= DECL_RTL (parms
);
1810 /* If the parm lives nowhere,
1811 use the register where it was passed. */
1813 best_rtl
= DECL_INCOMING_RTL (parms
);
1814 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
1817 if (DECL_NAME (parms
))
1819 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
1820 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
1821 IDENTIFIER_POINTER (DECL_NAME (parms
)),
1826 current_sym_nchars
= 8;
1827 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
1831 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
1832 dbxout_finish_symbol (parms
);
1834 else if (GET_CODE (DECL_RTL (parms
)) == MEM
1835 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
)
1837 /* Parm was passed in registers but lives on the stack. */
1839 current_sym_code
= N_PSYM
;
1840 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
1841 in which case we want the value of that CONST_INT,
1842 or (MEM (REG ...)) or (MEM (MEM ...)),
1843 in which case we use a value of zero. */
1844 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
1845 || GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
1846 current_sym_value
= 0;
1848 current_sym_value
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
1849 current_sym_addr
= 0;
1852 if (DECL_NAME (parms
))
1854 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
1856 fprintf (asmfile
, "%s \"%s:p", ASM_STABS_OP
,
1857 IDENTIFIER_POINTER (DECL_NAME (parms
)));
1861 current_sym_nchars
= 8;
1862 fprintf (asmfile
, "%s \"(anon):p", ASM_STABS_OP
);
1866 = DEBUGGER_ARG_OFFSET (current_sym_value
,
1867 XEXP (DECL_RTL (parms
), 0));
1868 dbxout_type (TREE_TYPE (parms
), 0, 0);
1869 dbxout_finish_symbol (parms
);
1874 /* Output definitions for the places where parms live during the function,
1875 when different from where they were passed, when the parms were passed
1878 It is not useful to do this for parms passed in registers
1879 that live during the function in different registers, because it is
1880 impossible to look in the passed register for the passed value,
1881 so we use the within-the-function register to begin with.
1883 PARMS is a chain of PARM_DECL nodes. */
1886 dbxout_reg_parms (parms
)
1889 for (; parms
; parms
= TREE_CHAIN (parms
))
1890 if (DECL_NAME (parms
))
1892 dbxout_prepare_symbol (parms
);
1894 /* Report parms that live in registers during the function
1895 but were passed in memory. */
1896 if (GET_CODE (DECL_RTL (parms
)) == REG
1897 && REGNO (DECL_RTL (parms
)) >= 0
1898 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
1899 && PARM_PASSED_IN_MEMORY (parms
))
1901 current_sym_code
= N_RSYM
;
1902 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms
)));
1903 current_sym_addr
= 0;
1906 if (DECL_NAME (parms
))
1908 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
1909 fprintf (asmfile
, "%s \"%s:r", ASM_STABS_OP
,
1910 IDENTIFIER_POINTER (DECL_NAME (parms
)));
1914 current_sym_nchars
= 8;
1915 fprintf (asmfile
, "%s \"(anon):r", ASM_STABS_OP
);
1917 dbxout_type (TREE_TYPE (parms
), 0, 0);
1918 dbxout_finish_symbol (parms
);
1920 /* Report parms that live in memory but not where they were passed. */
1921 else if (GET_CODE (DECL_RTL (parms
)) == MEM
1922 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == PLUS
1923 && GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == CONST_INT
1924 && PARM_PASSED_IN_MEMORY (parms
)
1925 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
1927 #if 0 /* ??? It is not clear yet what should replace this. */
1928 int offset
= DECL_OFFSET (parms
) / BITS_PER_UNIT
;
1929 /* A parm declared char is really passed as an int,
1930 so it occupies the least significant bytes.
1931 On a big-endian machine those are not the low-numbered ones. */
1932 #if BYTES_BIG_ENDIAN
1933 if (offset
!= -1 && TREE_TYPE (parms
) != DECL_ARG_TYPE (parms
))
1934 offset
+= (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms
)))
1935 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
))));
1937 if (INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) != offset
) {...}
1939 current_sym_code
= N_LSYM
;
1940 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (DECL_RTL (parms
), 0));
1941 current_sym_addr
= 0;
1943 if (DECL_NAME (parms
))
1945 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
1946 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
,
1947 IDENTIFIER_POINTER (DECL_NAME (parms
)));
1951 current_sym_nchars
= 8;
1952 fprintf (asmfile
, "%s \"(anon):", ASM_STABS_OP
);
1954 dbxout_type (TREE_TYPE (parms
), 0, 0);
1955 dbxout_finish_symbol (parms
);
1960 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
1961 output definitions of those names, in raw form */
1969 putc (',', asmfile
);
1970 dbxout_type (TREE_VALUE (args
), 0, 0);
1972 args
= TREE_CHAIN (args
);
1976 /* Given a chain of ..._TYPE nodes,
1977 find those which have typedef names and output those names.
1978 This is to ensure those types get output. */
1981 dbxout_types (types
)
1982 register tree types
;
1986 if (TYPE_NAME (types
)
1987 && TREE_CODE (TYPE_NAME (types
)) == TYPE_DECL
1988 && ! TREE_ASM_WRITTEN (TYPE_NAME (types
)))
1989 dbxout_symbol (TYPE_NAME (types
), 1);
1990 types
= TREE_CHAIN (types
);
1994 /* Output everything about a symbol block (a BLOCK node
1995 that represents a scope level),
1996 including recursive output of contained blocks.
1998 BLOCK is the BLOCK node.
1999 DEPTH is its depth within containing symbol blocks.
2000 ARGS is usually zero; but for the outermost block of the
2001 body of a function, it is a chain of PARM_DECLs for the function parameters.
2002 We output definitions of all the register parms
2003 as if they were local variables of that block.
2005 If -g1 was used, we count blocks just the same, but output nothing
2006 except for the outermost block.
2008 Actually, BLOCK may be several blocks chained together.
2009 We handle them all in sequence. */
2012 dbxout_block (block
, depth
, args
)
2013 register tree block
;
2021 /* Ignore blocks never expanded or otherwise marked as real. */
2022 if (TREE_USED (block
))
2024 #ifndef DBX_LBRAC_FIRST
2025 /* In dbx format, the syms of a block come before the N_LBRAC. */
2026 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2027 dbxout_syms (BLOCK_VARS (block
));
2029 dbxout_reg_parms (args
);
2032 /* Now output an N_LBRAC symbol to represent the beginning of
2033 the block. Use the block's tree-walk order to generate
2034 the assembler symbols LBBn and LBEn
2035 that final will define around the code in this block. */
2036 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2039 blocknum
= next_block_number
++;
2040 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
2042 if (BLOCK_HANDLER_BLOCK (block
))
2044 /* A catch block. Must precede N_LBRAC. */
2045 tree decl
= BLOCK_VARS (block
);
2048 #ifdef DBX_OUTPUT_CATCH
2049 DBX_OUTPUT_CATCH (asmfile
, decl
, buf
);
2051 fprintf (asmfile
, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP
,
2052 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
2053 assemble_name (asmfile
, buf
);
2054 fprintf (asmfile
, "\n");
2056 decl
= TREE_CHAIN (decl
);
2060 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_LBRAC
);
2061 assemble_name (asmfile
, buf
);
2062 fprintf (asmfile
, "\n");
2065 /* Count blocks the same way regardless of debug_info_level. */
2066 next_block_number
++;
2068 #ifdef DBX_LBRAC_FIRST
2069 /* On some weird machines, the syms of a block
2070 come after the N_LBRAC. */
2071 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2072 dbxout_syms (BLOCK_VARS (block
));
2074 dbxout_reg_parms (args
);
2077 /* Output the subblocks. */
2078 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, 0);
2080 /* Refer to the marker for the end of the block. */
2081 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2084 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
2085 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_RBRAC
);
2086 assemble_name (asmfile
, buf
);
2087 fprintf (asmfile
, "\n");
2090 block
= BLOCK_CHAIN (block
);
2094 /* Output the information about a function and its arguments and result.
2095 Usually this follows the function's code,
2096 but on some systems, it comes before. */
2099 dbxout_really_begin_function (decl
)
2102 dbxout_symbol (decl
, 0);
2103 dbxout_parms (DECL_ARGUMENTS (decl
));
2104 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
2105 dbxout_symbol (DECL_RESULT (decl
), 1);
2108 /* Called at beginning of output of function definition. */
2111 dbxout_begin_function (decl
)
2114 #ifdef DBX_FUNCTION_FIRST
2115 dbxout_really_begin_function (decl
);
2119 /* Output dbx data for a function definition.
2120 This includes a definition of the function name itself (a symbol),
2121 definitions of the parameters (locating them in the parameter list)
2122 and then output the block that makes up the function's body
2123 (including all the auto variables of the function). */
2126 dbxout_function (decl
)
2129 #ifndef DBX_FUNCTION_FIRST
2130 dbxout_really_begin_function (decl
);
2132 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
2133 #ifdef DBX_OUTPUT_FUNCTION_END
2134 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
2137 #endif /* DBX_DEBUGGING_INFO */