1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994 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"
81 #include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions. */
87 #ifdef XCOFF_DEBUGGING_INFO
92 #define ASM_STABS_OP ".stabs"
96 #define ASM_STABN_OP ".stabn"
99 #ifndef DBX_TYPE_DECL_STABS_CODE
100 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
103 #ifndef DBX_STATIC_CONST_VAR_CODE
104 #define DBX_STATIC_CONST_VAR_CODE N_FUN
107 #ifndef DBX_REGPARM_STABS_CODE
108 #define DBX_REGPARM_STABS_CODE N_RSYM
111 #ifndef DBX_REGPARM_STABS_LETTER
112 #define DBX_REGPARM_STABS_LETTER 'P'
115 #ifndef DBX_MEMPARM_STABS_LETTER
116 #define DBX_MEMPARM_STABS_LETTER 'p'
119 #ifndef FILE_NAME_JOINER
120 #define FILE_NAME_JOINER "/"
123 /* Nonzero means if the type has methods, only output debugging
124 information if methods are actually written to the asm file. */
126 static int flag_minimal_debug
= 1;
128 /* Nonzero if we have actually used any of the GDB extensions
129 to the debugging format. The idea is that we use them for the
130 first time only if there's a strong reason, but once we have done that,
131 we use them whenever convenient. */
133 static int have_used_extensions
= 0;
135 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
136 for the N_SO filename stabs label. */
138 static int source_label_number
= 1;
142 /* Typical USG systems don't have stab.h, and they also have
143 no use for DBX-format debugging info. */
145 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
147 #ifdef DEBUG_SYMS_TEXT
148 #define FORCE_TEXT text_section ();
153 #if defined (USG) || defined (NO_STAB_H)
154 #include "gstab.h" /* If doing DBX on sysV, use our own stab.h. */
156 #include <stab.h> /* On BSD, use the system's stab.h. */
158 /* This is a GNU extension we need to reference in this file. */
165 #define STAB_CODE_TYPE enum __stab_debug_code
167 #define STAB_CODE_TYPE int
170 /* 1 if PARM is passed to this function in memory. */
172 #define PARM_PASSED_IN_MEMORY(PARM) \
173 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
175 /* A C expression for the integer offset value of an automatic variable
176 (N_LSYM) having address X (an RTX). */
177 #ifndef DEBUGGER_AUTO_OFFSET
178 #define DEBUGGER_AUTO_OFFSET(X) \
179 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
182 /* A C expression for the integer offset value of an argument (N_PSYM)
183 having address X (an RTX). The nominal offset is OFFSET. */
184 #ifndef DEBUGGER_ARG_OFFSET
185 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
188 /* Stream for writing to assembler file. */
190 static FILE *asmfile
;
192 /* Last source file name mentioned in a NOTE insn. */
194 static char *lastfile
;
196 /* Current working directory. */
200 enum typestatus
{TYPE_UNSEEN
, TYPE_XREF
, TYPE_DEFINED
};
202 /* Vector recording the status of describing C data types.
203 When we first notice a data type (a tree node),
204 we assign it a number using next_type_number.
205 That is its index in this vector.
206 The vector element says whether we have yet output
207 the definition of the type. TYPE_XREF says we have
208 output it as a cross-reference only. */
210 enum typestatus
*typevec
;
212 /* Number of elements of space allocated in `typevec'. */
214 static int typevec_len
;
216 /* In dbx output, each type gets a unique number.
217 This is the number for the next type output.
218 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
220 static int next_type_number
;
222 /* In dbx output, we must assign symbol-blocks id numbers
223 in the order in which their beginnings are encountered.
224 We output debugging info that refers to the beginning and
225 end of the ranges of code in each block
226 with assembler labels LBBn and LBEn, where n is the block number.
227 The labels are generated in final, which assigns numbers to the
228 blocks in the same way. */
230 static int next_block_number
;
232 /* These variables are for dbxout_symbol to communicate to
233 dbxout_finish_symbol.
234 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
235 current_sym_value and current_sym_addr are two ways to address the
236 value to store in the symtab entry.
237 current_sym_addr if nonzero represents the value as an rtx.
238 If that is zero, current_sym_value is used. This is used
239 when the value is an offset (such as for auto variables,
240 register variables and parms). */
242 static STAB_CODE_TYPE current_sym_code
;
243 static int current_sym_value
;
244 static rtx current_sym_addr
;
246 /* Number of chars of symbol-description generated so far for the
247 current symbol. Used by CHARS and CONTIN. */
249 static int current_sym_nchars
;
251 /* Report having output N chars of the current symbol-description. */
253 #define CHARS(N) (current_sym_nchars += (N))
255 /* Break the current symbol-description, generating a continuation,
256 if it has become long. */
258 #ifndef DBX_CONTIN_LENGTH
259 #define DBX_CONTIN_LENGTH 80
262 #if DBX_CONTIN_LENGTH > 0
264 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
269 void dbxout_types ();
271 void dbxout_symbol ();
272 static void dbxout_type_name ();
273 static void dbxout_type ();
274 static void dbxout_typedefs ();
275 static void dbxout_symbol_name ();
276 static void dbxout_symbol_location ();
277 static void dbxout_prepare_symbol ();
278 static void dbxout_finish_symbol ();
279 static void dbxout_continue ();
280 static void print_int_cst_octal ();
281 static void print_octal ();
283 #if 0 /* Not clear we will actually need this. */
285 /* Return the absolutized filename for the given relative
286 filename. Note that if that filename is already absolute, it may
287 still be returned in a modified form because this routine also
288 eliminates redundant slashes and single dots and eliminates double
289 dots to get a shortest possible filename from the given input
290 filename. The absolutization of relative filenames is made by
291 assuming that the given filename is to be taken as relative to
292 the first argument (cwd) or to the current directory if cwd is
296 abspath (rel_filename
)
299 /* Setup the current working directory as needed. */
301 = (char *) alloca (strlen (cwd
) + strlen (rel_filename
) + 1);
302 char *endp
= abs_buffer
;
306 /* Copy the filename (possibly preceded by the current working
307 directory name) into the absolutization buffer. */
312 if (rel_filename
[0] != '/')
315 while (*endp
++ = *src_p
++)
317 *(endp
-1) = '/'; /* overwrite null */
319 src_p
= rel_filename
;
320 while (*endp
++ = *src_p
++)
325 /* Now make a copy of abs_buffer into abs_buffer, shortening the
326 filename (by taking out slashes and dots) as we go. */
328 outp
= inp
= abs_buffer
;
329 *outp
++ = *inp
++; /* copy first slash */
334 else if (inp
[0] == '/' && outp
[-1] == '/')
339 else if (inp
[0] == '.' && outp
[-1] == '/')
343 else if (inp
[1] == '/')
348 else if ((inp
[1] == '.') && (inp
[2] == 0 || inp
[2] == '/'))
350 inp
+= (inp
[2] == '/') ? 3 : 2;
352 while (outp
>= abs_buffer
&& *outp
!= '/')
354 if (outp
< abs_buffer
)
356 /* Catch cases like /.. where we try to backup to a
357 point above the absolute root of the logical file
360 fprintf (stderr
, "%s: invalid file name: %s\n",
361 pname
, rel_filename
);
371 /* On exit, make sure that there is a trailing null, and make sure that
372 the last character of the returned string is *not* a slash. */
378 /* Make a copy (in the heap) of the stuff left in the absolutization
379 buffer and return a pointer to the copy. */
381 value
= (char *) oballoc (strlen (abs_buffer
) + 1);
382 strcpy (value
, abs_buffer
);
387 /* At the beginning of compilation, start writing the symbol table.
388 Initialize `typevec' and output the standard data types of C. */
391 dbxout_init (asm_file
, input_file_name
, syms
)
393 char *input_file_name
;
396 char ltext_label_name
[100];
401 typevec
= (enum typestatus
*) xmalloc (typevec_len
* sizeof typevec
[0]);
402 bzero ((char *) typevec
, typevec_len
* sizeof typevec
[0]);
404 /* Convert Ltext into the appropriate format for local labels in case
405 the system doesn't insert underscores in front of user generated
407 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
409 /* Put the current working directory in an N_SO symbol. */
410 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
411 but GDB always does. */
412 if (use_gnu_debug_info_extensions
)
415 if (!cwd
&& (cwd
= getpwd ()) && (!*cwd
|| cwd
[strlen (cwd
) - 1] != '/'))
417 char *wdslash
= xmalloc (strlen (cwd
) + sizeof (FILE_NAME_JOINER
));
418 sprintf (wdslash
, "%s%s", cwd
, FILE_NAME_JOINER
);
423 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
424 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile
, cwd
);
425 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
426 fprintf (asmfile
, "%s ", ASM_STABS_OP
);
427 output_quoted_string (asmfile
, cwd
);
428 fprintf (asmfile
, ",%d,0,0,%s\n", N_SO
, <ext_label_name
[1]);
429 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
433 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
434 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
435 would give us an N_SOL, and we want an N_SO. */
436 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile
, input_file_name
);
437 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
438 /* We include outputting `Ltext:' here,
439 because that gives you a way to override it. */
440 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
441 fprintf (asmfile
, "%s ", ASM_STABS_OP
);
442 output_quoted_string (asmfile
, input_file_name
);
443 fprintf (asmfile
, ",%d,0,0,%s\n",
444 N_SO
, <ext_label_name
[1]);
446 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Ltext", 0);
447 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
449 /* Possibly output something to inform GDB that this compilation was by
450 GCC. It's easier for GDB to parse it when after the N_SO's. This
451 is used in Solaris 2. */
452 #ifdef ASM_IDENTIFY_GCC_AFTER_SOURCE
453 ASM_IDENTIFY_GCC_AFTER_SOURCE (asmfile
);
456 lastfile
= input_file_name
;
458 next_type_number
= 1;
459 next_block_number
= 2;
461 /* Make sure that types `int' and `char' have numbers 1 and 2.
462 Definitions of other integer types will refer to those numbers.
463 (Actually it should no longer matter what their numbers are.
464 Also, if any types with tags have been defined, dbxout_symbol
465 will output them first, so the numbers won't be 1 and 2. That
466 happens in C++. So it's a good thing it should no longer matter). */
468 #ifdef DBX_OUTPUT_STANDARD_TYPES
469 DBX_OUTPUT_STANDARD_TYPES (syms
);
471 dbxout_symbol (TYPE_NAME (integer_type_node
), 0);
472 dbxout_symbol (TYPE_NAME (char_type_node
), 0);
475 /* Get all permanent types that have typedef names,
476 and output them all, except for those already output. */
478 dbxout_typedefs (syms
);
481 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
482 in the reverse order from that which is found in SYMS. */
485 dbxout_typedefs (syms
)
490 dbxout_typedefs (TREE_CHAIN (syms
));
491 if (TREE_CODE (syms
) == TYPE_DECL
)
493 tree type
= TREE_TYPE (syms
);
495 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
496 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
497 dbxout_symbol (TYPE_NAME (type
), 0);
502 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
505 dbxout_source_file (file
, filename
)
509 char ltext_label_name
[100];
511 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
513 #ifdef DBX_OUTPUT_SOURCE_FILENAME
514 DBX_OUTPUT_SOURCE_FILENAME (file
, filename
);
516 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext",
517 source_label_number
);
518 fprintf (file
, "%s ", ASM_STABS_OP
);
519 output_quoted_string (file
, filename
);
520 fprintf (file
, ",%d,0,0,%s\n", N_SOL
, <ext_label_name
[1]);
522 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Ltext", source_label_number
++);
528 /* Output a line number symbol entry into output stream FILE,
529 for source file FILENAME and line number LINENO. */
532 dbxout_source_line (file
, filename
, lineno
)
537 dbxout_source_file (file
, filename
);
539 #ifdef ASM_OUTPUT_SOURCE_LINE
540 ASM_OUTPUT_SOURCE_LINE (file
, lineno
);
542 fprintf (file
, "\t%s %d,0,%d\n", ASM_STABD_OP
, N_SLINE
, lineno
);
546 /* At the end of compilation, finish writing the symbol table.
547 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
551 dbxout_finish (file
, filename
)
555 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
556 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file
, filename
);
557 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
560 /* Continue a symbol-description that gets too big.
561 End one symbol table entry with a double-backslash
562 and start a new one, eventually producing something like
563 .stabs "start......\\",code,0,value
564 .stabs "...rest",code,0,value */
569 #ifdef DBX_CONTIN_CHAR
570 fprintf (asmfile
, "%c", DBX_CONTIN_CHAR
);
572 fprintf (asmfile
, "\\\\");
574 dbxout_finish_symbol (NULL_TREE
);
575 fprintf (asmfile
, "%s \"", ASM_STABS_OP
);
576 current_sym_nchars
= 0;
579 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
580 This must be a separate function because anonymous unions require
584 dbxout_type_fields (type
)
588 /* Output the name, type, position (in bits), size (in bits) of each
590 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
592 /* Omit here local type decls until we know how to support them. */
593 if (TREE_CODE (tem
) == TYPE_DECL
)
595 /* Omit fields whose position or size are variable. */
596 else if (TREE_CODE (tem
) == FIELD_DECL
597 && (TREE_CODE (DECL_FIELD_BITPOS (tem
)) != INTEGER_CST
598 || TREE_CODE (DECL_SIZE (tem
)) != INTEGER_CST
))
600 /* Omit here the nameless fields that are used to skip bits. */
601 else if (TREE_CODE (tem
) != CONST_DECL
)
603 /* Continue the line if necessary,
604 but not before the first field. */
605 if (tem
!= TYPE_FIELDS (type
))
608 if (use_gnu_debug_info_extensions
609 && flag_minimal_debug
610 && TREE_CODE (tem
) == FIELD_DECL
611 && DECL_VIRTUAL_P (tem
)
612 && DECL_ASSEMBLER_NAME (tem
))
614 have_used_extensions
= 1;
615 CHARS (3 + IDENTIFIER_LENGTH (DECL_NAME (TYPE_NAME (DECL_FCONTEXT (tem
)))));
616 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
)), asmfile
);
617 dbxout_type (DECL_FCONTEXT (tem
), 0, 0);
618 fprintf (asmfile
, ":");
619 dbxout_type (TREE_TYPE (tem
), 0, 0);
620 fprintf (asmfile
, ",%d;",
621 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem
)));
627 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem
)));
628 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem
)));
632 fprintf (asmfile
, ":");
636 if (use_gnu_debug_info_extensions
637 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
638 || TREE_CODE (tem
) != FIELD_DECL
))
640 have_used_extensions
= 1;
642 putc ((TREE_PRIVATE (tem
) ? '0'
643 : TREE_PROTECTED (tem
) ? '1' : '2'),
648 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
649 && DECL_BIT_FIELD_TYPE (tem
))
650 ? DECL_BIT_FIELD_TYPE (tem
)
651 : TREE_TYPE (tem
), 0, 0);
653 if (TREE_CODE (tem
) == VAR_DECL
)
655 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
657 char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
));
658 have_used_extensions
= 1;
659 fprintf (asmfile
, ":%s;", name
);
660 CHARS (strlen (name
));
664 /* If TEM is non-static, GDB won't understand it. */
665 fprintf (asmfile
, ",0,0;");
668 else if (TREE_CODE (DECL_FIELD_BITPOS (tem
)) == INTEGER_CST
)
670 fprintf (asmfile
, ",%d,%d;",
671 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem
)),
672 TREE_INT_CST_LOW (DECL_SIZE (tem
)));
679 /* Subroutine of `dbxout_type_methods'. Output debug info about the
680 method described DECL. DEBUG_NAME is an encoding of the method's
681 type signature. ??? We may be able to do without DEBUG_NAME altogether
685 dbxout_type_method_1 (decl
, debug_name
)
689 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
692 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
694 else /* it's a METHOD_TYPE. */
696 /* A for normal functions.
697 B for `const' member functions.
698 C for `volatile' member functions.
699 D for `const volatile' member functions. */
700 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
702 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
705 if (DECL_VINDEX (decl
))
711 fprintf (asmfile
, ":%s;%c%c%c", debug_name
,
712 TREE_PRIVATE (decl
) ? '0' : TREE_PROTECTED (decl
) ? '1' : '2', c1
, c2
);
713 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
)) + 6
714 - (debug_name
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
715 if (DECL_VINDEX (decl
))
717 fprintf (asmfile
, "%d;",
718 TREE_INT_CST_LOW (DECL_VINDEX (decl
)));
719 dbxout_type (DECL_CONTEXT (decl
), 0, 0);
720 fprintf (asmfile
, ";");
725 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
729 dbxout_type_methods (type
)
732 /* C++: put out the method names and their parameter lists */
733 tree methods
= TYPE_METHODS (type
);
735 register tree fndecl
;
737 char formatted_type_identifier_length
[16];
738 register int type_identifier_length
;
740 if (methods
== NULL_TREE
)
743 type_encoding
= DECL_NAME (TYPE_NAME (type
));
746 /* C++: Template classes break some assumptions made by this code about
747 the class names, constructor names, and encodings for assembler
748 label names. For now, disable output of dbx info for them. */
750 char *ptr
= IDENTIFIER_POINTER (type_encoding
);
751 /* This should use index. (mrs) */
752 while (*ptr
&& *ptr
!= '<') ptr
++;
759 #ifdef HAVE_TEMPLATES
760 if (warn_template_debugging
)
761 warning ("dbx info for template class methods not yet supported");
769 type_identifier_length
= IDENTIFIER_LENGTH (type_encoding
);
771 sprintf(formatted_type_identifier_length
, "%d", type_identifier_length
);
773 if (TREE_CODE (methods
) == FUNCTION_DECL
)
775 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
776 fndecl
= TREE_VEC_ELT (methods
, 0);
778 fndecl
= TREE_VEC_ELT (methods
, 1);
782 tree name
= DECL_NAME (fndecl
);
785 /* Group together all the methods for the same operation.
786 These differ in the types of the arguments. */
787 for (last
= NULL_TREE
;
788 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
789 fndecl
= TREE_CHAIN (fndecl
))
790 /* Output the name of the field (after overloading), as
791 well as the name of the field before overloading, along
792 with its parameter list */
794 /* This is the "mangled" name of the method.
795 It encodes the argument types. */
796 char *debug_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
));
803 if (DECL_IGNORED_P (fndecl
))
806 if (flag_minimal_debug
)
808 /* Detect ordinary methods because their mangled names
809 start with the operation name. */
810 if (!strncmp (IDENTIFIER_POINTER (name
), debug_name
,
811 IDENTIFIER_LENGTH (name
)))
813 debug_name
+= IDENTIFIER_LENGTH (name
);
814 if (debug_name
[0] == '_' && debug_name
[1] == '_')
816 char *method_name
= debug_name
+ 2;
817 char *length_ptr
= formatted_type_identifier_length
;
818 /* Get past const and volatile qualifiers. */
819 while (*method_name
== 'C' || *method_name
== 'V')
821 /* Skip digits for length of type_encoding. */
822 while (*method_name
== *length_ptr
&& *length_ptr
)
823 length_ptr
++, method_name
++;
824 if (! strncmp (method_name
,
825 IDENTIFIER_POINTER (type_encoding
),
826 type_identifier_length
))
827 method_name
+= type_identifier_length
;
828 debug_name
= method_name
;
831 /* Detect constructors by their style of name mangling. */
832 else if (debug_name
[0] == '_' && debug_name
[1] == '_')
834 char *ctor_name
= debug_name
+ 2;
835 char *length_ptr
= formatted_type_identifier_length
;
836 while (*ctor_name
== 'C' || *ctor_name
== 'V')
838 /* Skip digits for length of type_encoding. */
839 while (*ctor_name
== *length_ptr
&& *length_ptr
)
840 length_ptr
++, ctor_name
++;
841 if (!strncmp (IDENTIFIER_POINTER (type_encoding
), ctor_name
,
842 type_identifier_length
))
843 debug_name
= ctor_name
+ type_identifier_length
;
845 /* The other alternative is a destructor. */
849 /* Output the operation name just once, for the first method
853 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (name
));
854 CHARS (IDENTIFIER_LENGTH (name
) + 2);
859 dbxout_type (TREE_TYPE (fndecl
), 0, destructor
);
861 dbxout_type_method_1 (fndecl
, debug_name
);
871 /* Emit a "range" type specification, which has the form:
872 "r<index type>;<lower bound>;<upper bound>;".
873 TYPE is an INTEGER_TYPE. */
876 dbxout_range_type (type
)
879 fprintf (asmfile
, "r");
880 if (TREE_TYPE (type
))
881 dbxout_type (TREE_TYPE (type
), 0, 0);
882 else if (TREE_CODE (type
) != INTEGER_TYPE
)
883 dbxout_type (type
, 0, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
886 /* This used to say `r1' and we used to take care
887 to make sure that `int' was type number 1. */
888 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (integer_type_node
));
890 if (TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
)
891 fprintf (asmfile
, ";%d",
892 TREE_INT_CST_LOW (TYPE_MIN_VALUE (type
)));
894 fprintf (asmfile
, ";0");
895 if (TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
)
896 fprintf (asmfile
, ";%d;",
897 TREE_INT_CST_LOW (TYPE_MAX_VALUE (type
)));
899 fprintf (asmfile
, ";-1;");
902 /* Output a reference to a type. If the type has not yet been
903 described in the dbx output, output its definition now.
904 For a type already defined, just refer to its definition
905 using the type number.
907 If FULL is nonzero, and the type has been described only with
908 a forward-reference, output the definition now.
909 If FULL is zero in this case, just refer to the forward-reference
910 using the number previously allocated.
912 If SHOW_ARG_TYPES is nonzero, we output a description of the argument
913 types for a METHOD_TYPE. */
916 dbxout_type (type
, full
, show_arg_types
)
922 static int anonymous_type_number
= 0;
924 /* If there was an input error and we don't really have a type,
925 avoid crashing and write something that is at least valid
926 by assuming `int'. */
927 if (type
== error_mark_node
)
928 type
= integer_type_node
;
931 type
= TYPE_MAIN_VARIANT (type
);
933 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
934 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
938 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
940 /* Type has no dbx number assigned. Assign next available number. */
941 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
943 /* Make sure type vector is long enough to record about this type. */
945 if (next_type_number
== typevec_len
)
948 (enum typestatus
*) xrealloc (typevec
,
949 typevec_len
* 2 * sizeof typevec
[0]);
950 bzero ((char *) (typevec
+ typevec_len
),
951 typevec_len
* sizeof typevec
[0]);
956 /* Output the number of this type, to refer to it. */
957 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
960 #ifdef DBX_TYPE_DEFINED
961 if (DBX_TYPE_DEFINED (type
))
965 /* If this type's definition has been output or is now being output,
968 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)])
973 /* If we have already had a cross reference,
974 and either that's all we want or that's the best we could do,
975 don't repeat the cross reference.
976 Sun dbx crashes if we do. */
977 if (! full
|| TYPE_SIZE (type
) == 0
978 /* No way in DBX fmt to describe a variable size. */
979 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
987 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
988 leave the type-number completely undefined rather than output
989 a cross-reference. If we have already used GNU debug info extensions,
990 then it is OK to output a cross reference. This is necessary to get
991 proper C++ debug output. */
992 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
993 || TREE_CODE (type
) == QUAL_UNION_TYPE
994 || TREE_CODE (type
) == ENUMERAL_TYPE
)
995 && ! use_gnu_debug_info_extensions
)
996 /* We must use the same test here as we use twice below when deciding
997 whether to emit a cross-reference. */
998 if ((TYPE_NAME (type
) != 0
999 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1000 && DECL_IGNORED_P (TYPE_NAME (type
)))
1002 || TYPE_SIZE (type
) == 0
1003 /* No way in DBX fmt to describe a variable size. */
1004 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1006 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_XREF
;
1011 /* Output a definition now. */
1013 fprintf (asmfile
, "=");
1016 /* Mark it as defined, so that if it is self-referent
1017 we will not get into an infinite recursion of definitions. */
1019 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_DEFINED
;
1021 switch (TREE_CODE (type
))
1025 /* For a void type, just define it as itself; ie, "5=5".
1026 This makes us consider it defined
1027 without saying what it is. The debugger will make it
1028 a void type when the reference is seen, and nothing will
1029 ever override that default. */
1030 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
1035 if (type
== char_type_node
&& ! TREE_UNSIGNED (type
))
1036 /* Output the type `char' as a subrange of itself!
1037 I don't understand this definition, just copied it
1038 from the output of pcc.
1039 This used to use `r2' explicitly and we used to
1040 take care to make sure that `char' was type number 2. */
1041 fprintf (asmfile
, "r%d;0;127;", TYPE_SYMTAB_ADDRESS (type
));
1042 else if (use_gnu_debug_info_extensions
1043 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
1044 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
))
1046 /* This used to say `r1' and we used to take care
1047 to make sure that `int' was type number 1. */
1048 fprintf (asmfile
, "r%d;", TYPE_SYMTAB_ADDRESS (integer_type_node
));
1049 print_int_cst_octal (TYPE_MIN_VALUE (type
));
1050 fprintf (asmfile
, ";");
1051 print_int_cst_octal (TYPE_MAX_VALUE (type
));
1052 fprintf (asmfile
, ";");
1054 else /* Output other integer types as subranges of `int'. */
1055 dbxout_range_type (type
);
1060 /* This used to say `r1' and we used to take care
1061 to make sure that `int' was type number 1. */
1062 fprintf (asmfile
, "r%d;%d;0;", TYPE_SYMTAB_ADDRESS (integer_type_node
),
1063 int_size_in_bytes (type
));
1068 if (use_gnu_debug_info_extensions
)
1069 fprintf (asmfile
, "@s%d;-20;",
1070 BITS_PER_UNIT
* int_size_in_bytes (type
));
1072 /* Output the type `char' as a subrange of itself.
1073 That is what pcc seems to do. */
1074 fprintf (asmfile
, "r%d;0;%d;", TYPE_SYMTAB_ADDRESS (char_type_node
),
1075 TREE_UNSIGNED (type
) ? 255 : 127);
1080 if (use_gnu_debug_info_extensions
)
1081 fprintf (asmfile
, "@s%d;-16;",
1082 BITS_PER_UNIT
* int_size_in_bytes (type
));
1083 else /* Define as enumeral type (False, True) */
1084 fprintf (asmfile
, "eFalse:0,True:1,;");
1089 putc ('d', asmfile
);
1091 dbxout_type (TREE_TYPE (type
), 0, 0);
1095 /* Differs from the REAL_TYPE by its new data type number */
1097 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1099 fprintf (asmfile
, "r%d;%d;0;",
1100 TYPE_SYMTAB_ADDRESS (type
),
1101 int_size_in_bytes (TREE_TYPE (type
)));
1102 CHARS (15); /* The number is probably incorrect here. */
1106 /* Output a complex integer type as a structure,
1107 pending some other way to do it. */
1108 fprintf (asmfile
, "s%d", int_size_in_bytes (type
));
1110 fprintf (asmfile
, "real:");
1112 dbxout_type (TREE_TYPE (type
), 0, 0);
1113 fprintf (asmfile
, ",%d,%d;",
1114 0, TYPE_PRECISION (TREE_TYPE (type
)));
1116 fprintf (asmfile
, "imag:");
1118 dbxout_type (TREE_TYPE (type
), 0, 0);
1119 fprintf (asmfile
, ",%d,%d;;",
1120 TYPE_PRECISION (TREE_TYPE (type
)),
1121 TYPE_PRECISION (TREE_TYPE (type
)));
1127 if (use_gnu_debug_info_extensions
)
1129 have_used_extensions
= 1;
1130 fprintf (asmfile
, "@s%d;",
1131 BITS_PER_UNIT
* int_size_in_bytes (type
));
1132 /* Check if a bitstring type, which in Chill is
1133 different from a [power]set. */
1134 if (TYPE_STRING_FLAG (type
))
1135 fprintf (asmfile
, "@S;");
1137 putc ('S', asmfile
);
1139 dbxout_type (TYPE_DOMAIN (type
), 0, 0);
1143 /* Output "a" followed by a range type definition
1144 for the index type of the array
1145 followed by a reference to the target-type.
1146 ar1;0;N;M for a C array of type M and size N+1. */
1147 /* Check if a character string type, which in Chill is
1148 different from an array of characters. */
1149 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
1151 have_used_extensions
= 1;
1152 fprintf (asmfile
, "@S;");
1154 tem
= TYPE_DOMAIN (type
);
1156 fprintf (asmfile
, "ar%d;0;-1;",
1157 TYPE_SYMTAB_ADDRESS (integer_type_node
));
1160 fprintf (asmfile
, "a");
1161 dbxout_range_type (tem
);
1164 dbxout_type (TREE_TYPE (type
), 0, 0);
1169 case QUAL_UNION_TYPE
:
1171 int i
, n_baseclasses
= 0;
1173 if (TYPE_BINFO (type
) != 0 && TYPE_BINFO_BASETYPES (type
) != 0)
1174 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
1176 /* Output a structure type. We must use the same test here as we
1177 use in the DBX_NO_XREFS case above. */
1178 if ((TYPE_NAME (type
) != 0
1179 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1180 && DECL_IGNORED_P (TYPE_NAME (type
)))
1182 || TYPE_SIZE (type
) == 0
1183 /* No way in DBX fmt to describe a variable size. */
1184 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1186 /* If the type is just a cross reference, output one
1187 and mark the type as partially described.
1188 If it later becomes defined, we will output
1189 its real definition.
1190 If the type has a name, don't nest its definition within
1191 another type's definition; instead, output an xref
1192 and let the definition come when the name is defined. */
1193 fprintf (asmfile
, (TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu");
1195 #if 0 /* This assertion is legitimately false in C++. */
1196 /* We shouldn't be outputting a reference to a type before its
1197 definition unless the type has a tag name.
1198 A typedef name without a tag name should be impossible. */
1199 if (TREE_CODE (TYPE_NAME (type
)) != IDENTIFIER_NODE
)
1202 if (TYPE_NAME (type
) != 0)
1203 dbxout_type_name (type
);
1205 fprintf (asmfile
, "$$%d", anonymous_type_number
++);
1206 fprintf (asmfile
, ":");
1207 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_XREF
;
1211 /* Identify record or union, and print its size. */
1212 fprintf (asmfile
, (TREE_CODE (type
) == RECORD_TYPE
) ? "s%d" : "u%d",
1213 int_size_in_bytes (type
));
1215 if (use_gnu_debug_info_extensions
)
1219 have_used_extensions
= 1;
1220 fprintf (asmfile
, "!%d,", n_baseclasses
);
1224 for (i
= 0; i
< n_baseclasses
; i
++)
1226 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)), i
);
1227 if (use_gnu_debug_info_extensions
)
1229 have_used_extensions
= 1;
1230 putc (TREE_VIA_VIRTUAL (child
) ? '1'
1233 putc (TREE_VIA_PUBLIC (child
) ? '2'
1236 fprintf (asmfile
, "%d,",
1237 TREE_INT_CST_LOW (BINFO_OFFSET (child
)) * BITS_PER_UNIT
);
1239 dbxout_type (BINFO_TYPE (child
), 0, 0);
1240 putc (';', asmfile
);
1244 /* Print out the base class information with fields
1245 which have the same names at the types they hold. */
1246 dbxout_type_name (BINFO_TYPE (child
));
1247 putc (':', asmfile
);
1248 dbxout_type (BINFO_TYPE (child
), full
, 0);
1249 fprintf (asmfile
, ",%d,%d;",
1250 TREE_INT_CST_LOW (BINFO_OFFSET (child
)) * BITS_PER_UNIT
,
1251 TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child
)))) * BITS_PER_UNIT
);
1259 /* Write out the field declarations. */
1260 dbxout_type_fields (type
);
1261 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1263 have_used_extensions
= 1;
1264 dbxout_type_methods (type
);
1266 putc (';', asmfile
);
1268 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1269 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1270 && TYPE_VFIELD (type
))
1272 have_used_extensions
= 1;
1274 /* Tell GDB+ that it may keep reading. */
1275 putc ('~', asmfile
);
1277 /* We need to write out info about what field this class
1278 uses as its "main" vtable pointer field, because if this
1279 field is inherited from a base class, GDB cannot necessarily
1280 figure out which field it's using in time. */
1281 if (TYPE_VFIELD (type
))
1283 putc ('%', asmfile
);
1284 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0, 0);
1286 putc (';', asmfile
);
1292 /* We must use the same test here as we use in the DBX_NO_XREFS case
1293 above. We simplify it a bit since an enum will never have a variable
1295 if ((TYPE_NAME (type
) != 0
1296 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1297 && DECL_IGNORED_P (TYPE_NAME (type
)))
1299 || TYPE_SIZE (type
) == 0)
1301 fprintf (asmfile
, "xe");
1303 dbxout_type_name (type
);
1304 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_XREF
;
1305 fprintf (asmfile
, ":");
1308 #ifdef DBX_OUTPUT_ENUM
1309 DBX_OUTPUT_ENUM (asmfile
, type
);
1311 if (use_gnu_debug_info_extensions
1312 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1313 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1314 putc ('e', asmfile
);
1316 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1318 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)));
1319 if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == 0)
1320 fprintf (asmfile
, "%lu",
1321 (unsigned long) TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1322 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == -1
1323 && TREE_INT_CST_LOW (TREE_VALUE (tem
)) < 0)
1324 fprintf (asmfile
, "%ld",
1325 (long) TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1327 print_int_cst_octal (TREE_VALUE (tem
));
1328 fprintf (asmfile
, ",");
1329 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)));
1330 if (TREE_CHAIN (tem
) != 0)
1333 putc (';', asmfile
);
1339 putc ('*', asmfile
);
1341 dbxout_type (TREE_TYPE (type
), 0, 0);
1345 if (use_gnu_debug_info_extensions
)
1347 have_used_extensions
= 1;
1348 putc ('#', asmfile
);
1350 if (flag_minimal_debug
&& !show_arg_types
)
1352 /* Normally, just output the return type.
1353 The argument types are encoded in the method name. */
1354 putc ('#', asmfile
);
1355 dbxout_type (TREE_TYPE (type
), 0, 0);
1356 putc (';', asmfile
);
1361 /* When outputting destructors, we need to write
1362 the argument types out longhand. */
1363 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0, 0);
1364 putc (',', asmfile
);
1366 dbxout_type (TREE_TYPE (type
), 0, 0);
1367 dbxout_args (TYPE_ARG_TYPES (type
));
1368 putc (';', asmfile
);
1374 /* Treat it as a function type. */
1375 dbxout_type (TREE_TYPE (type
), 0, 0);
1380 if (use_gnu_debug_info_extensions
)
1382 have_used_extensions
= 1;
1383 putc ('@', asmfile
);
1385 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0, 0);
1386 putc (',', asmfile
);
1388 dbxout_type (TREE_TYPE (type
), 0, 0);
1392 /* Should print as an int, because it is really
1394 dbxout_type (integer_type_node
, 0, 0);
1398 case REFERENCE_TYPE
:
1399 if (use_gnu_debug_info_extensions
)
1400 have_used_extensions
= 1;
1401 putc (use_gnu_debug_info_extensions
? '&' : '*', asmfile
);
1403 dbxout_type (TREE_TYPE (type
), 0, 0);
1407 putc ('f', asmfile
);
1409 dbxout_type (TREE_TYPE (type
), 0, 0);
1417 /* Print the value of integer constant C, in octal,
1418 handling double precision. */
1421 print_int_cst_octal (c
)
1424 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (c
);
1425 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (c
);
1426 int excess
= (3 - (HOST_BITS_PER_WIDE_INT
% 3));
1427 int width
= TYPE_PRECISION (TREE_TYPE (c
));
1429 /* GDB wants constants with no extra leading "1" bits, so
1430 we need to remove any sign-extension that might be
1432 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
1434 else if (width
> HOST_BITS_PER_WIDE_INT
)
1435 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
1436 else if (width
== HOST_BITS_PER_WIDE_INT
)
1439 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
1441 fprintf (asmfile
, "0");
1445 print_octal (high
, HOST_BITS_PER_WIDE_INT
/ 3);
1446 print_octal (low
, HOST_BITS_PER_WIDE_INT
/ 3);
1450 unsigned HOST_WIDE_INT beg
= high
>> excess
;
1451 unsigned HOST_WIDE_INT middle
1452 = ((high
& (((HOST_WIDE_INT
) 1 << excess
) - 1)) << (3 - excess
)
1453 | (low
>> (HOST_BITS_PER_WIDE_INT
/ 3 * 3)));
1454 unsigned HOST_WIDE_INT end
1455 = low
& (((unsigned HOST_WIDE_INT
) 1
1456 << (HOST_BITS_PER_WIDE_INT
/ 3 * 3))
1459 fprintf (asmfile
, "%o%01o", beg
, middle
);
1460 print_octal (end
, HOST_BITS_PER_WIDE_INT
/ 3);
1465 print_octal (value
, digits
)
1466 unsigned HOST_WIDE_INT value
;
1471 for (i
= digits
- 1; i
>= 0; i
--)
1472 fprintf (asmfile
, "%01o", ((value
>> (3 * i
)) & 7));
1475 /* Output the name of type TYPE, with no punctuation.
1476 Such names can be set up either by typedef declarations
1477 or by struct, enum and union tags. */
1480 dbxout_type_name (type
)
1484 if (TYPE_NAME (type
) == 0)
1486 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
1488 t
= TYPE_NAME (type
);
1490 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1492 t
= DECL_NAME (TYPE_NAME (type
));
1497 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
1498 CHARS (IDENTIFIER_LENGTH (t
));
1501 /* Output a .stabs for the symbol defined by DECL,
1502 which must be a ..._DECL node in the normal namespace.
1503 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1504 LOCAL is nonzero if the scope is less than the entire file. */
1507 dbxout_symbol (decl
, local
)
1511 tree type
= TREE_TYPE (decl
);
1512 tree context
= NULL_TREE
;
1514 /* Cast avoids warning in old compilers. */
1515 current_sym_code
= (STAB_CODE_TYPE
) 0;
1516 current_sym_value
= 0;
1517 current_sym_addr
= 0;
1519 /* Ignore nameless syms, but don't ignore type tags. */
1521 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
1522 || DECL_IGNORED_P (decl
))
1525 dbxout_prepare_symbol (decl
);
1527 /* The output will always start with the symbol name,
1528 so always count that in the length-output-so-far. */
1530 if (DECL_NAME (decl
) != 0)
1531 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
1533 switch (TREE_CODE (decl
))
1536 /* Enum values are defined by defining the enum type. */
1540 if (DECL_RTL (decl
) == 0)
1542 if (DECL_EXTERNAL (decl
))
1544 /* Don't mention a nested function under its parent. */
1545 context
= decl_function_context (decl
);
1546 if (context
== current_function_decl
)
1548 if (GET_CODE (DECL_RTL (decl
)) != MEM
1549 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
1553 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
1554 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1555 TREE_PUBLIC (decl
) ? 'F' : 'f');
1557 current_sym_code
= N_FUN
;
1558 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1560 if (TREE_TYPE (type
))
1561 dbxout_type (TREE_TYPE (type
), 0, 0);
1563 dbxout_type (void_type_node
, 0, 0);
1565 /* For a nested function, when that function is compiled,
1566 mention the containing function name
1567 as well as (since dbx wants it) our own assembler-name. */
1569 fprintf (asmfile
, ",%s,%s",
1570 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1571 IDENTIFIER_POINTER (DECL_NAME (context
)));
1573 dbxout_finish_symbol (decl
);
1578 /* This seems all wrong. Outputting most kinds of types gives no name
1579 at all. A true definition gives no name; a cross-ref for a
1580 structure can give the tag name, but not a type name.
1581 It seems that no typedef name is defined by outputting a type. */
1583 /* If this typedef name was defined by outputting the type,
1584 don't duplicate it. */
1585 if (typevec
[TYPE_SYMTAB_ADDRESS (type
)] == TYPE_DEFINED
1586 && TYPE_NAME (TREE_TYPE (decl
)) == decl
)
1589 /* Don't output the same typedef twice.
1590 And don't output what language-specific stuff doesn't want output. */
1591 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
1600 if (DECL_NAME (decl
))
1602 /* Nonzero means we must output a tag as well as a typedef. */
1605 /* Handle the case of a C++ structure or union
1606 where the TYPE_NAME is a TYPE_DECL
1607 which gives both a typedef name and a tag. */
1608 /* dbx requires the tag first and the typedef second. */
1609 if ((TREE_CODE (type
) == RECORD_TYPE
1610 || TREE_CODE (type
) == UNION_TYPE
1611 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1612 && TYPE_NAME (type
) == decl
1613 && !(use_gnu_debug_info_extensions
&& have_used_extensions
)
1614 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
1615 /* Distinguish the implicit typedefs of C++
1616 from explicit ones that might be found in C. */
1617 && (!strcmp (lang_identify (), "cplusplus")
1618 /* The following line maybe unnecessary;
1619 in 2.6, try removing it. */
1620 || DECL_SOURCE_LINE (decl
) == 0))
1622 tree name
= TYPE_NAME (type
);
1623 if (TREE_CODE (name
) == TYPE_DECL
)
1624 name
= DECL_NAME (name
);
1626 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1627 current_sym_value
= 0;
1628 current_sym_addr
= 0;
1629 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1631 fprintf (asmfile
, "%s \"%s:T", ASM_STABS_OP
,
1632 IDENTIFIER_POINTER (name
));
1633 dbxout_type (type
, 1, 0);
1634 dbxout_finish_symbol (NULL_TREE
);
1637 /* Output typedef name. */
1638 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
,
1639 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1641 /* Short cut way to output a tag also. */
1642 if ((TREE_CODE (type
) == RECORD_TYPE
1643 || TREE_CODE (type
) == UNION_TYPE
1644 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1645 && TYPE_NAME (type
) == decl
)
1647 if (use_gnu_debug_info_extensions
&& have_used_extensions
)
1649 putc ('T', asmfile
);
1650 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
1652 #if 0 /* Now we generate the tag for this case up above. */
1658 putc ('t', asmfile
);
1659 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1661 dbxout_type (type
, 1, 0);
1662 dbxout_finish_symbol (decl
);
1666 /* Don't output a tag if this is an incomplete type (TYPE_SIZE is
1667 zero). This prevents the sun4 Sun OS 4.x dbx from crashing. */
1669 if (tag_needed
&& TYPE_NAME (type
) != 0 && TYPE_SIZE (type
) != 0
1670 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1672 /* For a TYPE_DECL with no name, but the type has a name,
1674 This is what represents `struct foo' with no typedef. */
1675 /* In C++, the name of a type is the corresponding typedef.
1676 In C, it is an IDENTIFIER_NODE. */
1677 tree name
= TYPE_NAME (type
);
1678 if (TREE_CODE (name
) == TYPE_DECL
)
1679 name
= DECL_NAME (name
);
1681 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1682 current_sym_value
= 0;
1683 current_sym_addr
= 0;
1684 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1686 fprintf (asmfile
, "%s \"%s:T", ASM_STABS_OP
,
1687 IDENTIFIER_POINTER (name
));
1688 dbxout_type (type
, 1, 0);
1689 dbxout_finish_symbol (NULL_TREE
);
1693 /* If an enum type has no name, it cannot be referred to,
1694 but we must output it anyway, since the enumeration constants
1695 can be referred to. */
1696 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
1698 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1699 current_sym_value
= 0;
1700 current_sym_addr
= 0;
1701 current_sym_nchars
= 2;
1703 /* Some debuggers fail when given NULL names, so give this a
1704 harmless name of ` '. */
1705 fprintf (asmfile
, "%s \" :T", ASM_STABS_OP
);
1706 dbxout_type (type
, 1, 0);
1707 dbxout_finish_symbol (NULL_TREE
);
1710 /* Prevent duplicate output of a typedef. */
1711 TREE_ASM_WRITTEN (decl
) = 1;
1716 /* Parm decls go in their own separate chains
1717 and are output by dbxout_reg_parms and dbxout_parms. */
1721 /* Named return value, treat like a VAR_DECL. */
1723 if (DECL_RTL (decl
) == 0)
1725 /* Don't mention a variable that is external.
1726 Let the file that defines it describe it. */
1727 if (DECL_EXTERNAL (decl
))
1730 /* If the variable is really a constant
1731 and not written in memory, inform the debugger. */
1732 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
1733 && DECL_INITIAL (decl
) != 0
1734 && ! TREE_ASM_WRITTEN (decl
)
1735 && (DECL_FIELD_CONTEXT (decl
) == NULL_TREE
1736 || TREE_CODE (DECL_FIELD_CONTEXT (decl
)) == BLOCK
))
1738 if (TREE_PUBLIC (decl
) == 0)
1740 /* The sun4 assembler does not grok this. */
1741 char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1742 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
1743 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
1745 HOST_WIDE_INT ival
= TREE_INT_CST_LOW (DECL_INITIAL (decl
));
1746 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1747 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile
, name
, ival
);
1749 fprintf (asmfile
, "%s \"%s:c=i%d\",0x%x,0,0,0\n",
1750 ASM_STABS_OP
, name
, ival
, N_LSYM
);
1754 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
1756 /* don't know how to do this yet. */
1760 /* else it is something we handle like a normal variable. */
1763 DECL_RTL (decl
) = eliminate_regs (DECL_RTL (decl
), 0, NULL_RTX
);
1764 #ifdef LEAF_REG_REMAP
1766 leaf_renumber_regs_insn (DECL_RTL (decl
));
1769 dbxout_symbol_location (decl
, type
, 0, DECL_RTL (decl
));
1773 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1774 Add SUFFIX to its name, if SUFFIX is not 0.
1775 Describe the variable as residing in HOME
1776 (usually HOME is DECL_RTL (DECL), but not always). */
1779 dbxout_symbol_location (decl
, type
, suffix
, home
)
1787 /* Don't mention a variable at all
1788 if it was completely optimized into nothingness.
1790 If the decl was from an inline function, then it's rtl
1791 is not identically the rtl that was used in this
1792 particular compilation. */
1793 if (GET_CODE (home
) == REG
)
1795 regno
= REGNO (home
);
1796 if (regno
>= FIRST_PSEUDO_REGISTER
)
1799 else if (GET_CODE (home
) == SUBREG
)
1803 while (GET_CODE (value
) == SUBREG
)
1805 offset
+= SUBREG_WORD (value
);
1806 value
= SUBREG_REG (value
);
1808 if (GET_CODE (value
) == REG
)
1810 regno
= REGNO (value
);
1811 if (regno
>= FIRST_PSEUDO_REGISTER
)
1815 alter_subreg (home
);
1818 /* The kind-of-variable letter depends on where
1819 the variable is and on the scope of its name:
1820 G and N_GSYM for static storage and global scope,
1821 S for static storage and file scope,
1822 V for static storage and local scope,
1823 for those two, use N_LCSYM if data is in bss segment,
1824 N_STSYM if in data segment, N_FUN otherwise.
1825 (We used N_FUN originally, then changed to N_STSYM
1826 to please GDB. However, it seems that confused ld.
1827 Now GDB has been fixed to like N_FUN, says Kingdon.)
1828 no letter at all, and N_LSYM, for auto variable,
1829 r and N_RSYM for register variable. */
1831 if (GET_CODE (home
) == MEM
1832 && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
1834 if (TREE_PUBLIC (decl
))
1837 current_sym_code
= N_GSYM
;
1841 current_sym_addr
= XEXP (home
, 0);
1843 letter
= decl_function_context (decl
) ? 'V' : 'S';
1845 if (!DECL_INITIAL (decl
))
1846 current_sym_code
= N_LCSYM
;
1847 else if (DECL_IN_TEXT_SECTION (decl
))
1848 /* This is not quite right, but it's the closest
1849 of all the codes that Unix defines. */
1850 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
1853 /* Ultrix `as' seems to need this. */
1854 #ifdef DBX_STATIC_STAB_DATA_SECTION
1857 current_sym_code
= N_STSYM
;
1861 else if (regno
>= 0)
1864 current_sym_code
= N_RSYM
;
1865 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
1867 else if (GET_CODE (home
) == MEM
1868 && (GET_CODE (XEXP (home
, 0)) == MEM
1869 || (GET_CODE (XEXP (home
, 0)) == REG
1870 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
)))
1871 /* If the value is indirect by memory or by a register
1872 that isn't the frame pointer
1873 then it means the object is variable-sized and address through
1874 that register or stack slot. DBX has no way to represent this
1875 so all we can do is output the variable as a pointer.
1876 If it's not a parameter, ignore it.
1877 (VAR_DECLs like this can be made by integrate.c.) */
1879 if (GET_CODE (XEXP (home
, 0)) == REG
)
1882 current_sym_code
= N_RSYM
;
1883 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
1887 current_sym_code
= N_LSYM
;
1888 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
1889 We want the value of that CONST_INT. */
1891 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
1894 /* Effectively do build_pointer_type, but don't cache this type,
1895 since it might be temporary whereas the type it points to
1896 might have been saved for inlining. */
1897 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
1898 type
= make_node (POINTER_TYPE
);
1899 TREE_TYPE (type
) = TREE_TYPE (decl
);
1901 else if (GET_CODE (home
) == MEM
1902 && GET_CODE (XEXP (home
, 0)) == REG
)
1904 current_sym_code
= N_LSYM
;
1905 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
1907 else if (GET_CODE (home
) == MEM
1908 && GET_CODE (XEXP (home
, 0)) == PLUS
1909 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
1911 current_sym_code
= N_LSYM
;
1912 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
1913 We want the value of that CONST_INT. */
1914 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
1916 else if (GET_CODE (home
) == MEM
1917 && GET_CODE (XEXP (home
, 0)) == CONST
)
1919 /* Handle an obscure case which can arise when optimizing and
1920 when there are few available registers. (This is *always*
1921 the case for i386/i486 targets). The RTL looks like
1922 (MEM (CONST ...)) even though this variable is a local `auto'
1923 or a local `register' variable. In effect, what has happened
1924 is that the reload pass has seen that all assignments and
1925 references for one such a local variable can be replaced by
1926 equivalent assignments and references to some static storage
1927 variable, thereby avoiding the need for a register. In such
1928 cases we're forced to lie to debuggers and tell them that
1929 this variable was itself `static'. */
1930 current_sym_code
= N_LCSYM
;
1932 current_sym_addr
= XEXP (XEXP (home
, 0), 0);
1934 else if (GET_CODE (home
) == CONCAT
)
1936 tree subtype
= TREE_TYPE (type
);
1938 /* If the variable's storage is in two parts,
1939 output each as a separate stab with a modified name. */
1940 if (WORDS_BIG_ENDIAN
)
1941 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
1943 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
1945 /* Cast avoids warning in old compilers. */
1946 current_sym_code
= (STAB_CODE_TYPE
) 0;
1947 current_sym_value
= 0;
1948 current_sym_addr
= 0;
1949 dbxout_prepare_symbol (decl
);
1951 if (WORDS_BIG_ENDIAN
)
1952 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
1954 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
1958 /* Address might be a MEM, when DECL is a variable-sized object.
1959 Or it might be const0_rtx, meaning previous passes
1960 want us to ignore this variable. */
1963 /* Ok, start a symtab entry and output the variable name. */
1966 #ifdef DBX_STATIC_BLOCK_START
1967 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
1970 dbxout_symbol_name (decl
, suffix
, letter
);
1971 dbxout_type (type
, 0, 0);
1972 dbxout_finish_symbol (decl
);
1974 #ifdef DBX_STATIC_BLOCK_END
1975 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
1979 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
1980 Then output LETTER to indicate the kind of location the symbol has. */
1983 dbxout_symbol_name (decl
, suffix
, letter
)
1988 /* One slight hitch: if this is a VAR_DECL which is a static
1989 class member, we must put out the mangled name instead of the
1993 /* Note also that static member (variable) names DO NOT begin
1994 with underscores in .stabs directives. */
1995 if (DECL_LANG_SPECIFIC (decl
))
1996 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
1998 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
2001 fprintf (asmfile
, "%s \"%s%s:", ASM_STABS_OP
, name
,
2002 (suffix
? suffix
: ""));
2004 if (letter
) putc (letter
, asmfile
);
2008 dbxout_prepare_symbol (decl
)
2012 char *filename
= DECL_SOURCE_FILE (decl
);
2014 dbxout_source_file (asmfile
, filename
);
2019 dbxout_finish_symbol (sym
)
2022 #ifdef DBX_FINISH_SYMBOL
2023 DBX_FINISH_SYMBOL (sym
);
2026 if (use_gnu_debug_info_extensions
&& sym
!= 0)
2027 line
= DECL_SOURCE_LINE (sym
);
2029 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
2030 if (current_sym_addr
)
2031 output_addr_const (asmfile
, current_sym_addr
);
2033 fprintf (asmfile
, "%d", current_sym_value
);
2034 putc ('\n', asmfile
);
2038 /* Output definitions of all the decls in a chain. */
2046 dbxout_symbol (syms
, 1);
2047 syms
= TREE_CHAIN (syms
);
2051 /* The following two functions output definitions of function parameters.
2052 Each parameter gets a definition locating it in the parameter list.
2053 Each parameter that is a register variable gets a second definition
2054 locating it in the register.
2056 Printing or argument lists in gdb uses the definitions that
2057 locate in the parameter list. But reference to the variable in
2058 expressions uses preferentially the definition as a register. */
2060 /* Output definitions, referring to storage in the parmlist,
2061 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2064 dbxout_parms (parms
)
2067 for (; parms
; parms
= TREE_CHAIN (parms
))
2068 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
2070 dbxout_prepare_symbol (parms
);
2072 /* Perform any necessary register eliminations on the parameter's rtl,
2073 so that the debugging output will be accurate. */
2074 DECL_INCOMING_RTL (parms
)
2075 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
2076 DECL_RTL (parms
) = eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
);
2077 #ifdef LEAF_REG_REMAP
2080 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
2081 leaf_renumber_regs_insn (DECL_RTL (parms
));
2085 if (PARM_PASSED_IN_MEMORY (parms
))
2087 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
2089 /* ??? Here we assume that the parm address is indexed
2090 off the frame pointer or arg pointer.
2091 If that is not true, we produce meaningless results,
2092 but do not crash. */
2093 if (GET_CODE (addr
) == PLUS
2094 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
2095 current_sym_value
= INTVAL (XEXP (addr
, 1));
2097 current_sym_value
= 0;
2099 current_sym_code
= N_PSYM
;
2100 current_sym_addr
= 0;
2103 if (DECL_NAME (parms
))
2105 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2107 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2108 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2109 DBX_MEMPARM_STABS_LETTER
);
2113 current_sym_nchars
= 8;
2114 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2115 DBX_MEMPARM_STABS_LETTER
);
2118 if (GET_CODE (DECL_RTL (parms
)) == REG
2119 && REGNO (DECL_RTL (parms
)) >= 0
2120 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2121 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
2124 int original_value
= current_sym_value
;
2126 /* This is the case where the parm is passed as an int or double
2127 and it is converted to a char, short or float and stored back
2128 in the parmlist. In this case, describe the parm
2129 with the variable's declared type, and adjust the address
2130 if the least significant bytes (which we are using) are not
2132 #if BYTES_BIG_ENDIAN
2133 if (TREE_TYPE (parms
) != DECL_ARG_TYPE (parms
))
2134 current_sym_value
+= (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms
)))
2135 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
))));
2138 if (GET_CODE (DECL_RTL (parms
)) == MEM
2139 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == PLUS
2140 && GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == CONST_INT
2141 && INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == current_sym_value
)
2142 dbxout_type (TREE_TYPE (parms
), 0, 0);
2145 current_sym_value
= original_value
;
2146 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
2149 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
2150 dbxout_finish_symbol (parms
);
2152 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
2155 char regparm_letter
;
2157 /* Parm passed in registers and lives in registers or nowhere. */
2159 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2160 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2161 current_sym_addr
= 0;
2163 /* If parm lives in a register, use that register;
2164 pretend the parm was passed there. It would be more consistent
2165 to describe the register where the parm was passed,
2166 but in practice that register usually holds something else.
2168 If we use DECL_RTL, then we must use the declared type of
2169 the variable, not the type that it arrived in. */
2170 if (REGNO (DECL_RTL (parms
)) >= 0
2171 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2173 best_rtl
= DECL_RTL (parms
);
2174 parm_type
= TREE_TYPE (parms
);
2176 /* If the parm lives nowhere, use the register where it was
2177 passed. It is also better to use the declared type here. */
2180 best_rtl
= DECL_INCOMING_RTL (parms
);
2181 parm_type
= TREE_TYPE (parms
);
2183 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
2186 if (DECL_NAME (parms
))
2188 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2189 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2190 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2195 current_sym_nchars
= 8;
2196 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2200 dbxout_type (parm_type
, 0, 0);
2201 dbxout_finish_symbol (parms
);
2203 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2204 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
2205 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
2206 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
2207 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2208 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
2212 /* Parm was passed via invisible reference.
2213 That is, its address was passed in a register.
2214 Output it as if it lived in that register.
2215 The debugger will know from the type
2216 that it was actually passed by invisible reference. */
2218 char regparm_letter
;
2219 /* Parm passed in registers and lives in registers or nowhere. */
2221 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2222 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2224 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2225 If it is an unallocated pseudo-reg, then use the register where
2226 it was passed instead. */
2227 if (REGNO (XEXP (DECL_RTL (parms
), 0)) >= 0
2228 && REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
2229 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
2231 current_sym_value
= REGNO (DECL_INCOMING_RTL (parms
));
2233 current_sym_addr
= 0;
2236 if (DECL_NAME (parms
))
2238 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2240 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2241 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2242 DBX_REGPARM_STABS_LETTER
);
2246 current_sym_nchars
= 8;
2247 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2248 DBX_REGPARM_STABS_LETTER
);
2251 dbxout_type (TREE_TYPE (parms
), 0, 0);
2252 dbxout_finish_symbol (parms
);
2254 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2255 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
2256 /* ??? A constant address for a parm can happen
2257 when the reg it lives in is equiv to a constant in memory.
2258 Should make this not happen, after 2.4. */
2259 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
2261 /* Parm was passed in registers but lives on the stack. */
2263 current_sym_code
= N_PSYM
;
2264 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2265 in which case we want the value of that CONST_INT,
2266 or (MEM (REG ...)) or (MEM (MEM ...)),
2267 in which case we use a value of zero. */
2268 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
2269 || GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
2270 current_sym_value
= 0;
2272 current_sym_value
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
2273 current_sym_addr
= 0;
2276 if (DECL_NAME (parms
))
2278 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2280 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2281 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2282 DBX_MEMPARM_STABS_LETTER
);
2286 current_sym_nchars
= 8;
2287 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2288 DBX_MEMPARM_STABS_LETTER
);
2292 = DEBUGGER_ARG_OFFSET (current_sym_value
,
2293 XEXP (DECL_RTL (parms
), 0));
2294 dbxout_type (TREE_TYPE (parms
), 0, 0);
2295 dbxout_finish_symbol (parms
);
2300 /* Output definitions for the places where parms live during the function,
2301 when different from where they were passed, when the parms were passed
2304 It is not useful to do this for parms passed in registers
2305 that live during the function in different registers, because it is
2306 impossible to look in the passed register for the passed value,
2307 so we use the within-the-function register to begin with.
2309 PARMS is a chain of PARM_DECL nodes. */
2312 dbxout_reg_parms (parms
)
2315 for (; parms
; parms
= TREE_CHAIN (parms
))
2316 if (DECL_NAME (parms
))
2318 dbxout_prepare_symbol (parms
);
2320 /* Report parms that live in registers during the function
2321 but were passed in memory. */
2322 if (GET_CODE (DECL_RTL (parms
)) == REG
2323 && REGNO (DECL_RTL (parms
)) >= 0
2324 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
2325 && PARM_PASSED_IN_MEMORY (parms
))
2326 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2327 0, DECL_RTL (parms
));
2328 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
2329 && PARM_PASSED_IN_MEMORY (parms
))
2330 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2331 0, DECL_RTL (parms
));
2332 /* Report parms that live in memory but not where they were passed. */
2333 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2334 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == PLUS
2335 && GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == CONST_INT
2336 && PARM_PASSED_IN_MEMORY (parms
)
2337 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
2339 #if 0 /* ??? It is not clear yet what should replace this. */
2340 int offset
= DECL_OFFSET (parms
) / BITS_PER_UNIT
;
2341 /* A parm declared char is really passed as an int,
2342 so it occupies the least significant bytes.
2343 On a big-endian machine those are not the low-numbered ones. */
2344 #if BYTES_BIG_ENDIAN
2345 if (offset
!= -1 && TREE_TYPE (parms
) != DECL_ARG_TYPE (parms
))
2346 offset
+= (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms
)))
2347 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
))));
2349 if (INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) != offset
) {...}
2351 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2352 0, DECL_RTL (parms
));
2355 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2356 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
)
2358 /* Parm was passed via invisible reference.
2359 That is, its address was passed in a register.
2360 Output it as if it lived in that register.
2361 The debugger will know from the type
2362 that it was actually passed by invisible reference. */
2364 current_sym_code
= N_RSYM
;
2366 /* DECL_RTL looks like (MEM (REG...). Get the register number. */
2367 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
2368 current_sym_addr
= 0;
2371 if (DECL_NAME (parms
))
2373 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2375 fprintf (asmfile
, "%s \"%s:r", ASM_STABS_OP
,
2376 IDENTIFIER_POINTER (DECL_NAME (parms
)));
2380 current_sym_nchars
= 8;
2381 fprintf (asmfile
, "%s \"(anon):r", ASM_STABS_OP
);
2384 dbxout_type (TREE_TYPE (parms
), 0, 0);
2385 dbxout_finish_symbol (parms
);
2391 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2392 output definitions of those names, in raw form */
2400 putc (',', asmfile
);
2401 dbxout_type (TREE_VALUE (args
), 0, 0);
2403 args
= TREE_CHAIN (args
);
2407 /* Given a chain of ..._TYPE nodes,
2408 find those which have typedef names and output those names.
2409 This is to ensure those types get output. */
2412 dbxout_types (types
)
2413 register tree types
;
2417 if (TYPE_NAME (types
)
2418 && TREE_CODE (TYPE_NAME (types
)) == TYPE_DECL
2419 && ! TREE_ASM_WRITTEN (TYPE_NAME (types
)))
2420 dbxout_symbol (TYPE_NAME (types
), 1);
2421 types
= TREE_CHAIN (types
);
2425 /* Output everything about a symbol block (a BLOCK node
2426 that represents a scope level),
2427 including recursive output of contained blocks.
2429 BLOCK is the BLOCK node.
2430 DEPTH is its depth within containing symbol blocks.
2431 ARGS is usually zero; but for the outermost block of the
2432 body of a function, it is a chain of PARM_DECLs for the function parameters.
2433 We output definitions of all the register parms
2434 as if they were local variables of that block.
2436 If -g1 was used, we count blocks just the same, but output nothing
2437 except for the outermost block.
2439 Actually, BLOCK may be several blocks chained together.
2440 We handle them all in sequence. */
2443 dbxout_block (block
, depth
, args
)
2444 register tree block
;
2452 /* Ignore blocks never expanded or otherwise marked as real. */
2453 if (TREE_USED (block
))
2455 #ifndef DBX_LBRAC_FIRST
2456 /* In dbx format, the syms of a block come before the N_LBRAC. */
2457 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2458 dbxout_syms (BLOCK_VARS (block
));
2460 dbxout_reg_parms (args
);
2463 /* Now output an N_LBRAC symbol to represent the beginning of
2464 the block. Use the block's tree-walk order to generate
2465 the assembler symbols LBBn and LBEn
2466 that final will define around the code in this block. */
2467 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2470 blocknum
= next_block_number
++;
2471 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
2473 if (BLOCK_HANDLER_BLOCK (block
))
2475 /* A catch block. Must precede N_LBRAC. */
2476 tree decl
= BLOCK_VARS (block
);
2479 #ifdef DBX_OUTPUT_CATCH
2480 DBX_OUTPUT_CATCH (asmfile
, decl
, buf
);
2482 fprintf (asmfile
, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP
,
2483 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
2484 assemble_name (asmfile
, buf
);
2485 fprintf (asmfile
, "\n");
2487 decl
= TREE_CHAIN (decl
);
2491 #ifdef DBX_OUTPUT_LBRAC
2492 DBX_OUTPUT_LBRAC (asmfile
, buf
);
2494 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_LBRAC
);
2495 assemble_name (asmfile
, buf
);
2496 #if DBX_BLOCKS_FUNCTION_RELATIVE
2497 fputc ('-', asmfile
);
2498 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
2500 fprintf (asmfile
, "\n");
2504 /* Count blocks the same way regardless of debug_info_level. */
2505 next_block_number
++;
2507 #ifdef DBX_LBRAC_FIRST
2508 /* On some weird machines, the syms of a block
2509 come after the N_LBRAC. */
2510 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2511 dbxout_syms (BLOCK_VARS (block
));
2513 dbxout_reg_parms (args
);
2516 /* Output the subblocks. */
2517 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
2519 /* Refer to the marker for the end of the block. */
2520 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2523 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
2524 #ifdef DBX_OUTPUT_RBRAC
2525 DBX_OUTPUT_RBRAC (asmfile
, buf
);
2527 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_RBRAC
);
2528 assemble_name (asmfile
, buf
);
2529 #if DBX_BLOCKS_FUNCTION_RELATIVE
2530 fputc ('-', asmfile
);
2531 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
2533 fprintf (asmfile
, "\n");
2537 block
= BLOCK_CHAIN (block
);
2541 /* Output the information about a function and its arguments and result.
2542 Usually this follows the function's code,
2543 but on some systems, it comes before. */
2546 dbxout_really_begin_function (decl
)
2549 dbxout_symbol (decl
, 0);
2550 dbxout_parms (DECL_ARGUMENTS (decl
));
2551 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
2552 dbxout_symbol (DECL_RESULT (decl
), 1);
2555 /* Called at beginning of output of function definition. */
2558 dbxout_begin_function (decl
)
2561 #ifdef DBX_FUNCTION_FIRST
2562 dbxout_really_begin_function (decl
);
2566 /* Output dbx data for a function definition.
2567 This includes a definition of the function name itself (a symbol),
2568 definitions of the parameters (locating them in the parameter list)
2569 and then output the block that makes up the function's body
2570 (including all the auto variables of the function). */
2573 dbxout_function (decl
)
2576 #ifndef DBX_FUNCTION_FIRST
2577 dbxout_really_begin_function (decl
);
2579 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
2580 #ifdef DBX_OUTPUT_FUNCTION_END
2581 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
2584 #endif /* DBX_DEBUGGING_INFO */