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"
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;
137 /* Typical USG systems don't have stab.h, and they also have
138 no use for DBX-format debugging info. */
140 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
142 #ifdef DEBUG_SYMS_TEXT
143 #define FORCE_TEXT text_section ();
148 #if defined (USG) || defined (NO_STAB_H)
149 #include "gstab.h" /* If doing DBX on sysV, use our own stab.h. */
151 #include <stab.h> /* On BSD, use the system's stab.h. */
153 /* This is a GNU extension we need to reference in this file. */
160 #define STAB_CODE_TYPE enum __stab_debug_code
162 #define STAB_CODE_TYPE int
165 /* 1 if PARM is passed to this function in memory. */
167 #define PARM_PASSED_IN_MEMORY(PARM) \
168 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
170 /* A C expression for the integer offset value of an automatic variable
171 (N_LSYM) having address X (an RTX). */
172 #ifndef DEBUGGER_AUTO_OFFSET
173 #define DEBUGGER_AUTO_OFFSET(X) \
174 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
177 /* A C expression for the integer offset value of an argument (N_PSYM)
178 having address X (an RTX). The nominal offset is OFFSET. */
179 #ifndef DEBUGGER_ARG_OFFSET
180 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
183 /* Stream for writing to assembler file. */
185 static FILE *asmfile
;
187 /* Last source file name mentioned in a NOTE insn. */
189 static char *lastfile
;
191 /* Current working directory. */
195 enum typestatus
{TYPE_UNSEEN
, TYPE_XREF
, TYPE_DEFINED
};
197 /* Vector recording the status of describing C data types.
198 When we first notice a data type (a tree node),
199 we assign it a number using next_type_number.
200 That is its index in this vector.
201 The vector element says whether we have yet output
202 the definition of the type. TYPE_XREF says we have
203 output it as a cross-reference only. */
205 enum typestatus
*typevec
;
207 /* Number of elements of space allocated in `typevec'. */
209 static int typevec_len
;
211 /* In dbx output, each type gets a unique number.
212 This is the number for the next type output.
213 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
215 static int next_type_number
;
217 /* In dbx output, we must assign symbol-blocks id numbers
218 in the order in which their beginnings are encountered.
219 We output debugging info that refers to the beginning and
220 end of the ranges of code in each block
221 with assembler labels LBBn and LBEn, where n is the block number.
222 The labels are generated in final, which assigns numbers to the
223 blocks in the same way. */
225 static int next_block_number
;
227 /* These variables are for dbxout_symbol to communicate to
228 dbxout_finish_symbol.
229 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
230 current_sym_value and current_sym_addr are two ways to address the
231 value to store in the symtab entry.
232 current_sym_addr if nonzero represents the value as an rtx.
233 If that is zero, current_sym_value is used. This is used
234 when the value is an offset (such as for auto variables,
235 register variables and parms). */
237 static STAB_CODE_TYPE current_sym_code
;
238 static int current_sym_value
;
239 static rtx current_sym_addr
;
241 /* Number of chars of symbol-description generated so far for the
242 current symbol. Used by CHARS and CONTIN. */
244 static int current_sym_nchars
;
246 /* Report having output N chars of the current symbol-description. */
248 #define CHARS(N) (current_sym_nchars += (N))
250 /* Break the current symbol-description, generating a continuation,
251 if it has become long. */
253 #ifndef DBX_CONTIN_LENGTH
254 #define DBX_CONTIN_LENGTH 80
257 #if DBX_CONTIN_LENGTH > 0
259 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
264 void dbxout_types ();
266 void dbxout_symbol ();
267 static void dbxout_type_name ();
268 static void dbxout_type ();
269 static void dbxout_typedefs ();
270 static void dbxout_symbol_name ();
271 static void dbxout_symbol_location ();
272 static void dbxout_prepare_symbol ();
273 static void dbxout_finish_symbol ();
274 static void dbxout_continue ();
275 static void print_int_cst_octal ();
276 static void print_octal ();
278 #if 0 /* Not clear we will actually need this. */
280 /* Return the absolutized filename for the given relative
281 filename. Note that if that filename is already absolute, it may
282 still be returned in a modified form because this routine also
283 eliminates redundant slashes and single dots and eliminates double
284 dots to get a shortest possible filename from the given input
285 filename. The absolutization of relative filenames is made by
286 assuming that the given filename is to be taken as relative to
287 the first argument (cwd) or to the current directory if cwd is
291 abspath (rel_filename
)
294 /* Setup the current working directory as needed. */
296 = (char *) alloca (strlen (cwd
) + strlen (rel_filename
) + 1);
297 char *endp
= abs_buffer
;
301 /* Copy the filename (possibly preceded by the current working
302 directory name) into the absolutization buffer. */
307 if (rel_filename
[0] != '/')
310 while (*endp
++ = *src_p
++)
312 *(endp
-1) = '/'; /* overwrite null */
314 src_p
= rel_filename
;
315 while (*endp
++ = *src_p
++)
320 /* Now make a copy of abs_buffer into abs_buffer, shortening the
321 filename (by taking out slashes and dots) as we go. */
323 outp
= inp
= abs_buffer
;
324 *outp
++ = *inp
++; /* copy first slash */
329 else if (inp
[0] == '/' && outp
[-1] == '/')
334 else if (inp
[0] == '.' && outp
[-1] == '/')
338 else if (inp
[1] == '/')
343 else if ((inp
[1] == '.') && (inp
[2] == 0 || inp
[2] == '/'))
345 inp
+= (inp
[2] == '/') ? 3 : 2;
347 while (outp
>= abs_buffer
&& *outp
!= '/')
349 if (outp
< abs_buffer
)
351 /* Catch cases like /.. where we try to backup to a
352 point above the absolute root of the logical file
355 fprintf (stderr
, "%s: invalid file name: %s\n",
356 pname
, rel_filename
);
366 /* On exit, make sure that there is a trailing null, and make sure that
367 the last character of the returned string is *not* a slash. */
373 /* Make a copy (in the heap) of the stuff left in the absolutization
374 buffer and return a pointer to the copy. */
376 value
= (char *) oballoc (strlen (abs_buffer
) + 1);
377 strcpy (value
, abs_buffer
);
382 /* At the beginning of compilation, start writing the symbol table.
383 Initialize `typevec' and output the standard data types of C. */
386 dbxout_init (asm_file
, input_file_name
, syms
)
388 char *input_file_name
;
391 char ltext_label_name
[100];
396 typevec
= (enum typestatus
*) xmalloc (typevec_len
* sizeof typevec
[0]);
397 bzero (typevec
, typevec_len
* sizeof typevec
[0]);
399 /* Convert Ltext into the appropriate format for local labels in case
400 the system doesn't insert underscores in front of user generated
402 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
404 /* Put the current working directory in an N_SO symbol. */
405 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
406 but GDB always does. */
407 if (use_gnu_debug_info_extensions
)
410 if (!cwd
&& (cwd
= getpwd ()) && (!*cwd
|| cwd
[strlen (cwd
) - 1] != '/'))
412 char *wdslash
= xmalloc (strlen (cwd
) + sizeof (FILE_NAME_JOINER
));
413 sprintf (wdslash
, "%s%s", cwd
, FILE_NAME_JOINER
);
418 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
419 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile
, cwd
);
420 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
421 fprintf (asmfile
, "%s ", ASM_STABS_OP
);
422 output_quoted_string (asmfile
, cwd
);
423 fprintf (asmfile
, ",%d,0,0,%s\n", N_SO
, <ext_label_name
[1]);
424 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
428 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
429 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
430 would give us an N_SOL, and we want an N_SO. */
431 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile
, input_file_name
);
432 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
433 /* We include outputting `Ltext:' here,
434 because that gives you a way to override it. */
435 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
436 fprintf (asmfile
, "%s ", ASM_STABS_OP
);
437 output_quoted_string (asmfile
, input_file_name
);
438 fprintf (asmfile
, ",%d,0,0,%s\n",
439 N_SO
, <ext_label_name
[1]);
441 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Ltext", 0);
442 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
444 /* Possibly output something to inform GDB that this compilation was by
445 GCC. It's easier for GDB to parse it when after the N_SO's. This
446 is used in Solaris 2. */
447 #ifdef ASM_IDENTIFY_GCC_AFTER_SOURCE
448 ASM_IDENTIFY_GCC_AFTER_SOURCE (asmfile
);
451 lastfile
= input_file_name
;
453 next_type_number
= 1;
454 next_block_number
= 2;
456 /* Make sure that types `int' and `char' have numbers 1 and 2.
457 Definitions of other integer types will refer to those numbers.
458 (Actually it should no longer matter what their numbers are.
459 Also, if any types with tags have been defined, dbxout_symbol
460 will output them first, so the numbers won't be 1 and 2. That
461 happens in C++. So it's a good thing it should no longer matter). */
463 #ifdef DBX_OUTPUT_STANDARD_TYPES
464 DBX_OUTPUT_STANDARD_TYPES (syms
);
466 dbxout_symbol (TYPE_NAME (integer_type_node
), 0);
467 dbxout_symbol (TYPE_NAME (char_type_node
), 0);
470 /* Get all permanent types that have typedef names,
471 and output them all, except for those already output. */
473 dbxout_typedefs (syms
);
476 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
477 in the reverse order from that which is found in SYMS. */
480 dbxout_typedefs (syms
)
485 dbxout_typedefs (TREE_CHAIN (syms
));
486 if (TREE_CODE (syms
) == TYPE_DECL
)
488 tree type
= TREE_TYPE (syms
);
490 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
491 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
492 dbxout_symbol (TYPE_NAME (type
), 0);
497 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
500 dbxout_source_file (file
, filename
)
504 char ltext_label_name
[100];
506 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
508 #ifdef DBX_OUTPUT_SOURCE_FILENAME
509 DBX_OUTPUT_SOURCE_FILENAME (file
, filename
);
511 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
512 fprintf (file
, "%s ", ASM_STABS_OP
);
513 output_quoted_string (file
, filename
);
514 fprintf (file
, ",%d,0,0,%s\n", N_SOL
, <ext_label_name
[1]);
520 /* Output a line number symbol entry into output stream FILE,
521 for source file FILENAME and line number LINENO. */
524 dbxout_source_line (file
, filename
, lineno
)
529 dbxout_source_file (file
, filename
);
531 #ifdef ASM_OUTPUT_SOURCE_LINE
532 ASM_OUTPUT_SOURCE_LINE (file
, lineno
);
534 fprintf (file
, "\t%s %d,0,%d\n", ASM_STABD_OP
, N_SLINE
, lineno
);
538 /* At the end of compilation, finish writing the symbol table.
539 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
543 dbxout_finish (file
, filename
)
547 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
548 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file
, filename
);
549 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
552 /* Continue a symbol-description that gets too big.
553 End one symbol table entry with a double-backslash
554 and start a new one, eventually producing something like
555 .stabs "start......\\",code,0,value
556 .stabs "...rest",code,0,value */
561 #ifdef DBX_CONTIN_CHAR
562 fprintf (asmfile
, "%c", DBX_CONTIN_CHAR
);
564 fprintf (asmfile
, "\\\\");
566 dbxout_finish_symbol (NULL_TREE
);
567 fprintf (asmfile
, "%s \"", ASM_STABS_OP
);
568 current_sym_nchars
= 0;
571 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
572 This must be a separate function because anonymous unions require
576 dbxout_type_fields (type
)
580 /* Output the name, type, position (in bits), size (in bits) of each
582 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
584 /* For nameless subunions and subrecords, treat their fields as ours. */
585 if (DECL_NAME (tem
) == NULL_TREE
586 && (TREE_CODE (TREE_TYPE (tem
)) == UNION_TYPE
587 || TREE_CODE (TREE_TYPE (tem
)) == QUAL_UNION_TYPE
588 || TREE_CODE (TREE_TYPE (tem
)) == RECORD_TYPE
))
589 dbxout_type_fields (TREE_TYPE (tem
));
590 /* Omit here local type decls until we know how to support them. */
591 else if (TREE_CODE (tem
) == TYPE_DECL
)
593 /* Omit here the nameless fields that are used to skip bits. */
594 else if (DECL_NAME (tem
) != 0 && TREE_CODE (tem
) != CONST_DECL
)
596 /* Continue the line if necessary,
597 but not before the first field. */
598 if (tem
!= TYPE_FIELDS (type
))
601 if (use_gnu_debug_info_extensions
602 && flag_minimal_debug
603 && TREE_CODE (tem
) == FIELD_DECL
604 && DECL_VIRTUAL_P (tem
)
605 && DECL_ASSEMBLER_NAME (tem
))
607 have_used_extensions
= 1;
608 CHARS (3 + IDENTIFIER_LENGTH (DECL_NAME (TYPE_NAME (DECL_FCONTEXT (tem
)))));
609 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
)), asmfile
);
610 dbxout_type (DECL_FCONTEXT (tem
), 0, 0);
611 fprintf (asmfile
, ":");
612 dbxout_type (TREE_TYPE (tem
), 0, 0);
613 fprintf (asmfile
, ",%d;",
614 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem
)));
618 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem
)));
619 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem
)));
621 if (use_gnu_debug_info_extensions
622 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
623 || TREE_CODE (tem
) != FIELD_DECL
))
625 have_used_extensions
= 1;
627 putc ((TREE_PRIVATE (tem
) ? '0'
628 : TREE_PROTECTED (tem
) ? '1' : '2'),
633 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
634 && DECL_BIT_FIELD_TYPE (tem
))
635 ? DECL_BIT_FIELD_TYPE (tem
)
636 : TREE_TYPE (tem
), 0, 0);
638 if (TREE_CODE (tem
) == VAR_DECL
)
640 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
642 char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
));
643 have_used_extensions
= 1;
644 fprintf (asmfile
, ":%s;", name
);
645 CHARS (strlen (name
));
649 /* If TEM is non-static, GDB won't understand it. */
650 fprintf (asmfile
, ",0,0;");
653 else if (TREE_CODE (DECL_FIELD_BITPOS (tem
)) == INTEGER_CST
)
655 fprintf (asmfile
, ",%d,%d;",
656 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem
)),
657 TREE_INT_CST_LOW (DECL_SIZE (tem
)));
660 /* This has yet to be implemented. */
667 /* Subroutine of `dbxout_type_methods'. Output debug info about the
668 method described DECL. DEBUG_NAME is an encoding of the method's
669 type signature. ??? We may be able to do without DEBUG_NAME altogether
673 dbxout_type_method_1 (decl
, debug_name
)
677 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
680 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
682 else /* it's a METHOD_TYPE. */
684 /* A for normal functions.
685 B for `const' member functions.
686 C for `volatile' member functions.
687 D for `const volatile' member functions. */
688 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
690 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
693 if (DECL_VINDEX (decl
))
699 fprintf (asmfile
, ":%s;%c%c%c", debug_name
,
700 TREE_PRIVATE (decl
) ? '0' : TREE_PROTECTED (decl
) ? '1' : '2', c1
, c2
);
701 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
)) + 6
702 - (debug_name
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
703 if (DECL_VINDEX (decl
))
705 fprintf (asmfile
, "%d;",
706 TREE_INT_CST_LOW (DECL_VINDEX (decl
)));
707 dbxout_type (DECL_CONTEXT (decl
), 0, 0);
708 fprintf (asmfile
, ";");
713 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
717 dbxout_type_methods (type
)
720 /* C++: put out the method names and their parameter lists */
721 tree methods
= TYPE_METHODS (type
);
723 register tree fndecl
;
725 char formatted_type_identifier_length
[16];
726 register int type_identifier_length
;
728 if (methods
== NULL_TREE
)
731 type_encoding
= DECL_NAME (TYPE_NAME (type
));
733 /* C++: Template classes break some assumptions made by this code about
734 the class names, constructor names, and encodings for assembler
735 label names. For now, disable output of dbx info for them. */
737 char *ptr
= IDENTIFIER_POINTER (type_encoding
);
738 /* This should use index. (mrs) */
739 while (*ptr
&& *ptr
!= '<') ptr
++;
746 #ifdef HAVE_TEMPLATES
747 if (warn_template_debugging
)
748 warning ("dbx info for template class methods not yet supported");
755 type_identifier_length
= IDENTIFIER_LENGTH (type_encoding
);
757 sprintf(formatted_type_identifier_length
, "%d", type_identifier_length
);
759 if (TREE_CODE (methods
) == FUNCTION_DECL
)
761 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
762 fndecl
= TREE_VEC_ELT (methods
, 0);
764 fndecl
= TREE_VEC_ELT (methods
, 1);
768 tree name
= DECL_NAME (fndecl
);
771 /* Group together all the methods for the same operation.
772 These differ in the types of the arguments. */
773 for (last
= NULL_TREE
;
774 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
775 fndecl
= TREE_CHAIN (fndecl
))
776 /* Output the name of the field (after overloading), as
777 well as the name of the field before overloading, along
778 with its parameter list */
780 /* This is the "mangled" name of the method.
781 It encodes the argument types. */
782 char *debug_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
));
789 if (DECL_IGNORED_P (fndecl
))
792 if (flag_minimal_debug
)
794 /* Detect ordinary methods because their mangled names
795 start with the operation name. */
796 if (!strncmp (IDENTIFIER_POINTER (name
), debug_name
,
797 IDENTIFIER_LENGTH (name
)))
799 debug_name
+= IDENTIFIER_LENGTH (name
);
800 if (debug_name
[0] == '_' && debug_name
[1] == '_')
802 char *method_name
= debug_name
+ 2;
803 char *length_ptr
= formatted_type_identifier_length
;
804 /* Get past const and volatile qualifiers. */
805 while (*method_name
== 'C' || *method_name
== 'V')
807 /* Skip digits for length of type_encoding. */
808 while (*method_name
== *length_ptr
&& *length_ptr
)
809 length_ptr
++, method_name
++;
810 if (! strncmp (method_name
,
811 IDENTIFIER_POINTER (type_encoding
),
812 type_identifier_length
))
813 method_name
+= type_identifier_length
;
814 debug_name
= method_name
;
817 /* Detect constructors by their style of name mangling. */
818 else if (debug_name
[0] == '_' && debug_name
[1] == '_')
820 char *ctor_name
= debug_name
+ 2;
821 char *length_ptr
= formatted_type_identifier_length
;
822 while (*ctor_name
== 'C' || *ctor_name
== 'V')
824 /* Skip digits for length of type_encoding. */
825 while (*ctor_name
== *length_ptr
&& *length_ptr
)
826 length_ptr
++, ctor_name
++;
827 if (!strncmp (IDENTIFIER_POINTER (type_encoding
), ctor_name
,
828 type_identifier_length
))
829 debug_name
= ctor_name
+ type_identifier_length
;
831 /* The other alternative is a destructor. */
835 /* Output the operation name just once, for the first method
839 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (name
));
840 CHARS (IDENTIFIER_LENGTH (name
) + 2);
845 dbxout_type (TREE_TYPE (fndecl
), 0, destructor
);
847 dbxout_type_method_1 (fndecl
, debug_name
);
857 /* Emit a "range" type specification, which has the form:
858 "r<index type>;<lower bound>;<upper bound>;".
859 TYPE is an INTEGER_TYPE. */
862 dbxout_range_type (type
)
865 fprintf (asmfile
, "r");
866 if (TREE_TYPE (type
) && TREE_CODE (TREE_TYPE(type
)) != INTEGER_TYPE
)
867 dbxout_type (TREE_TYPE (type
), 0, 0);
870 /* This used to say `r1' and we used to take care
871 to make sure that `int' was type number 1. */
872 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (integer_type_node
));
874 if (TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
)
875 fprintf (asmfile
, ";%d",
876 TREE_INT_CST_LOW (TYPE_MIN_VALUE (type
)));
878 fprintf (asmfile
, ";0");
879 if (TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
)
880 fprintf (asmfile
, ";%d;",
881 TREE_INT_CST_LOW (TYPE_MAX_VALUE (type
)));
883 fprintf (asmfile
, ";-1;");
886 /* Output a reference to a type. If the type has not yet been
887 described in the dbx output, output its definition now.
888 For a type already defined, just refer to its definition
889 using the type number.
891 If FULL is nonzero, and the type has been described only with
892 a forward-reference, output the definition now.
893 If FULL is zero in this case, just refer to the forward-reference
894 using the number previously allocated.
896 If SHOW_ARG_TYPES is nonzero, we output a description of the argument
897 types for a METHOD_TYPE. */
900 dbxout_type (type
, full
, show_arg_types
)
906 static int anonymous_type_number
= 0;
908 /* If there was an input error and we don't really have a type,
909 avoid crashing and write something that is at least valid
910 by assuming `int'. */
911 if (type
== error_mark_node
)
912 type
= integer_type_node
;
915 type
= TYPE_MAIN_VARIANT (type
);
917 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
918 && DECL_IGNORED_P (TYPE_NAME (type
)))
922 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
924 /* Type has no dbx number assigned. Assign next available number. */
925 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
927 /* Make sure type vector is long enough to record about this type. */
929 if (next_type_number
== typevec_len
)
931 typevec
= (enum typestatus
*) xrealloc (typevec
, typevec_len
* 2 * sizeof typevec
[0]);
932 bzero (typevec
+ typevec_len
, typevec_len
* sizeof typevec
[0]);
937 /* Output the number of this type, to refer to it. */
938 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
941 #ifdef DBX_TYPE_DEFINED
942 if (DBX_TYPE_DEFINED (type
))
946 /* If this type's definition has been output or is now being output,
949 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)])
954 /* If we have already had a cross reference,
955 and either that's all we want or that's the best we could do,
956 don't repeat the cross reference.
957 Sun dbx crashes if we do. */
958 if (! full
|| TYPE_SIZE (type
) == 0
959 /* No way in DBX fmt to describe a variable size. */
960 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
968 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
969 leave the type-number completely undefined rather than output
970 a cross-reference. */
971 if (TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
972 || TREE_CODE (type
) == QUAL_UNION_TYPE
973 || TREE_CODE (type
) == ENUMERAL_TYPE
)
975 if ((TYPE_NAME (type
) != 0 && !full
)
976 || TYPE_SIZE (type
) == 0)
978 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_XREF
;
983 /* Output a definition now. */
985 fprintf (asmfile
, "=");
988 /* Mark it as defined, so that if it is self-referent
989 we will not get into an infinite recursion of definitions. */
991 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_DEFINED
;
993 switch (TREE_CODE (type
))
997 /* For a void type, just define it as itself; ie, "5=5".
998 This makes us consider it defined
999 without saying what it is. The debugger will make it
1000 a void type when the reference is seen, and nothing will
1001 ever override that default. */
1002 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
1007 if (type
== char_type_node
&& ! TREE_UNSIGNED (type
))
1008 /* Output the type `char' as a subrange of itself!
1009 I don't understand this definition, just copied it
1010 from the output of pcc.
1011 This used to use `r2' explicitly and we used to
1012 take care to make sure that `char' was type number 2. */
1013 fprintf (asmfile
, "r%d;0;127;", TYPE_SYMTAB_ADDRESS (type
));
1014 else if (use_gnu_debug_info_extensions
&& TYPE_PRECISION (type
) > BITS_PER_WORD
)
1016 /* This used to say `r1' and we used to take care
1017 to make sure that `int' was type number 1. */
1018 fprintf (asmfile
, "r%d;", TYPE_SYMTAB_ADDRESS (integer_type_node
));
1019 print_int_cst_octal (TYPE_MIN_VALUE (type
));
1020 fprintf (asmfile
, ";");
1021 print_int_cst_octal (TYPE_MAX_VALUE (type
));
1022 fprintf (asmfile
, ";");
1024 else /* Output other integer types as subranges of `int'. */
1025 dbxout_range_type (type
);
1030 /* This used to say `r1' and we used to take care
1031 to make sure that `int' was type number 1. */
1032 fprintf (asmfile
, "r%d;%d;0;", TYPE_SYMTAB_ADDRESS (integer_type_node
),
1033 int_size_in_bytes (type
));
1038 if (use_gnu_debug_info_extensions
)
1039 fprintf (asmfile
, "@s%d;-20;",
1040 BITS_PER_UNIT
* int_size_in_bytes (type
));
1042 /* Output the type `char' as a subrange of itself.
1043 That is what pcc seems to do. */
1044 fprintf (asmfile
, "r%d;0;%d;", TYPE_SYMTAB_ADDRESS (char_type_node
),
1045 TREE_UNSIGNED (type
) ? 255 : 127);
1050 if (use_gnu_debug_info_extensions
)
1051 fprintf (asmfile
, "@s%d;-16;",
1052 BITS_PER_UNIT
* int_size_in_bytes (type
));
1053 else /* Define as enumeral type (False, True) */
1054 fprintf (asmfile
, "eFalse:0,True:1,;");
1059 putc ('d', asmfile
);
1061 dbxout_type (TREE_TYPE (type
), 0, 0);
1065 /* Differs from the REAL_TYPE by its new data type number */
1067 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1069 fprintf (asmfile
, "r%d;%d;0;",
1070 TYPE_SYMTAB_ADDRESS (type
),
1071 int_size_in_bytes (TREE_TYPE (type
)));
1072 CHARS (15); /* The number is probably incorrect here. */
1076 /* Output a complex integer type as a structure,
1077 pending some other way to do it. */
1078 fprintf (asmfile
, "s%d", int_size_in_bytes (type
));
1080 fprintf (asmfile
, "real:");
1082 dbxout_type (TREE_TYPE (type
), 0, 0);
1083 fprintf (asmfile
, ",%d,%d;",
1084 0, TYPE_PRECISION (TREE_TYPE (type
)));
1086 fprintf (asmfile
, "imag:");
1088 dbxout_type (TREE_TYPE (type
), 0, 0);
1089 fprintf (asmfile
, ",%d,%d;;",
1090 TYPE_PRECISION (TREE_TYPE (type
)),
1091 TYPE_PRECISION (TREE_TYPE (type
)));
1097 putc ('S', asmfile
);
1099 dbxout_type (TREE_TYPE (type
), 0, 0);
1103 /* Output "a" followed by a range type definition
1104 for the index type of the array
1105 followed by a reference to the target-type.
1106 ar1;0;N;M for a C array of type M and size N+1. */
1107 tem
= TYPE_DOMAIN (type
);
1109 fprintf (asmfile
, "ar%d;0;-1;",
1110 TYPE_SYMTAB_ADDRESS (integer_type_node
));
1113 fprintf (asmfile
, "a");
1114 dbxout_range_type (tem
);
1117 dbxout_type (TREE_TYPE (type
), 0, 0);
1122 case QUAL_UNION_TYPE
:
1124 int i
, n_baseclasses
= 0;
1126 if (TYPE_BINFO (type
) != 0 && TYPE_BINFO_BASETYPES (type
) != 0)
1127 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
1129 /* Output a structure type. */
1130 if ((TYPE_NAME (type
) != 0
1131 /* Long ago, Tiemann said this creates output that "confuses GDB".
1132 In April 93, mrs@cygnus.com said there is no such problem.
1133 The type decls made automatically by struct specifiers
1134 are marked with DECL_IGNORED_P in C++. */
1135 #if 0 /* This creates output for anonymous classes which confuses GDB. */
1136 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1137 && DECL_IGNORED_P (TYPE_NAME (type
)))
1140 || TYPE_SIZE (type
) == 0
1141 /* No way in DBX fmt to describe a variable size. */
1142 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1144 /* If the type is just a cross reference, output one
1145 and mark the type as partially described.
1146 If it later becomes defined, we will output
1147 its real definition.
1148 If the type has a name, don't nest its definition within
1149 another type's definition; instead, output an xref
1150 and let the definition come when the name is defined. */
1151 fprintf (asmfile
, (TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu");
1153 #if 0 /* This assertion is legitimately false in C++. */
1154 /* We shouldn't be outputting a reference to a type before its
1155 definition unless the type has a tag name.
1156 A typedef name without a tag name should be impossible. */
1157 if (TREE_CODE (TYPE_NAME (type
)) != IDENTIFIER_NODE
)
1160 if (TYPE_NAME (type
) != 0)
1161 dbxout_type_name (type
);
1163 fprintf (asmfile
, "$$%d", anonymous_type_number
++);
1164 fprintf (asmfile
, ":");
1165 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_XREF
;
1169 /* Identify record or union, and print its size. */
1170 fprintf (asmfile
, (TREE_CODE (type
) == RECORD_TYPE
) ? "s%d" : "u%d",
1171 int_size_in_bytes (type
));
1173 if (use_gnu_debug_info_extensions
)
1177 have_used_extensions
= 1;
1178 fprintf (asmfile
, "!%d,", n_baseclasses
);
1182 for (i
= 0; i
< n_baseclasses
; i
++)
1184 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)), i
);
1185 if (use_gnu_debug_info_extensions
)
1187 have_used_extensions
= 1;
1188 putc (TREE_VIA_VIRTUAL (child
) ? '1'
1191 putc (TREE_VIA_PUBLIC (child
) ? '2'
1194 fprintf (asmfile
, "%d,",
1195 TREE_INT_CST_LOW (BINFO_OFFSET (child
)) * BITS_PER_UNIT
);
1197 dbxout_type (BINFO_TYPE (child
), 0, 0);
1198 putc (';', asmfile
);
1202 /* Print out the base class information with fields
1203 which have the same names at the types they hold. */
1204 dbxout_type_name (BINFO_TYPE (child
));
1205 putc (':', asmfile
);
1206 dbxout_type (BINFO_TYPE (child
), full
, 0);
1207 fprintf (asmfile
, ",%d,%d;",
1208 TREE_INT_CST_LOW (BINFO_OFFSET (child
)) * BITS_PER_UNIT
,
1209 TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child
)))) * BITS_PER_UNIT
);
1217 /* Write out the field declarations. */
1218 dbxout_type_fields (type
);
1219 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1221 have_used_extensions
= 1;
1222 dbxout_type_methods (type
);
1224 putc (';', asmfile
);
1226 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1227 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1228 && TYPE_VFIELD (type
))
1230 have_used_extensions
= 1;
1232 /* Tell GDB+ that it may keep reading. */
1233 putc ('~', asmfile
);
1235 /* We need to write out info about what field this class
1236 uses as its "main" vtable pointer field, because if this
1237 field is inherited from a base class, GDB cannot necessarily
1238 figure out which field it's using in time. */
1239 if (TYPE_VFIELD (type
))
1241 putc ('%', asmfile
);
1242 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0, 0);
1244 putc (';', asmfile
);
1250 if ((TYPE_NAME (type
) != 0 && !full
1251 && (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1252 && ! DECL_IGNORED_P (TYPE_NAME (type
))))
1253 || TYPE_SIZE (type
) == 0)
1255 fprintf (asmfile
, "xe");
1257 dbxout_type_name (type
);
1258 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_XREF
;
1259 fprintf (asmfile
, ":");
1262 #ifdef DBX_OUTPUT_ENUM
1263 DBX_OUTPUT_ENUM (asmfile
, type
);
1265 putc ('e', asmfile
);
1267 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1269 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)));
1270 if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == 0)
1272 if (TREE_INT_CST_LOW (TREE_VALUE (tem
)) < 0)
1273 fprintf (asmfile
, "%u", TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1275 fprintf (asmfile
, "%d", TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1278 print_int_cst_octal (TREE_VALUE (tem
));
1279 fprintf (asmfile
, ",");
1280 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)));
1281 if (TREE_CHAIN (tem
) != 0)
1284 putc (';', asmfile
);
1290 putc ('*', asmfile
);
1292 dbxout_type (TREE_TYPE (type
), 0, 0);
1296 if (use_gnu_debug_info_extensions
)
1298 have_used_extensions
= 1;
1299 putc ('#', asmfile
);
1301 if (flag_minimal_debug
&& !show_arg_types
)
1303 /* Normally, just output the return type.
1304 The argument types are encoded in the method name. */
1305 putc ('#', asmfile
);
1306 dbxout_type (TREE_TYPE (type
), 0, 0);
1307 putc (';', asmfile
);
1312 /* When outputting destructors, we need to write
1313 the argument types out longhand. */
1314 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0, 0);
1315 putc (',', asmfile
);
1317 dbxout_type (TREE_TYPE (type
), 0, 0);
1318 dbxout_args (TYPE_ARG_TYPES (type
));
1319 putc (';', asmfile
);
1325 /* Treat it as a function type. */
1326 dbxout_type (TREE_TYPE (type
), 0, 0);
1331 if (use_gnu_debug_info_extensions
)
1333 have_used_extensions
= 1;
1334 putc ('@', asmfile
);
1336 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0, 0);
1337 putc (',', asmfile
);
1339 dbxout_type (TREE_TYPE (type
), 0, 0);
1343 /* Should print as an int, because it is really
1345 dbxout_type (integer_type_node
, 0, 0);
1349 case REFERENCE_TYPE
:
1350 if (use_gnu_debug_info_extensions
)
1351 have_used_extensions
= 1;
1352 putc (use_gnu_debug_info_extensions
? '&' : '*', asmfile
);
1354 dbxout_type (TREE_TYPE (type
), 0, 0);
1358 putc ('f', asmfile
);
1360 dbxout_type (TREE_TYPE (type
), 0, 0);
1368 /* Print the value of integer constant C, in octal,
1369 handling double precision. */
1372 print_int_cst_octal (c
)
1375 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (c
);
1376 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (c
);
1377 int excess
= (3 - (HOST_BITS_PER_WIDE_INT
% 3));
1379 fprintf (asmfile
, "0");
1383 print_octal (high
, HOST_BITS_PER_WIDE_INT
/ 3);
1384 print_octal (low
, HOST_BITS_PER_WIDE_INT
/ 3);
1388 unsigned HOST_WIDE_INT beg
= high
>> excess
;
1389 unsigned HOST_WIDE_INT middle
1390 = ((high
& (((HOST_WIDE_INT
) 1 << excess
) - 1)) << (3 - excess
)
1391 | (low
>> (HOST_BITS_PER_WIDE_INT
/ 3 * 3)));
1392 unsigned HOST_WIDE_INT end
1393 = low
& (((HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
/ 3 * 3)) - 1);
1394 fprintf (asmfile
, "%o%01o", beg
, middle
);
1395 print_octal (end
, HOST_BITS_PER_WIDE_INT
/ 3);
1400 print_octal (value
, digits
)
1401 unsigned HOST_WIDE_INT value
;
1406 for (i
= digits
- 1; i
>= 0; i
--)
1407 fprintf (asmfile
, "%01o", ((value
>> (3 * i
)) & 7));
1410 /* Output the name of type TYPE, with no punctuation.
1411 Such names can be set up either by typedef declarations
1412 or by struct, enum and union tags. */
1415 dbxout_type_name (type
)
1419 if (TYPE_NAME (type
) == 0)
1421 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
1423 t
= TYPE_NAME (type
);
1425 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1427 t
= DECL_NAME (TYPE_NAME (type
));
1432 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
1433 CHARS (IDENTIFIER_LENGTH (t
));
1436 /* Output a .stabs for the symbol defined by DECL,
1437 which must be a ..._DECL node in the normal namespace.
1438 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1439 LOCAL is nonzero if the scope is less than the entire file. */
1442 dbxout_symbol (decl
, local
)
1447 tree type
= TREE_TYPE (decl
);
1448 tree context
= NULL_TREE
;
1451 /* Cast avoids warning in old compilers. */
1452 current_sym_code
= (STAB_CODE_TYPE
) 0;
1453 current_sym_value
= 0;
1454 current_sym_addr
= 0;
1456 /* Ignore nameless syms, but don't ignore type tags. */
1458 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
1459 || DECL_IGNORED_P (decl
))
1462 dbxout_prepare_symbol (decl
);
1464 /* The output will always start with the symbol name,
1465 so always count that in the length-output-so-far. */
1467 if (DECL_NAME (decl
) != 0)
1468 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
1470 switch (TREE_CODE (decl
))
1473 /* Enum values are defined by defining the enum type. */
1477 if (DECL_RTL (decl
) == 0)
1479 if (DECL_EXTERNAL (decl
))
1481 /* Don't mention a nested function under its parent. */
1482 context
= decl_function_context (decl
);
1483 if (context
== current_function_decl
)
1485 if (GET_CODE (DECL_RTL (decl
)) != MEM
1486 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
1490 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
1491 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1492 TREE_PUBLIC (decl
) ? 'F' : 'f');
1494 current_sym_code
= N_FUN
;
1495 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1497 if (TREE_TYPE (type
))
1498 dbxout_type (TREE_TYPE (type
), 0, 0);
1500 dbxout_type (void_type_node
, 0, 0);
1502 /* For a nested function, when that function is compiled,
1503 mention the containing function name
1504 as well as (since dbx wants it) our own assembler-name. */
1506 fprintf (asmfile
, ",%s,%s",
1507 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1508 IDENTIFIER_POINTER (DECL_NAME (context
)));
1510 dbxout_finish_symbol (decl
);
1515 /* This seems all wrong. Outputting most kinds of types gives no name
1516 at all. A true definition gives no name; a cross-ref for a
1517 structure can give the tag name, but not a type name.
1518 It seems that no typedef name is defined by outputting a type. */
1520 /* If this typedef name was defined by outputting the type,
1521 don't duplicate it. */
1522 if (typevec
[TYPE_SYMTAB_ADDRESS (type
)] == TYPE_DEFINED
1523 && TYPE_NAME (TREE_TYPE (decl
)) == decl
)
1526 /* Don't output the same typedef twice.
1527 And don't output what language-specific stuff doesn't want output. */
1528 if (TREE_ASM_WRITTEN (decl
) || DECL_IGNORED_P (decl
))
1537 if (DECL_NAME (decl
))
1539 /* Nonzero means we must output a tag as well as a typedef. */
1542 /* Handle the case of a C++ structure or union
1543 where the TYPE_NAME is a TYPE_DECL
1544 which gives both a typedef name and a tag. */
1545 /* dbx requires the tag first and the typedef second. */
1546 if ((TREE_CODE (type
) == RECORD_TYPE
1547 || TREE_CODE (type
) == UNION_TYPE
1548 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1549 && TYPE_NAME (type
) == decl
1550 && !(use_gnu_debug_info_extensions
&& have_used_extensions
)
1551 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
1552 /* Distinguish the implicit typedefs of C++
1553 from explicit ones that might be found in C. */
1554 && DECL_SOURCE_LINE (decl
) == 0)
1556 tree name
= TYPE_NAME (type
);
1557 if (TREE_CODE (name
) == TYPE_DECL
)
1558 name
= DECL_NAME (name
);
1560 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1561 current_sym_value
= 0;
1562 current_sym_addr
= 0;
1563 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1565 fprintf (asmfile
, "%s \"%s:T", ASM_STABS_OP
,
1566 IDENTIFIER_POINTER (name
));
1567 dbxout_type (type
, 1, 0);
1568 dbxout_finish_symbol (NULL_TREE
);
1571 /* Output typedef name. */
1572 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
,
1573 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1575 /* Short cut way to output a tag also. */
1576 if ((TREE_CODE (type
) == RECORD_TYPE
1577 || TREE_CODE (type
) == UNION_TYPE
1578 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1579 && TYPE_NAME (type
) == decl
)
1581 if (use_gnu_debug_info_extensions
&& have_used_extensions
)
1583 putc ('T', asmfile
);
1584 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
1586 #if 0 /* Now we generate the tag for this case up above. */
1592 putc ('t', asmfile
);
1593 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1595 dbxout_type (type
, 1, 0);
1596 dbxout_finish_symbol (decl
);
1600 /* Don't output a tag if this is an incomplete type (TYPE_SIZE is
1601 zero). This prevents the sun4 Sun OS 4.x dbx from crashing. */
1603 if (tag_needed
&& TYPE_NAME (type
) != 0 && TYPE_SIZE (type
) != 0
1604 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1606 /* For a TYPE_DECL with no name, but the type has a name,
1608 This is what represents `struct foo' with no typedef. */
1609 /* In C++, the name of a type is the corresponding typedef.
1610 In C, it is an IDENTIFIER_NODE. */
1611 tree name
= TYPE_NAME (type
);
1612 if (TREE_CODE (name
) == TYPE_DECL
)
1613 name
= DECL_NAME (name
);
1615 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1616 current_sym_value
= 0;
1617 current_sym_addr
= 0;
1618 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1620 fprintf (asmfile
, "%s \"%s:T", ASM_STABS_OP
,
1621 IDENTIFIER_POINTER (name
));
1622 dbxout_type (type
, 1, 0);
1623 dbxout_finish_symbol (NULL_TREE
);
1627 /* If an enum type has no name, it cannot be referred to,
1628 but we must output it anyway, since the enumeration constants
1629 can be referred to. */
1630 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
1632 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1633 current_sym_value
= 0;
1634 current_sym_addr
= 0;
1635 current_sym_nchars
= 2;
1637 /* Some debuggers fail when given NULL names, so give this a
1638 harmless name of ` '. */
1639 fprintf (asmfile
, "%s \" :T", ASM_STABS_OP
);
1640 dbxout_type (type
, 1, 0);
1641 dbxout_finish_symbol (NULL_TREE
);
1644 /* Prevent duplicate output of a typedef. */
1645 TREE_ASM_WRITTEN (decl
) = 1;
1650 /* Parm decls go in their own separate chains
1651 and are output by dbxout_reg_parms and dbxout_parms. */
1655 /* Named return value, treat like a VAR_DECL. */
1657 if (DECL_RTL (decl
) == 0)
1659 /* Don't mention a variable that is external.
1660 Let the file that defines it describe it. */
1661 if (DECL_EXTERNAL (decl
))
1664 /* If the variable is really a constant
1665 and not written in memory, inform the debugger. */
1666 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
1667 && DECL_INITIAL (decl
) != 0
1668 && ! TREE_ASM_WRITTEN (decl
)
1669 && (DECL_FIELD_CONTEXT (decl
) == NULL_TREE
1670 || TREE_CODE (DECL_FIELD_CONTEXT (decl
)) == BLOCK
))
1672 if (TREE_PUBLIC (decl
) == 0)
1674 /* The sun4 assembler does not grok this. */
1675 char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1676 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
1677 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
1679 HOST_WIDE_INT ival
= TREE_INT_CST_LOW (DECL_INITIAL (decl
));
1680 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1681 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile
, name
, ival
);
1683 fprintf (asmfile
, "%s \"%s:c=i%d\",0x%x,0,0,0\n",
1684 ASM_STABS_OP
, name
, ival
, N_LSYM
);
1688 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
1690 /* don't know how to do this yet. */
1694 /* else it is something we handle like a normal variable. */
1697 DECL_RTL (decl
) = eliminate_regs (DECL_RTL (decl
), 0, NULL_RTX
);
1698 #ifdef LEAF_REG_REMAP
1700 leaf_renumber_regs_insn (DECL_RTL (decl
));
1703 dbxout_symbol_location (decl
, type
, 0, DECL_RTL (decl
));
1707 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1708 Add SUFFIX to its name, if SUFFIX is not 0.
1709 Describe the variable as residing in HOME
1710 (usually HOME is DECL_RTL (DECL), but not always). */
1713 dbxout_symbol_location (decl
, type
, suffix
, home
)
1721 /* Don't mention a variable at all
1722 if it was completely optimized into nothingness.
1724 If the decl was from an inline function, then it's rtl
1725 is not identically the rtl that was used in this
1726 particular compilation. */
1727 if (GET_CODE (home
) == REG
)
1729 regno
= REGNO (home
);
1730 if (regno
>= FIRST_PSEUDO_REGISTER
)
1733 else if (GET_CODE (home
) == SUBREG
)
1737 while (GET_CODE (value
) == SUBREG
)
1739 offset
+= SUBREG_WORD (value
);
1740 value
= SUBREG_REG (value
);
1742 if (GET_CODE (value
) == REG
)
1744 regno
= REGNO (value
);
1745 if (regno
>= FIRST_PSEUDO_REGISTER
)
1749 alter_subreg (home
);
1752 /* The kind-of-variable letter depends on where
1753 the variable is and on the scope of its name:
1754 G and N_GSYM for static storage and global scope,
1755 S for static storage and file scope,
1756 V for static storage and local scope,
1757 for those two, use N_LCSYM if data is in bss segment,
1758 N_STSYM if in data segment, N_FUN otherwise.
1759 (We used N_FUN originally, then changed to N_STSYM
1760 to please GDB. However, it seems that confused ld.
1761 Now GDB has been fixed to like N_FUN, says Kingdon.)
1762 no letter at all, and N_LSYM, for auto variable,
1763 r and N_RSYM for register variable. */
1765 if (GET_CODE (home
) == MEM
1766 && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
1768 if (TREE_PUBLIC (decl
))
1771 current_sym_code
= N_GSYM
;
1775 current_sym_addr
= XEXP (home
, 0);
1777 letter
= decl_function_context (decl
) ? 'V' : 'S';
1779 if (!DECL_INITIAL (decl
))
1780 current_sym_code
= N_LCSYM
;
1781 else if (in_text_section ())
1782 /* This is not quite right, but it's the closest
1783 of all the codes that Unix defines. */
1784 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
1787 /* Ultrix `as' seems to need this. */
1788 #ifdef DBX_STATIC_STAB_DATA_SECTION
1791 current_sym_code
= N_STSYM
;
1795 else if (regno
>= 0)
1798 current_sym_code
= N_RSYM
;
1799 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
1801 else if (GET_CODE (home
) == MEM
1802 && (GET_CODE (XEXP (home
, 0)) == MEM
1803 || (GET_CODE (XEXP (home
, 0)) == REG
1804 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
)))
1805 /* If the value is indirect by memory or by a register
1806 that isn't the frame pointer
1807 then it means the object is variable-sized and address through
1808 that register or stack slot. DBX has no way to represent this
1809 so all we can do is output the variable as a pointer.
1810 If it's not a parameter, ignore it.
1811 (VAR_DECLs like this can be made by integrate.c.) */
1813 if (GET_CODE (XEXP (home
, 0)) == REG
)
1816 current_sym_code
= N_RSYM
;
1817 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
1821 current_sym_code
= N_LSYM
;
1822 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
1823 We want the value of that CONST_INT. */
1825 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
1828 /* Effectively do build_pointer_type, but don't cache this type,
1829 since it might be temporary whereas the type it points to
1830 might have been saved for inlining. */
1831 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
1832 type
= make_node (POINTER_TYPE
);
1833 TREE_TYPE (type
) = TREE_TYPE (decl
);
1835 else if (GET_CODE (home
) == MEM
1836 && GET_CODE (XEXP (home
, 0)) == REG
)
1838 current_sym_code
= N_LSYM
;
1839 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
1841 else if (GET_CODE (home
) == MEM
1842 && GET_CODE (XEXP (home
, 0)) == PLUS
1843 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
1845 current_sym_code
= N_LSYM
;
1846 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
1847 We want the value of that CONST_INT. */
1848 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
1850 else if (GET_CODE (home
) == MEM
1851 && GET_CODE (XEXP (home
, 0)) == CONST
)
1853 /* Handle an obscure case which can arise when optimizing and
1854 when there are few available registers. (This is *always*
1855 the case for i386/i486 targets). The RTL looks like
1856 (MEM (CONST ...)) even though this variable is a local `auto'
1857 or a local `register' variable. In effect, what has happened
1858 is that the reload pass has seen that all assignments and
1859 references for one such a local variable can be replaced by
1860 equivalent assignments and references to some static storage
1861 variable, thereby avoiding the need for a register. In such
1862 cases we're forced to lie to debuggers and tell them that
1863 this variable was itself `static'. */
1864 current_sym_code
= N_LCSYM
;
1866 current_sym_addr
= XEXP (XEXP (home
, 0), 0);
1868 else if (GET_CODE (home
) == CONCAT
)
1870 tree subtype
= TREE_TYPE (type
);
1872 /* If the variable's storage is in two parts,
1873 output each as a separate stab with a modified name. */
1874 if (WORDS_BIG_ENDIAN
)
1875 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
1877 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
1879 /* Cast avoids warning in old compilers. */
1880 current_sym_code
= (STAB_CODE_TYPE
) 0;
1881 current_sym_value
= 0;
1882 current_sym_addr
= 0;
1883 dbxout_prepare_symbol (decl
);
1885 if (WORDS_BIG_ENDIAN
)
1886 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
1888 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
1892 /* Address might be a MEM, when DECL is a variable-sized object.
1893 Or it might be const0_rtx, meaning previous passes
1894 want us to ignore this variable. */
1897 /* Ok, start a symtab entry and output the variable name. */
1900 #ifdef DBX_STATIC_BLOCK_START
1901 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
1904 dbxout_symbol_name (decl
, suffix
, letter
);
1905 dbxout_type (type
, 0, 0);
1906 dbxout_finish_symbol (decl
);
1908 #ifdef DBX_STATIC_BLOCK_END
1909 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
1913 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
1914 Then output LETTER to indicate the kind of location the symbol has. */
1917 dbxout_symbol_name (decl
, suffix
, letter
)
1922 /* One slight hitch: if this is a VAR_DECL which is a static
1923 class member, we must put out the mangled name instead of the
1927 /* Note also that static member (variable) names DO NOT begin
1928 with underscores in .stabs directives. */
1929 if (DECL_LANG_SPECIFIC (decl
))
1930 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
1932 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1935 fprintf (asmfile
, "%s \"%s%s:", ASM_STABS_OP
, name
,
1936 (suffix
? suffix
: ""));
1938 if (letter
) putc (letter
, asmfile
);
1942 dbxout_prepare_symbol (decl
)
1946 char *filename
= DECL_SOURCE_FILE (decl
);
1948 dbxout_source_file (asmfile
, filename
);
1953 dbxout_finish_symbol (sym
)
1956 #ifdef DBX_FINISH_SYMBOL
1957 DBX_FINISH_SYMBOL (sym
);
1960 if (use_gnu_debug_info_extensions
&& sym
!= 0)
1961 line
= DECL_SOURCE_LINE (sym
);
1963 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
1964 if (current_sym_addr
)
1965 output_addr_const (asmfile
, current_sym_addr
);
1967 fprintf (asmfile
, "%d", current_sym_value
);
1968 putc ('\n', asmfile
);
1972 /* Output definitions of all the decls in a chain. */
1980 dbxout_symbol (syms
, 1);
1981 syms
= TREE_CHAIN (syms
);
1985 /* The following two functions output definitions of function parameters.
1986 Each parameter gets a definition locating it in the parameter list.
1987 Each parameter that is a register variable gets a second definition
1988 locating it in the register.
1990 Printing or argument lists in gdb uses the definitions that
1991 locate in the parameter list. But reference to the variable in
1992 expressions uses preferentially the definition as a register. */
1994 /* Output definitions, referring to storage in the parmlist,
1995 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
1998 dbxout_parms (parms
)
2001 for (; parms
; parms
= TREE_CHAIN (parms
))
2002 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
2004 dbxout_prepare_symbol (parms
);
2006 /* Perform any necessary register eliminations on the parameter's rtl,
2007 so that the debugging output will be accurate. */
2008 DECL_INCOMING_RTL (parms
)
2009 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
2010 DECL_RTL (parms
) = eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
);
2011 #ifdef LEAF_REG_REMAP
2014 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
2015 leaf_renumber_regs_insn (DECL_RTL (parms
));
2019 if (PARM_PASSED_IN_MEMORY (parms
))
2021 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
2023 /* ??? Here we assume that the parm address is indexed
2024 off the frame pointer or arg pointer.
2025 If that is not true, we produce meaningless results,
2026 but do not crash. */
2027 if (GET_CODE (addr
) == PLUS
2028 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
2029 current_sym_value
= INTVAL (XEXP (addr
, 1));
2031 current_sym_value
= 0;
2033 current_sym_code
= N_PSYM
;
2034 current_sym_addr
= 0;
2037 if (DECL_NAME (parms
))
2039 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2041 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2042 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2043 DBX_MEMPARM_STABS_LETTER
);
2047 current_sym_nchars
= 8;
2048 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2049 DBX_MEMPARM_STABS_LETTER
);
2052 if (GET_CODE (DECL_RTL (parms
)) == REG
2053 && REGNO (DECL_RTL (parms
)) >= 0
2054 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2055 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
2058 int original_value
= current_sym_value
;
2060 /* This is the case where the parm is passed as an int or double
2061 and it is converted to a char, short or float and stored back
2062 in the parmlist. In this case, describe the parm
2063 with the variable's declared type, and adjust the address
2064 if the least significant bytes (which we are using) are not
2066 #if BYTES_BIG_ENDIAN
2067 if (TREE_TYPE (parms
) != DECL_ARG_TYPE (parms
))
2068 current_sym_value
+= (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms
)))
2069 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
))));
2072 if (GET_CODE (DECL_RTL (parms
)) == MEM
2073 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == PLUS
2074 && GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == CONST_INT
2075 && INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == current_sym_value
)
2076 dbxout_type (TREE_TYPE (parms
), 0, 0);
2079 current_sym_value
= original_value
;
2080 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
2083 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
2084 dbxout_finish_symbol (parms
);
2086 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
2089 char regparm_letter
;
2091 /* Parm passed in registers and lives in registers or nowhere. */
2093 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2094 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2095 current_sym_addr
= 0;
2097 /* If parm lives in a register, use that register;
2098 pretend the parm was passed there. It would be more consistent
2099 to describe the register where the parm was passed,
2100 but in practice that register usually holds something else.
2102 If we use DECL_RTL, then we must use the declared type of
2103 the variable, not the type that it arrived in. */
2104 if (REGNO (DECL_RTL (parms
)) >= 0
2105 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2107 best_rtl
= DECL_RTL (parms
);
2108 parm_type
= TREE_TYPE (parms
);
2110 /* If the parm lives nowhere,
2111 use the register where it was passed. */
2114 best_rtl
= DECL_INCOMING_RTL (parms
);
2115 parm_type
= DECL_ARG_TYPE (parms
);
2117 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
2120 if (DECL_NAME (parms
))
2122 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2123 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2124 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2129 current_sym_nchars
= 8;
2130 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2134 dbxout_type (parm_type
, 0, 0);
2135 dbxout_finish_symbol (parms
);
2137 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2138 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
)
2139 /* && rtx_equal_p (XEXP (DECL_RTL (parms), 0),
2140 DECL_INCOMING_RTL (parms))) */
2142 /* Parm was passed via invisible reference.
2143 That is, its address was passed in a register.
2144 Output it as if it lived in that register.
2145 The debugger will know from the type
2146 that it was actually passed by invisible reference. */
2148 char regparm_letter
;
2149 /* Parm passed in registers and lives in registers or nowhere. */
2151 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2152 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2154 /* DECL_RTL looks like (MEM (REG...). Get the register number. */
2155 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
2156 current_sym_addr
= 0;
2159 if (DECL_NAME (parms
))
2161 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2163 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2164 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2165 DBX_REGPARM_STABS_LETTER
);
2169 current_sym_nchars
= 8;
2170 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2171 DBX_REGPARM_STABS_LETTER
);
2174 dbxout_type (TREE_TYPE (parms
), 0, 0);
2175 dbxout_finish_symbol (parms
);
2177 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2178 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
2179 /* ??? A constant address for a parm can happen
2180 when the reg it lives in is equiv to a constant in memory.
2181 Should make this not happen, after 2.4. */
2182 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
2184 /* Parm was passed in registers but lives on the stack. */
2186 current_sym_code
= N_PSYM
;
2187 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2188 in which case we want the value of that CONST_INT,
2189 or (MEM (REG ...)) or (MEM (MEM ...)),
2190 in which case we use a value of zero. */
2191 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
2192 || GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
2193 current_sym_value
= 0;
2195 current_sym_value
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
2196 current_sym_addr
= 0;
2199 if (DECL_NAME (parms
))
2201 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2203 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2204 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2205 DBX_MEMPARM_STABS_LETTER
);
2209 current_sym_nchars
= 8;
2210 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2211 DBX_MEMPARM_STABS_LETTER
);
2215 = DEBUGGER_ARG_OFFSET (current_sym_value
,
2216 XEXP (DECL_RTL (parms
), 0));
2217 dbxout_type (TREE_TYPE (parms
), 0, 0);
2218 dbxout_finish_symbol (parms
);
2223 /* Output definitions for the places where parms live during the function,
2224 when different from where they were passed, when the parms were passed
2227 It is not useful to do this for parms passed in registers
2228 that live during the function in different registers, because it is
2229 impossible to look in the passed register for the passed value,
2230 so we use the within-the-function register to begin with.
2232 PARMS is a chain of PARM_DECL nodes. */
2235 dbxout_reg_parms (parms
)
2238 for (; parms
; parms
= TREE_CHAIN (parms
))
2239 if (DECL_NAME (parms
))
2241 dbxout_prepare_symbol (parms
);
2243 /* Report parms that live in registers during the function
2244 but were passed in memory. */
2245 if (GET_CODE (DECL_RTL (parms
)) == REG
2246 && REGNO (DECL_RTL (parms
)) >= 0
2247 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
2248 && PARM_PASSED_IN_MEMORY (parms
))
2249 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2250 0, DECL_RTL (parms
));
2251 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
2252 && PARM_PASSED_IN_MEMORY (parms
))
2253 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2254 0, DECL_RTL (parms
));
2255 /* Report parms that live in memory but not where they were passed. */
2256 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2257 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == PLUS
2258 && GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == CONST_INT
2259 && PARM_PASSED_IN_MEMORY (parms
)
2260 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
2262 #if 0 /* ??? It is not clear yet what should replace this. */
2263 int offset
= DECL_OFFSET (parms
) / BITS_PER_UNIT
;
2264 /* A parm declared char is really passed as an int,
2265 so it occupies the least significant bytes.
2266 On a big-endian machine those are not the low-numbered ones. */
2267 #if BYTES_BIG_ENDIAN
2268 if (offset
!= -1 && TREE_TYPE (parms
) != DECL_ARG_TYPE (parms
))
2269 offset
+= (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms
)))
2270 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
))));
2272 if (INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) != offset
) {...}
2274 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2275 0, DECL_RTL (parms
));
2278 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2279 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
)
2281 /* Parm was passed via invisible reference.
2282 That is, its address was passed in a register.
2283 Output it as if it lived in that register.
2284 The debugger will know from the type
2285 that it was actually passed by invisible reference. */
2287 current_sym_code
= N_RSYM
;
2289 /* DECL_RTL looks like (MEM (REG...). Get the register number. */
2290 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
2291 current_sym_addr
= 0;
2294 if (DECL_NAME (parms
))
2296 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2298 fprintf (asmfile
, "%s \"%s:r", ASM_STABS_OP
,
2299 IDENTIFIER_POINTER (DECL_NAME (parms
)));
2303 current_sym_nchars
= 8;
2304 fprintf (asmfile
, "%s \"(anon):r", ASM_STABS_OP
);
2307 dbxout_type (TREE_TYPE (parms
), 0, 0);
2308 dbxout_finish_symbol (parms
);
2314 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2315 output definitions of those names, in raw form */
2323 putc (',', asmfile
);
2324 dbxout_type (TREE_VALUE (args
), 0, 0);
2326 args
= TREE_CHAIN (args
);
2330 /* Given a chain of ..._TYPE nodes,
2331 find those which have typedef names and output those names.
2332 This is to ensure those types get output. */
2335 dbxout_types (types
)
2336 register tree types
;
2340 if (TYPE_NAME (types
)
2341 && TREE_CODE (TYPE_NAME (types
)) == TYPE_DECL
2342 && ! TREE_ASM_WRITTEN (TYPE_NAME (types
)))
2343 dbxout_symbol (TYPE_NAME (types
), 1);
2344 types
= TREE_CHAIN (types
);
2348 /* Output everything about a symbol block (a BLOCK node
2349 that represents a scope level),
2350 including recursive output of contained blocks.
2352 BLOCK is the BLOCK node.
2353 DEPTH is its depth within containing symbol blocks.
2354 ARGS is usually zero; but for the outermost block of the
2355 body of a function, it is a chain of PARM_DECLs for the function parameters.
2356 We output definitions of all the register parms
2357 as if they were local variables of that block.
2359 If -g1 was used, we count blocks just the same, but output nothing
2360 except for the outermost block.
2362 Actually, BLOCK may be several blocks chained together.
2363 We handle them all in sequence. */
2366 dbxout_block (block
, depth
, args
)
2367 register tree block
;
2375 /* Ignore blocks never expanded or otherwise marked as real. */
2376 if (TREE_USED (block
))
2378 #ifndef DBX_LBRAC_FIRST
2379 /* In dbx format, the syms of a block come before the N_LBRAC. */
2380 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2381 dbxout_syms (BLOCK_VARS (block
));
2383 dbxout_reg_parms (args
);
2386 /* Now output an N_LBRAC symbol to represent the beginning of
2387 the block. Use the block's tree-walk order to generate
2388 the assembler symbols LBBn and LBEn
2389 that final will define around the code in this block. */
2390 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2393 blocknum
= next_block_number
++;
2394 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
2396 if (BLOCK_HANDLER_BLOCK (block
))
2398 /* A catch block. Must precede N_LBRAC. */
2399 tree decl
= BLOCK_VARS (block
);
2402 #ifdef DBX_OUTPUT_CATCH
2403 DBX_OUTPUT_CATCH (asmfile
, decl
, buf
);
2405 fprintf (asmfile
, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP
,
2406 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
2407 assemble_name (asmfile
, buf
);
2408 fprintf (asmfile
, "\n");
2410 decl
= TREE_CHAIN (decl
);
2414 #ifdef DBX_OUTPUT_LBRAC
2415 DBX_OUTPUT_LBRAC (asmfile
, buf
);
2417 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_LBRAC
);
2418 assemble_name (asmfile
, buf
);
2419 #if DBX_BLOCKS_FUNCTION_RELATIVE
2420 fputc ('-', asmfile
);
2421 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
2423 fprintf (asmfile
, "\n");
2427 /* Count blocks the same way regardless of debug_info_level. */
2428 next_block_number
++;
2430 #ifdef DBX_LBRAC_FIRST
2431 /* On some weird machines, the syms of a block
2432 come after the N_LBRAC. */
2433 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2434 dbxout_syms (BLOCK_VARS (block
));
2436 dbxout_reg_parms (args
);
2439 /* Output the subblocks. */
2440 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
2442 /* Refer to the marker for the end of the block. */
2443 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2446 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
2447 #ifdef DBX_OUTPUT_RBRAC
2448 DBX_OUTPUT_RBRAC (asmfile
, buf
);
2450 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_RBRAC
);
2451 assemble_name (asmfile
, buf
);
2452 #if DBX_BLOCKS_FUNCTION_RELATIVE
2453 fputc ('-', asmfile
);
2454 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
2456 fprintf (asmfile
, "\n");
2460 block
= BLOCK_CHAIN (block
);
2464 /* Output the information about a function and its arguments and result.
2465 Usually this follows the function's code,
2466 but on some systems, it comes before. */
2469 dbxout_really_begin_function (decl
)
2472 dbxout_symbol (decl
, 0);
2473 dbxout_parms (DECL_ARGUMENTS (decl
));
2474 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
2475 dbxout_symbol (DECL_RESULT (decl
), 1);
2478 /* Called at beginning of output of function definition. */
2481 dbxout_begin_function (decl
)
2484 #ifdef DBX_FUNCTION_FIRST
2485 dbxout_really_begin_function (decl
);
2489 /* Output dbx data for a function definition.
2490 This includes a definition of the function name itself (a symbol),
2491 definitions of the parameters (locating them in the parameter list)
2492 and then output the block that makes up the function's body
2493 (including all the auto variables of the function). */
2496 dbxout_function (decl
)
2499 #ifndef DBX_FUNCTION_FIRST
2500 dbxout_really_begin_function (decl
);
2502 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
2503 #ifdef DBX_OUTPUT_FUNCTION_END
2504 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
2507 #endif /* DBX_DEBUGGING_INFO */