1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987, 1988, 1992 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* Output dbx-format symbol table data.
22 This consists of many symbol table entries, each of them
23 a .stabs assembler pseudo-op with four operands:
24 a "name" which is really a description of one symbol and its type,
25 a "code", which is a symbol defined in stab.h whose name starts with N_,
26 an unused operand always 0,
27 and a "value" which is an address or an offset.
28 The name is enclosed in doublequote characters.
30 Each function, variable, typedef, and structure tag
31 has a symbol table entry to define it.
32 The beginning and end of each level of name scoping within
33 a function are also marked by special symbol table entries.
35 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
36 and a data type number. The data type number may be followed by
37 "=" and a type definition; normally this will happen the first time
38 the type number is mentioned. The type definition may refer to
39 other types by number, and those type numbers may be followed
40 by "=" and nested definitions.
42 This can make the "name" quite long.
43 When a name is more than 80 characters, we split the .stabs pseudo-op
44 into two .stabs pseudo-ops, both sharing the same "code" and "value".
45 The first one is marked as continued with a double-backslash at the
48 The kind-of-symbol letter distinguished function names from global
49 variables from file-scope variables from parameters from auto
50 variables in memory from typedef names from register variables.
53 The "code" is mostly redundant with the kind-of-symbol letter
54 that goes in the "name", but not entirely: for symbols located
55 in static storage, the "code" says which segment the address is in,
56 which controls how it is relocated.
58 The "value" for a symbol in static storage
59 is the core address of the symbol (actually, the assembler
60 label for the symbol). For a symbol located in a stack slot
61 it is the stack offset; for one in a register, the register number.
62 For a typedef symbol, it is zero.
64 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
65 output while in the text section.
67 For more on data type definitions, see `dbxout_type'. */
69 /* Include these first, because they may define MIN and MAX. */
78 #include "insn-config.h"
85 #ifdef XCOFF_DEBUGGING_INFO
90 #define ASM_STABS_OP ".stabs"
94 #define ASM_STABN_OP ".stabn"
97 #ifndef DBX_TYPE_DECL_STABS_CODE
98 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
101 #ifndef DBX_STATIC_CONST_VAR_CODE
102 #define DBX_STATIC_CONST_VAR_CODE N_FUN
105 #ifndef DBX_REGPARM_STABS_CODE
106 #define DBX_REGPARM_STABS_CODE N_RSYM
109 #ifndef DBX_REGPARM_STABS_LETTER
110 #define DBX_REGPARM_STABS_LETTER 'P'
113 #ifndef DBX_MEMPARM_STABS_LETTER
114 #define DBX_MEMPARM_STABS_LETTER 'p'
117 /* Nonzero means if the type has methods, only output debugging
118 information if methods are actually written to the asm file. */
120 static int flag_minimal_debug
= 1;
122 /* Nonzero if we have actually used any of the GDB extensions
123 to the debugging format. The idea is that we use them for the
124 first time only if there's a strong reason, but once we have done that,
125 we use them whenever convenient. */
127 static int have_used_extensions
= 0;
131 /* Typical USG systems don't have stab.h, and they also have
132 no use for DBX-format debugging info. */
134 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
136 #ifdef DEBUG_SYMS_TEXT
137 #define FORCE_TEXT text_section ();
142 #if defined (USG) || defined (NO_STAB_H)
143 #include "gstab.h" /* If doing DBX on sysV, use our own stab.h. */
145 #include <stab.h> /* On BSD, use the system's stab.h. */
147 /* This is a GNU extension we need to reference in this file. */
154 #define STAB_CODE_TYPE enum __stab_debug_code
156 #define STAB_CODE_TYPE int
159 /* 1 if PARM is passed to this function in memory. */
161 #define PARM_PASSED_IN_MEMORY(PARM) \
162 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
164 /* A C expression for the integer offset value of an automatic variable
165 (N_LSYM) having address X (an RTX). */
166 #ifndef DEBUGGER_AUTO_OFFSET
167 #define DEBUGGER_AUTO_OFFSET(X) \
168 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
171 /* A C expression for the integer offset value of an argument (N_PSYM)
172 having address X (an RTX). The nominal offset is OFFSET. */
173 #ifndef DEBUGGER_ARG_OFFSET
174 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
177 /* Stream for writing to assembler file. */
179 static FILE *asmfile
;
181 /* Last source file name mentioned in a NOTE insn. */
183 static char *lastfile
;
185 /* Current working directory. */
189 enum typestatus
{TYPE_UNSEEN
, TYPE_XREF
, TYPE_DEFINED
};
191 /* Vector recording the status of describing C data types.
192 When we first notice a data type (a tree node),
193 we assign it a number using next_type_number.
194 That is its index in this vector.
195 The vector element says whether we have yet output
196 the definition of the type. TYPE_XREF says we have
197 output it as a cross-reference only. */
199 enum typestatus
*typevec
;
201 /* Number of elements of space allocated in `typevec'. */
203 static int typevec_len
;
205 /* In dbx output, each type gets a unique number.
206 This is the number for the next type output.
207 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
209 static int next_type_number
;
211 /* In dbx output, we must assign symbol-blocks id numbers
212 in the order in which their beginnings are encountered.
213 We output debugging info that refers to the beginning and
214 end of the ranges of code in each block
215 with assembler labels LBBn and LBEn, where n is the block number.
216 The labels are generated in final, which assigns numbers to the
217 blocks in the same way. */
219 static int next_block_number
;
221 /* These variables are for dbxout_symbol to communicate to
222 dbxout_finish_symbol.
223 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
224 current_sym_value and current_sym_addr are two ways to address the
225 value to store in the symtab entry.
226 current_sym_addr if nonzero represents the value as an rtx.
227 If that is zero, current_sym_value is used. This is used
228 when the value is an offset (such as for auto variables,
229 register variables and parms). */
231 static STAB_CODE_TYPE current_sym_code
;
232 static int current_sym_value
;
233 static rtx current_sym_addr
;
235 /* Number of chars of symbol-description generated so far for the
236 current symbol. Used by CHARS and CONTIN. */
238 static int current_sym_nchars
;
240 /* Report having output N chars of the current symbol-description. */
242 #define CHARS(N) (current_sym_nchars += (N))
244 /* Break the current symbol-description, generating a continuation,
245 if it has become long. */
247 #ifndef DBX_CONTIN_LENGTH
248 #define DBX_CONTIN_LENGTH 80
251 #if DBX_CONTIN_LENGTH > 0
253 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
258 void dbxout_types ();
260 void dbxout_symbol ();
261 static void dbxout_type_name ();
262 static void dbxout_type ();
263 static void dbxout_typedefs ();
264 static void dbxout_prepare_symbol ();
265 static void dbxout_finish_symbol ();
266 static void dbxout_continue ();
267 static void print_int_cst_octal ();
268 static void print_octal ();
270 #if 0 /* Not clear we will actually need this. */
272 /* Return the absolutized filename for the given relative
273 filename. Note that if that filename is already absolute, it may
274 still be returned in a modified form because this routine also
275 eliminates redundant slashes and single dots and eliminates double
276 dots to get a shortest possible filename from the given input
277 filename. The absolutization of relative filenames is made by
278 assuming that the given filename is to be taken as relative to
279 the first argument (cwd) or to the current directory if cwd is
283 abspath (rel_filename
)
286 /* Setup the current working directory as needed. */
288 = (char *) alloca (strlen (cwd
) + strlen (rel_filename
) + 1);
289 char *endp
= abs_buffer
;
293 /* Copy the filename (possibly preceded by the current working
294 directory name) into the absolutization buffer. */
299 if (rel_filename
[0] != '/')
302 while (*endp
++ = *src_p
++)
304 *(endp
-1) = '/'; /* overwrite null */
306 src_p
= rel_filename
;
307 while (*endp
++ = *src_p
++)
312 /* Now make a copy of abs_buffer into abs_buffer, shortening the
313 filename (by taking out slashes and dots) as we go. */
315 outp
= inp
= abs_buffer
;
316 *outp
++ = *inp
++; /* copy first slash */
321 else if (inp
[0] == '/' && outp
[-1] == '/')
326 else if (inp
[0] == '.' && outp
[-1] == '/')
330 else if (inp
[1] == '/')
335 else if ((inp
[1] == '.') && (inp
[2] == 0 || inp
[2] == '/'))
337 inp
+= (inp
[2] == '/') ? 3 : 2;
339 while (outp
>= abs_buffer
&& *outp
!= '/')
341 if (outp
< abs_buffer
)
343 /* Catch cases like /.. where we try to backup to a
344 point above the absolute root of the logical file
347 fprintf (stderr
, "%s: invalid file name: %s\n",
348 pname
, rel_filename
);
358 /* On exit, make sure that there is a trailing null, and make sure that
359 the last character of the returned string is *not* a slash. */
365 /* Make a copy (in the heap) of the stuff left in the absolutization
366 buffer and return a pointer to the copy. */
368 value
= (char *) oballoc (strlen (abs_buffer
) + 1);
369 strcpy (value
, abs_buffer
);
374 /* At the beginning of compilation, start writing the symbol table.
375 Initialize `typevec' and output the standard data types of C. */
378 dbxout_init (asm_file
, input_file_name
, syms
)
380 char *input_file_name
;
383 char ltext_label_name
[100];
388 typevec
= (enum typestatus
*) xmalloc (typevec_len
* sizeof typevec
[0]);
389 bzero (typevec
, typevec_len
* sizeof typevec
[0]);
391 /* Convert Ltext into the appropriate format for local labels in case
392 the system doesn't insert underscores in front of user generated
394 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
396 /* Put the current working directory in an N_SO symbol. */
397 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
398 but GDB always does. */
399 if (use_gdb_dbx_extensions
)
402 if (cwd
|| (cwd
= getpwd ()))
404 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
405 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile
, cwd
);
406 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
407 fprintf (asmfile
, "%s \"%s/\",%d,0,0,%s\n", ASM_STABS_OP
,
408 cwd
, N_SO
, <ext_label_name
[1]);
409 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
413 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
414 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
415 would give us an N_SOL, and we want an N_SO. */
416 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile
, input_file_name
);
417 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
418 /* We include outputting `Ltext:' here,
419 because that gives you a way to override it. */
420 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
421 fprintf (asmfile
, "%s \"%s\",%d,0,0,%s\n", ASM_STABS_OP
, input_file_name
,
422 N_SO
, <ext_label_name
[1]);
424 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Ltext", 0);
425 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
427 lastfile
= input_file_name
;
429 next_type_number
= 1;
430 next_block_number
= 2;
432 /* Make sure that types `int' and `char' have numbers 1 and 2.
433 Definitions of other integer types will refer to those numbers.
434 (Actually it should no longer matter what their numbers are.
435 Also, if any types with tags have been defined, dbxout_symbol
436 will output them first, so the numbers won't be 1 and 2. That
437 happens in C++. So it's a good thing it should no longer matter). */
439 #ifdef DBX_OUTPUT_STANDARD_TYPES
440 DBX_OUTPUT_STANDARD_TYPES (syms
);
442 dbxout_symbol (TYPE_NAME (integer_type_node
), 0);
443 dbxout_symbol (TYPE_NAME (char_type_node
), 0);
446 /* Get all permanent types that have typedef names,
447 and output them all, except for those already output. */
449 dbxout_typedefs (syms
);
452 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
453 in the reverse order from that which is found in SYMS. */
456 dbxout_typedefs (syms
)
461 dbxout_typedefs (TREE_CHAIN (syms
));
462 if (TREE_CODE (syms
) == TYPE_DECL
)
464 tree type
= TREE_TYPE (syms
);
466 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
467 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
468 dbxout_symbol (TYPE_NAME (type
), 0);
473 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
476 dbxout_source_file (file
, filename
)
480 char ltext_label_name
[100];
482 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
484 #ifdef DBX_OUTPUT_SOURCE_FILENAME
485 DBX_OUTPUT_SOURCE_FILENAME (file
, filename
);
487 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
488 fprintf (file
, "%s \"%s\",%d,0,0,%s\n", ASM_STABS_OP
,
489 filename
, N_SOL
, <ext_label_name
[1]);
495 /* At the end of compilation, finish writing the symbol table.
496 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
500 dbxout_finish (file
, filename
)
504 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
505 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file
, filename
);
506 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
509 /* Continue a symbol-description that gets too big.
510 End one symbol table entry with a double-backslash
511 and start a new one, eventually producing something like
512 .stabs "start......\\",code,0,value
513 .stabs "...rest",code,0,value */
518 #ifdef DBX_CONTIN_CHAR
519 fprintf (asmfile
, "%c", DBX_CONTIN_CHAR
);
521 fprintf (asmfile
, "\\\\");
523 dbxout_finish_symbol (0);
524 fprintf (asmfile
, "%s \"", ASM_STABS_OP
);
525 current_sym_nchars
= 0;
528 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
529 This must be a separate function because anonymous unions require
533 dbxout_type_fields (type
)
537 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
539 /* Output the name, type, position (in bits), size (in bits)
541 if (DECL_NAME (tem
) == NULL_TREE
542 && TREE_CODE (TREE_TYPE (tem
)) == UNION_TYPE
)
543 dbxout_type_fields (TREE_TYPE (tem
));
544 /* Omit here local type decls until we know how to support them. */
545 else if (TREE_CODE (tem
) == TYPE_DECL
)
547 /* Omit here the nameless fields that are used to skip bits. */
548 else if (DECL_NAME (tem
) != 0 && TREE_CODE (tem
) != CONST_DECL
)
550 /* Continue the line if necessary,
551 but not before the first field. */
552 if (tem
!= TYPE_FIELDS (type
))
555 if (use_gdb_dbx_extensions
556 && flag_minimal_debug
557 && TREE_CODE (tem
) == FIELD_DECL
558 && DECL_VIRTUAL_P (tem
)
559 && DECL_ASSEMBLER_NAME (tem
))
561 have_used_extensions
= 1;
562 CHARS (3 + IDENTIFIER_LENGTH (DECL_NAME (TYPE_NAME (DECL_FCONTEXT (tem
)))));
563 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
)), asmfile
);
564 dbxout_type (DECL_FCONTEXT (tem
), 0, 0);
565 fprintf (asmfile
, ":");
566 dbxout_type (TREE_TYPE (tem
), 0, 0);
567 fprintf (asmfile
, ",%d;",
568 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem
)));
572 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem
)));
573 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem
)));
575 if (use_gdb_dbx_extensions
576 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
577 || TREE_CODE (tem
) != FIELD_DECL
))
579 have_used_extensions
= 1;
581 putc ((TREE_PRIVATE (tem
) ? '0'
582 : TREE_PROTECTED (tem
) ? '1' : '2'),
587 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
588 && DECL_BIT_FIELD_TYPE (tem
))
589 ? DECL_BIT_FIELD_TYPE (tem
)
590 : TREE_TYPE (tem
), 0, 0);
592 if (TREE_CODE (tem
) == VAR_DECL
)
594 if (TREE_STATIC (tem
) && use_gdb_dbx_extensions
)
596 char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
));
597 have_used_extensions
= 1;
598 fprintf (asmfile
, ":%s;", name
);
599 CHARS (strlen (name
));
603 /* If TEM is non-static, GDB won't understand it. */
604 fprintf (asmfile
, ",0,0;");
607 else if (TREE_CODE (DECL_FIELD_BITPOS (tem
)) == INTEGER_CST
)
609 fprintf (asmfile
, ",%d,%d;",
610 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem
)),
611 TREE_INT_CST_LOW (DECL_SIZE (tem
)));
614 /* This has yet to be implemented. */
621 /* Subroutine of `dbxout_type_methods'. Output debug info about the
622 method described DECL. DEBUG_NAME is an encoding of the method's
623 type signature. ??? We may be able to do without DEBUG_NAME altogether
627 dbxout_type_method_1 (decl
, debug_name
)
631 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
634 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
636 else /* it's a METHOD_TYPE. */
638 /* A for normal functions.
639 B for `const' member functions.
640 C for `volatile' member functions.
641 D for `const volatile' member functions. */
642 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
644 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
647 if (DECL_VINDEX (decl
))
653 fprintf (asmfile
, ":%s;%c%c%c", debug_name
,
654 TREE_PRIVATE (decl
) ? '0' : TREE_PROTECTED (decl
) ? '1' : '2', c1
, c2
);
655 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
)) + 6
656 - (debug_name
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
657 if (DECL_VINDEX (decl
))
659 fprintf (asmfile
, "%d;",
660 TREE_INT_CST_LOW (DECL_VINDEX (decl
)));
661 dbxout_type (DECL_CONTEXT (decl
), 0, 0);
662 fprintf (asmfile
, ";");
667 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
671 dbxout_type_methods (type
)
674 /* C++: put out the method names and their parameter lists */
675 tree methods
= TYPE_METHODS (type
);
677 register tree fndecl
;
679 register int type_identifier_length
;
681 if (methods
== NULL_TREE
)
684 type_encoding
= DECL_NAME (TYPE_NAME (type
));
686 /* C++: Template classes break some assumptions made by this code about
687 the class names, constructor names, and encodings for assembler
688 label names. For now, disable output of dbx info for them. */
690 char *ptr
= IDENTIFIER_POINTER (type_encoding
);
691 /* Avoid strchr or index since those names aren't universal. */
692 while (*ptr
&& *ptr
!= '<') ptr
++;
699 warning ("dbx info for template class methods not yet supported");
705 type_identifier_length
= IDENTIFIER_LENGTH (type_encoding
);
707 if (TREE_CODE (methods
) == FUNCTION_DECL
)
709 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
710 fndecl
= TREE_VEC_ELT (methods
, 0);
711 else fndecl
= TREE_VEC_ELT (methods
, 1);
715 tree name
= DECL_NAME (fndecl
);
718 /* Group together all the methods for the same operation.
719 These differ in the types of the arguments. */
720 for (last
= NULL_TREE
;
721 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
722 fndecl
= TREE_CHAIN (fndecl
))
723 /* Output the name of the field (after overloading), as
724 well as the name of the field before overloading, along
725 with its parameter list */
727 /* This is the "mangled" name of the method.
728 It encodes the argument types. */
729 char *debug_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
));
736 if (DECL_IGNORED_P (fndecl
))
739 if (flag_minimal_debug
)
741 /* Detect ordinary methods because their mangled names
742 start with the operation name. */
743 if (!strncmp (IDENTIFIER_POINTER (name
), debug_name
,
744 IDENTIFIER_LENGTH (name
)))
746 debug_name
+= IDENTIFIER_LENGTH (name
);
747 if (debug_name
[0] == '_' && debug_name
[1] == '_')
749 char *method_name
= debug_name
+ 2;
750 /* Get past const and volatile qualifiers. */
751 while (*method_name
== 'C' || *method_name
== 'V')
753 if (! strncmp (method_name
,
754 IDENTIFIER_POINTER (type_encoding
),
755 type_identifier_length
))
756 method_name
+= type_identifier_length
;
757 debug_name
= method_name
;
760 /* Detect constructors by their style of name mangling. */
761 else if (debug_name
[0] == '_' && debug_name
[1] == '_')
763 char *ctor_name
= debug_name
+ 2;
764 while (*ctor_name
== 'C' || *ctor_name
== 'V')
766 if (!strncmp (IDENTIFIER_POINTER (type_encoding
), ctor_name
,
767 type_identifier_length
))
768 debug_name
= ctor_name
+ type_identifier_length
;
770 /* The other alternative is a destructor. */
774 /* Output the operation name just once, for the first method
778 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (name
));
779 CHARS (IDENTIFIER_LENGTH (name
) + 2);
784 dbxout_type (TREE_TYPE (fndecl
), 0, destructor
);
786 dbxout_type_method_1 (fndecl
, debug_name
);
796 /* Output a reference to a type. If the type has not yet been
797 described in the dbx output, output its definition now.
798 For a type already defined, just refer to its definition
799 using the type number.
801 If FULL is nonzero, and the type has been described only with
802 a forward-reference, output the definition now.
803 If FULL is zero in this case, just refer to the forward-reference
804 using the number previously allocated.
806 If SHOW_ARG_TYPES is nonzero, we output a description of the argument
807 types for a METHOD_TYPE. */
810 dbxout_type (type
, full
, show_arg_types
)
817 /* If there was an input error and we don't really have a type,
818 avoid crashing and write something that is at least valid
819 by assuming `int'. */
820 if (type
== error_mark_node
)
821 type
= integer_type_node
;
824 type
= TYPE_MAIN_VARIANT (type
);
826 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
827 && DECL_IGNORED_P (TYPE_NAME (type
)))
831 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
833 /* Type has no dbx number assigned. Assign next available number. */
834 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
836 /* Make sure type vector is long enough to record about this type. */
838 if (next_type_number
== typevec_len
)
840 typevec
= (enum typestatus
*) xrealloc (typevec
, typevec_len
* 2 * sizeof typevec
[0]);
841 bzero (typevec
+ typevec_len
, typevec_len
* sizeof typevec
[0]);
846 /* Output the number of this type, to refer to it. */
847 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
850 #ifdef DBX_TYPE_DEFINED
851 if (DBX_TYPE_DEFINED (type
))
855 /* If this type's definition has been output or is now being output,
858 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)])
863 /* If we have already had a cross reference,
864 and either that's all we want or that's the best we could do,
865 don't repeat the cross reference.
866 Sun dbx crashes if we do. */
867 if (! full
|| TYPE_SIZE (type
) == 0
868 /* No way in DBX fmt to describe a variable size. */
869 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
877 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
878 leave the type-number completely undefined rather than output
879 a cross-reference. */
880 if (TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
881 || TREE_CODE (type
) == ENUMERAL_TYPE
)
883 if ((TYPE_NAME (type
) != 0 && !full
)
884 || TYPE_SIZE (type
) == 0)
886 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_XREF
;
891 /* Output a definition now. */
893 fprintf (asmfile
, "=");
896 /* Mark it as defined, so that if it is self-referent
897 we will not get into an infinite recursion of definitions. */
899 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_DEFINED
;
901 switch (TREE_CODE (type
))
905 /* For a void type, just define it as itself; ie, "5=5".
906 This makes us consider it defined
907 without saying what it is. The debugger will make it
908 a void type when the reference is seen, and nothing will
909 ever override that default. */
910 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
915 if (type
== char_type_node
&& ! TREE_UNSIGNED (type
))
916 /* Output the type `char' as a subrange of itself!
917 I don't understand this definition, just copied it
918 from the output of pcc.
919 This used to use `r2' explicitly and we used to
920 take care to make sure that `char' was type number 2. */
921 fprintf (asmfile
, "r%d;0;127;", TYPE_SYMTAB_ADDRESS (type
));
923 else if (TYPE_PRECISION (type
) > BITS_PER_WORD
)
925 /* This used to say `r1' and we used to take care
926 to make sure that `int' was type number 1. */
927 fprintf (asmfile
, "r%d;", TYPE_SYMTAB_ADDRESS (integer_type_node
));
928 print_int_cst_octal (TYPE_MIN_VALUE (type
));
929 fprintf (asmfile
, ";");
930 print_int_cst_octal (TYPE_MAX_VALUE (type
));
931 fprintf (asmfile
, ";");
935 /* Output other integer types as subranges of `int'. */
936 /* This used to say `r1' and we used to take care
937 to make sure that `int' was type number 1. */
938 fprintf (asmfile
, "r%d;%d;%d;",
939 TYPE_SYMTAB_ADDRESS (integer_type_node
),
940 TREE_INT_CST_LOW (TYPE_MIN_VALUE (type
)),
941 TREE_INT_CST_LOW (TYPE_MAX_VALUE (type
)));
946 /* This used to say `r1' and we used to take care
947 to make sure that `int' was type number 1. */
948 fprintf (asmfile
, "r%d;%d;0;", TYPE_SYMTAB_ADDRESS (integer_type_node
),
949 TREE_INT_CST_LOW (size_in_bytes (type
)));
954 /* Output "a" followed by a range type definition
955 for the index type of the array
956 followed by a reference to the target-type.
957 ar1;0;N;M for an array of type M and size N. */
958 /* This used to say `r1' and we used to take care
959 to make sure that `int' was type number 1. */
960 fprintf (asmfile
, "ar%d;0;%d;", TYPE_SYMTAB_ADDRESS (integer_type_node
),
963 ? TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)))
966 dbxout_type (TREE_TYPE (type
), 0, 0);
972 int i
, n_baseclasses
= 0;
974 if (TYPE_BINFO (type
) != 0 && TYPE_BINFO_BASETYPES (type
) != 0)
975 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
977 /* Output a structure type. */
978 if ((TYPE_NAME (type
) != 0
979 #if 0 /* Tiemann says this creates output tha "confuses GDB".
980 Too bad the info is so vague. Hope this doesn't lose. */
981 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
982 && DECL_IGNORED_P (TYPE_NAME (type
)))
985 || TYPE_SIZE (type
) == 0
986 /* No way in DBX fmt to describe a variable size. */
987 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
989 /* If the type is just a cross reference, output one
990 and mark the type as partially described.
991 If it later becomes defined, we will output
993 If the type has a name, don't nest its definition within
994 another type's definition; instead, output an xref
995 and let the definition come when the name is defined. */
996 fprintf (asmfile
, (TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu");
998 #if 0 /* This assertion is legitimately false in C++. */
999 /* We shouldn't be outputting a reference to a type before its
1000 definition unless the type has a tag name.
1001 A typedef name without a tag name should be impossible. */
1002 if (TREE_CODE (TYPE_NAME (type
)) != IDENTIFIER_NODE
)
1005 dbxout_type_name (type
);
1006 fprintf (asmfile
, ":");
1007 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_XREF
;
1010 tem
= size_in_bytes (type
);
1012 /* Identify record or union, and print its size. */
1013 fprintf (asmfile
, (TREE_CODE (type
) == RECORD_TYPE
) ? "s%d" : "u%d",
1014 TREE_INT_CST_LOW (tem
));
1016 if (use_gdb_dbx_extensions
)
1020 have_used_extensions
= 1;
1021 fprintf (asmfile
, "!%d,", n_baseclasses
);
1025 for (i
= 0; i
< n_baseclasses
; i
++)
1027 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)), i
);
1028 if (use_gdb_dbx_extensions
)
1030 have_used_extensions
= 1;
1031 putc (TREE_VIA_VIRTUAL (child
) ? '1'
1034 putc (TREE_VIA_PUBLIC (child
) ? '2'
1037 fprintf (asmfile
, "%d,",
1038 TREE_INT_CST_LOW (BINFO_OFFSET (child
)) * BITS_PER_UNIT
);
1040 dbxout_type (BINFO_TYPE (child
), 0, 0);
1041 putc (';', asmfile
);
1045 /* Print out the base class information with fields
1046 which have the same names at the types they hold. */
1047 dbxout_type_name (BINFO_TYPE (child
));
1048 putc (':', asmfile
);
1049 dbxout_type (BINFO_TYPE (child
), full
, 0);
1050 fprintf (asmfile
, ",%d,%d;",
1051 TREE_INT_CST_LOW (BINFO_OFFSET (child
)) * BITS_PER_UNIT
,
1052 TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child
)))) * BITS_PER_UNIT
);
1060 /* Write out the field declarations. */
1061 dbxout_type_fields (type
);
1062 if (use_gdb_dbx_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1064 have_used_extensions
= 1;
1065 dbxout_type_methods (type
);
1067 putc (';', asmfile
);
1069 if (use_gdb_dbx_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1070 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1071 && TYPE_VFIELD (type
))
1073 have_used_extensions
= 1;
1075 /* Tell GDB+ that it may keep reading. */
1076 putc ('~', asmfile
);
1078 /* We need to write out info about what field this class
1079 uses as its "main" vtable pointer field, because if this
1080 field is inherited from a base class, GDB cannot necessarily
1081 figure out which field it's using in time. */
1082 if (TYPE_VFIELD (type
))
1084 putc ('%', asmfile
);
1085 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0, 0);
1087 putc (';', asmfile
);
1093 if ((TYPE_NAME (type
) != 0 && !full
1094 && (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1095 && ! DECL_IGNORED_P (TYPE_NAME (type
))))
1096 || TYPE_SIZE (type
) == 0)
1098 fprintf (asmfile
, "xe");
1100 dbxout_type_name (type
);
1101 typevec
[TYPE_SYMTAB_ADDRESS (type
)] = TYPE_XREF
;
1102 fprintf (asmfile
, ":");
1105 #ifdef DBX_OUTPUT_ENUM
1106 DBX_OUTPUT_ENUM (asmfile
, type
);
1108 putc ('e', asmfile
);
1110 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1112 fprintf (asmfile
, "%s:%d,", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)),
1113 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1114 CHARS (11 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)));
1115 if (TREE_CHAIN (tem
) != 0)
1118 putc (';', asmfile
);
1124 putc ('*', asmfile
);
1126 dbxout_type (TREE_TYPE (type
), 0, 0);
1130 if (use_gdb_dbx_extensions
)
1132 have_used_extensions
= 1;
1133 putc ('#', asmfile
);
1135 if (flag_minimal_debug
&& !show_arg_types
)
1137 /* Normally, just output the return type.
1138 The argument types are encoded in the method name. */
1139 putc ('#', asmfile
);
1140 dbxout_type (TREE_TYPE (type
), 0, 0);
1141 putc (';', asmfile
);
1146 /* When outputing destructors, we need to write
1147 the argument types out longhand. */
1148 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0, 0);
1149 putc (',', asmfile
);
1151 dbxout_type (TREE_TYPE (type
), 0, 0);
1152 dbxout_args (TYPE_ARG_TYPES (type
));
1153 putc (';', asmfile
);
1159 /* Treat it as a function type. */
1160 dbxout_type (TREE_TYPE (type
), 0, 0);
1165 if (use_gdb_dbx_extensions
)
1167 have_used_extensions
= 1;
1168 putc ('@', asmfile
);
1170 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0, 0);
1171 putc (',', asmfile
);
1173 dbxout_type (TREE_TYPE (type
), 0, 0);
1177 /* Should print as an int, because it is really
1179 dbxout_type (integer_type_node
, 0, 0);
1183 case REFERENCE_TYPE
:
1184 if (use_gdb_dbx_extensions
)
1185 have_used_extensions
= 1;
1186 putc (use_gdb_dbx_extensions
? '&' : '*', asmfile
);
1188 dbxout_type (TREE_TYPE (type
), 0, 0);
1192 putc ('f', asmfile
);
1194 dbxout_type (TREE_TYPE (type
), 0, 0);
1202 /* Print the value of integer constant C, in octal,
1203 handling double precision. */
1206 print_int_cst_octal (c
)
1209 unsigned int high
= TREE_INT_CST_HIGH (c
);
1210 unsigned int low
= TREE_INT_CST_LOW (c
);
1211 int excess
= (3 - (HOST_BITS_PER_INT
% 3));
1213 fprintf (asmfile
, "0");
1217 print_octal (high
, HOST_BITS_PER_INT
/ 3);
1218 print_octal (low
, HOST_BITS_PER_INT
/ 3);
1222 unsigned int beg
= high
>> excess
;
1224 = ((high
& ((1 << excess
) - 1)) << (3 - excess
)
1225 | (low
>> (HOST_BITS_PER_INT
/ 3 * 3)));
1226 unsigned int end
= low
& ((1 << (HOST_BITS_PER_INT
/ 3 * 3)) - 1);
1227 fprintf (asmfile
, "%o%01o", beg
, middle
);
1228 print_octal (end
, HOST_BITS_PER_INT
/ 3);
1233 print_octal (value
, digits
)
1239 for (i
= digits
- 1; i
>= 0; i
--)
1240 fprintf (asmfile
, "%01o", ((value
>> (3 * i
)) & 7));
1243 /* Output the name of type TYPE, with no punctuation.
1244 Such names can be set up either by typedef declarations
1245 or by struct, enum and union tags. */
1248 dbxout_type_name (type
)
1252 if (TYPE_NAME (type
) == 0)
1254 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
1256 t
= TYPE_NAME (type
);
1258 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1260 t
= DECL_NAME (TYPE_NAME (type
));
1265 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
1266 CHARS (IDENTIFIER_LENGTH (t
));
1269 /* Output a .stabs for the symbol defined by DECL,
1270 which must be a ..._DECL node in the normal namespace.
1271 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1272 LOCAL is nonzero if the scope is less than the entire file. */
1275 dbxout_symbol (decl
, local
)
1280 tree type
= TREE_TYPE (decl
);
1281 tree context
= NULL_TREE
;
1284 /* Cast avoids warning in old compilers. */
1285 current_sym_code
= (STAB_CODE_TYPE
) 0;
1286 current_sym_value
= 0;
1287 current_sym_addr
= 0;
1289 /* Ignore nameless syms, but don't ignore type tags. */
1291 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
1292 || DECL_IGNORED_P (decl
))
1295 dbxout_prepare_symbol (decl
);
1297 /* The output will always start with the symbol name,
1298 so always count that in the length-output-so-far. */
1300 if (DECL_NAME (decl
) != 0)
1301 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
1303 switch (TREE_CODE (decl
))
1306 /* Enum values are defined by defining the enum type. */
1310 if (DECL_RTL (decl
) == 0)
1312 if (TREE_EXTERNAL (decl
))
1314 /* Don't mention a nested function under its parent. */
1315 context
= decl_function_context (decl
);
1316 if (context
== current_function_decl
)
1318 if (GET_CODE (DECL_RTL (decl
)) != MEM
1319 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
1323 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
1324 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1325 TREE_PUBLIC (decl
) ? 'F' : 'f');
1327 current_sym_code
= N_FUN
;
1328 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1330 if (TREE_TYPE (type
))
1331 dbxout_type (TREE_TYPE (type
), 0, 0);
1333 dbxout_type (void_type_node
, 0, 0);
1335 /* For a nested function, when that function is compiled,
1336 mention the containing function name
1337 as well as (since dbx wants it) our own assembler-name. */
1339 fprintf (asmfile
, ",%s,%s",
1340 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1341 IDENTIFIER_POINTER (DECL_NAME (context
)));
1343 dbxout_finish_symbol (decl
);
1348 /* This seems all wrong. Outputting most kinds of types gives no name
1349 at all. A true definition gives no name; a cross-ref for a
1350 structure can give the tag name, but not a type name.
1351 It seems that no typedef name is defined by outputting a type. */
1353 /* If this typedef name was defined by outputting the type,
1354 don't duplicate it. */
1355 if (typevec
[TYPE_SYMTAB_ADDRESS (type
)] == TYPE_DEFINED
1356 && TYPE_NAME (TREE_TYPE (decl
)) == decl
)
1359 /* Don't output the same typedef twice.
1360 And don't output what language-specific stuff doesn't want output. */
1361 if (TREE_ASM_WRITTEN (decl
) || DECL_IGNORED_P (decl
))
1369 if (DECL_NAME (decl
))
1371 /* Nonzero means we must output a tag as well as a typedef. */
1374 /* Output typedef name. */
1375 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
,
1376 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1378 /* #ifndef DBX_NO_EXTRA_TAGS rms: I think this is no longer needed. */
1379 /* This section makes absolutely no sense to me. Why would a tag
1380 ever be needed at this point? The result of this is that any
1381 structure typedef with the tag omitted is treated as if the
1382 tag was given to be the same as the typedef name. Probably
1383 no harm in it, unless the programmer used the same name for
1384 the tag of a *different* structure. At any rate, Alliant's
1385 debugger would want the tag output before the typedef, so
1386 this code still loses. -- hyc */
1388 /* Short cut way to output a tag also. */
1389 if ((TREE_CODE (type
) == RECORD_TYPE
1390 || TREE_CODE (type
) == UNION_TYPE
)
1391 && TYPE_NAME (type
) == decl
)
1393 if (use_gdb_dbx_extensions
&& have_used_extensions
)
1395 putc ('T', asmfile
);
1396 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
1403 putc ('t', asmfile
);
1404 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1406 dbxout_type (type
, 1, 0);
1407 dbxout_finish_symbol (decl
);
1410 if (tag_needed
&& TYPE_NAME (type
) != 0
1411 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1413 /* For a TYPE_DECL with no name, but the type has a name,
1415 This is what represents `struct foo' with no typedef. */
1416 /* In C++, the name of a type is the corresponding typedef.
1417 In C, it is an IDENTIFIER_NODE. */
1418 tree name
= TYPE_NAME (type
);
1419 if (TREE_CODE (name
) == TYPE_DECL
)
1420 name
= DECL_NAME (name
);
1422 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1423 current_sym_value
= 0;
1424 current_sym_addr
= 0;
1425 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1427 fprintf (asmfile
, "%s \"%s:T", ASM_STABS_OP
,
1428 IDENTIFIER_POINTER (name
));
1429 dbxout_type (type
, 1, 0);
1430 dbxout_finish_symbol (0);
1433 /* Prevent duplicate output of a typedef. */
1434 TREE_ASM_WRITTEN (decl
) = 1;
1439 /* Parm decls go in their own separate chains
1440 and are output by dbxout_reg_parms and dbxout_parms. */
1444 /* Named return value, treat like a VAR_DECL. */
1446 if (DECL_RTL (decl
) == 0)
1448 /* Don't mention a variable that is external.
1449 Let the file that defines it describe it. */
1450 if (TREE_EXTERNAL (decl
))
1453 /* If the variable is really a constant
1454 and not written in memory, inform the debugger. */
1455 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
1456 && DECL_INITIAL (decl
) != 0
1457 && ! TREE_ASM_WRITTEN (decl
)
1458 && (DECL_FIELD_CONTEXT (decl
) == NULL_TREE
1459 || TREE_CODE (DECL_FIELD_CONTEXT (decl
)) == BLOCK
))
1461 if (TREE_PUBLIC (decl
) == 0)
1463 /* The sun4 assembler does not grok this. */
1464 char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1465 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
1466 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
1468 int ival
= TREE_INT_CST_LOW (DECL_INITIAL (decl
));
1469 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1470 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile
, name
, ival
);
1472 fprintf (asmfile
, "%s \"%s:c=i%d\",0x%x,0,0,0\n",
1473 ASM_STABS_OP
, name
, ival
, N_LSYM
);
1477 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
1479 /* don't know how to do this yet. */
1483 /* else it is something we handle like a normal variable. */
1486 DECL_RTL (decl
) = eliminate_regs (DECL_RTL (decl
));
1487 #ifdef LEAF_REG_REMAP
1489 leaf_renumber_regs_insn (DECL_RTL (decl
));
1492 /* Don't mention a variable at all
1493 if it was completely optimized into nothingness.
1495 If DECL was from an inline function, then it's rtl
1496 is not identically the rtl that was used in this
1497 particular compilation. */
1498 if (GET_CODE (DECL_RTL (decl
)) == REG
)
1500 regno
= REGNO (DECL_RTL (decl
));
1501 if (regno
>= FIRST_PSEUDO_REGISTER
)
1502 regno
= reg_renumber
[REGNO (DECL_RTL (decl
))];
1506 else if (GET_CODE (DECL_RTL (decl
)) == SUBREG
)
1508 rtx value
= DECL_RTL (decl
);
1510 while (GET_CODE (value
) == SUBREG
)
1512 offset
+= SUBREG_WORD (value
);
1513 value
= SUBREG_REG (value
);
1515 if (GET_CODE (value
) == REG
)
1517 regno
= REGNO (value
);
1518 if (regno
>= FIRST_PSEUDO_REGISTER
)
1519 regno
= reg_renumber
[REGNO (value
)];
1525 /* The kind-of-variable letter depends on where
1526 the variable is and on the scope of its name:
1527 G and N_GSYM for static storage and global scope,
1528 S for static storage and file scope,
1529 V for static storage and local scope,
1530 for those two, use N_LCSYM if data is in bss segment,
1531 N_STSYM if in data segment, N_FUN otherwise.
1532 (We used N_FUN originally, then changed to N_STSYM
1533 to please GDB. However, it seems that confused ld.
1534 Now GDB has been fixed to like N_FUN, says Kingdon.)
1535 no letter at all, and N_LSYM, for auto variable,
1536 r and N_RSYM for register variable. */
1538 if (GET_CODE (DECL_RTL (decl
)) == MEM
1539 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == SYMBOL_REF
)
1541 if (TREE_PUBLIC (decl
))
1544 current_sym_code
= N_GSYM
;
1548 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1550 letter
= decl_function_context (decl
) ? 'V' : 'S';
1552 if (!DECL_INITIAL (decl
))
1553 current_sym_code
= N_LCSYM
;
1554 else if (TREE_READONLY (decl
) && ! TREE_THIS_VOLATILE (decl
))
1555 /* This is not quite right, but it's the closest
1556 of all the codes that Unix defines. */
1557 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
1560 /* Ultrix `as' seems to need this. */
1561 #ifdef DBX_STATIC_STAB_DATA_SECTION
1564 current_sym_code
= N_STSYM
;
1568 else if (regno
>= 0)
1571 current_sym_code
= N_RSYM
;
1572 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
1574 else if (GET_CODE (DECL_RTL (decl
)) == SUBREG
)
1576 rtx value
= DECL_RTL (decl
);
1578 while (GET_CODE (value
) == SUBREG
)
1580 offset
+= SUBREG_WORD (value
);
1581 value
= SUBREG_REG (value
);
1584 current_sym_code
= N_RSYM
;
1585 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (value
) + offset
);
1587 else if (GET_CODE (DECL_RTL (decl
)) == MEM
1588 && (GET_CODE (XEXP (DECL_RTL (decl
), 0)) == MEM
1589 || (GET_CODE (XEXP (DECL_RTL (decl
), 0)) == REG
1590 && REGNO (XEXP (DECL_RTL (decl
), 0)) != FRAME_POINTER_REGNUM
)))
1591 /* If the value is indirect by memory or by a register
1592 that isn't the frame pointer
1593 then it means the object is variable-sized and address through
1594 that register or stack slot. DBX has no way to represent this
1595 so all we can do is output the variable as a pointer.
1596 If it's not a parameter, ignore it.
1597 (VAR_DECLs like this can be made by integrate.c.) */
1599 if (GET_CODE (XEXP (DECL_RTL (decl
), 0)) == REG
)
1602 current_sym_code
= N_RSYM
;
1603 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (DECL_RTL (decl
), 0)));
1607 current_sym_code
= N_LSYM
;
1608 /* DECL_RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
1609 We want the value of that CONST_INT. */
1611 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (DECL_RTL (decl
), 0), 0));
1614 /* Effectively do build_pointer_type, but don't cache this type,
1615 since it might be temporary whereas the type it points to
1616 might have been saved for inlining. */
1617 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
1618 type
= make_node (POINTER_TYPE
);
1619 TREE_TYPE (type
) = TREE_TYPE (decl
);
1621 else if (GET_CODE (DECL_RTL (decl
)) == MEM
1622 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == REG
)
1624 current_sym_code
= N_LSYM
;
1625 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (DECL_RTL (decl
), 0));
1627 else if (GET_CODE (DECL_RTL (decl
)) == MEM
1628 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == PLUS
1629 && GET_CODE (XEXP (XEXP (DECL_RTL (decl
), 0), 1)) == CONST_INT
)
1631 current_sym_code
= N_LSYM
;
1632 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
1633 We want the value of that CONST_INT. */
1634 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (DECL_RTL (decl
), 0));
1636 else if (GET_CODE (DECL_RTL (decl
)) == MEM
1637 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == CONST
)
1639 /* Handle an obscure case which can arise when optimizing and
1640 when there are few available registers. (This is *always*
1641 the case for i386/i486 targets). The DECL_RTL looks like
1642 (MEM (CONST ...)) even though this variable is a local `auto'
1643 or a local `register' variable. In effect, what has happened
1644 is that the reload pass has seen that all assignments and
1645 references for one such a local variable can be replaced by
1646 equivalent assignments and references to some static storage
1647 variable, thereby avoiding the need for a register. In such
1648 cases we're forced to lie to debuggers and tell them that
1649 this variable was itself `static'. */
1650 current_sym_code
= N_LCSYM
;
1652 current_sym_addr
= XEXP (XEXP (DECL_RTL (decl
), 0), 0);
1655 /* Address might be a MEM, when DECL is a variable-sized object.
1656 Or it might be const0_rtx, meaning previous passes
1657 want us to ignore this variable. */
1660 /* Ok, start a symtab entry and output the variable name. */
1663 #ifdef DBX_STATIC_BLOCK_START
1664 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
1667 /* One slight hitch: if this is a VAR_DECL which is a static
1668 class member, we must put out the mangled name instead of the
1672 /* Note also that static member (variable) names DO NOT begin
1673 with underscores in .stabs directives. */
1674 if (DECL_LANG_SPECIFIC (decl
))
1675 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
1677 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1678 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
, name
);
1680 if (letter
) putc (letter
, asmfile
);
1681 dbxout_type (type
, 0, 0);
1682 dbxout_finish_symbol (decl
);
1684 #ifdef DBX_STATIC_BLOCK_END
1685 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
1692 dbxout_prepare_symbol (decl
)
1696 char *filename
= DECL_SOURCE_FILE (decl
);
1698 dbxout_source_file (asmfile
, filename
);
1703 dbxout_finish_symbol (sym
)
1706 #ifdef DBX_FINISH_SYMBOL
1707 DBX_FINISH_SYMBOL (sym
);
1712 line
= DECL_SOURCE_LINE (sym
);
1715 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
1716 if (current_sym_addr
)
1717 output_addr_const (asmfile
, current_sym_addr
);
1719 fprintf (asmfile
, "%d", current_sym_value
);
1720 putc ('\n', asmfile
);
1724 /* Output definitions of all the decls in a chain. */
1732 dbxout_symbol (syms
, 1);
1733 syms
= TREE_CHAIN (syms
);
1737 /* The following two functions output definitions of function parameters.
1738 Each parameter gets a definition locating it in the parameter list.
1739 Each parameter that is a register variable gets a second definition
1740 locating it in the register.
1742 Printing or argument lists in gdb uses the definitions that
1743 locate in the parameter list. But reference to the variable in
1744 expressions uses preferentially the definition as a register. */
1746 /* Output definitions, referring to storage in the parmlist,
1747 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
1750 dbxout_parms (parms
)
1753 for (; parms
; parms
= TREE_CHAIN (parms
))
1754 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
1756 dbxout_prepare_symbol (parms
);
1758 /* Perform any necessary register eliminations on the parameter's rtl,
1759 so that the debugging output will be accurate. */
1760 DECL_INCOMING_RTL (parms
)
1761 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, 0);
1762 DECL_RTL (parms
) = eliminate_regs (DECL_RTL (parms
), 0, 0);
1763 #ifdef LEAF_REG_REMAP
1766 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
1767 leaf_renumber_regs_insn (DECL_RTL (parms
));
1771 if (PARM_PASSED_IN_MEMORY (parms
))
1773 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
1775 /* ??? Here we assume that the parm address is indexed
1776 off the frame pointer or arg pointer.
1777 If that is not true, we produce meaningless results,
1778 but do not crash. */
1779 if (GET_CODE (addr
) == PLUS
1780 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
1781 current_sym_value
= INTVAL (XEXP (addr
, 1));
1783 current_sym_value
= 0;
1785 current_sym_code
= N_PSYM
;
1786 current_sym_addr
= 0;
1789 if (DECL_NAME (parms
))
1791 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
1793 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
1794 IDENTIFIER_POINTER (DECL_NAME (parms
)),
1795 DBX_MEMPARM_STABS_LETTER
);
1799 current_sym_nchars
= 8;
1800 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
1801 DBX_MEMPARM_STABS_LETTER
);
1804 if (GET_CODE (DECL_RTL (parms
)) == REG
1805 && REGNO (DECL_RTL (parms
)) >= 0
1806 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
1807 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
1810 int original_value
= current_sym_value
;
1812 /* This is the case where the parm is passed as an int or double
1813 and it is converted to a char, short or float and stored back
1814 in the parmlist. In this case, describe the parm
1815 with the variable's declared type, and adjust the address
1816 if the least significant bytes (which we are using) are not
1818 #if BYTES_BIG_ENDIAN
1819 if (TREE_TYPE (parms
) != DECL_ARG_TYPE (parms
))
1820 current_sym_value
+= (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms
)))
1821 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
))));
1824 if (GET_CODE (DECL_RTL (parms
)) == MEM
1825 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == PLUS
1826 && GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == CONST_INT
1827 && INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == current_sym_value
)
1828 dbxout_type (TREE_TYPE (parms
), 0, 0);
1831 current_sym_value
= original_value
;
1832 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
1835 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
1836 dbxout_finish_symbol (parms
);
1838 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
1841 char regparm_letter
;
1842 /* Parm passed in registers and lives in registers or nowhere. */
1844 current_sym_code
= DBX_REGPARM_STABS_CODE
;
1845 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
1846 current_sym_addr
= 0;
1848 /* If parm lives in a register, use that register;
1849 pretend the parm was passed there. It would be more consistent
1850 to describe the register where the parm was passed,
1851 but in practice that register usually holds something else. */
1852 if (REGNO (DECL_RTL (parms
)) >= 0
1853 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
1854 best_rtl
= DECL_RTL (parms
);
1855 /* If the parm lives nowhere,
1856 use the register where it was passed. */
1858 best_rtl
= DECL_INCOMING_RTL (parms
);
1859 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
1862 if (DECL_NAME (parms
))
1864 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
1865 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
1866 IDENTIFIER_POINTER (DECL_NAME (parms
)),
1871 current_sym_nchars
= 8;
1872 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
1876 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
1877 dbxout_finish_symbol (parms
);
1879 else if (GET_CODE (DECL_RTL (parms
)) == MEM
1880 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
1881 && rtx_equal_p (XEXP (DECL_RTL (parms
), 0),
1882 DECL_INCOMING_RTL (parms
)))
1884 /* Parm was passed via invisible reference.
1885 That is, its address was passed in a register.
1886 Output it as if it lived in that register.
1887 The debugger will know from the type
1888 that it was actually passed by invisible reference. */
1890 char regparm_letter
;
1891 /* Parm passed in registers and lives in registers or nowhere. */
1893 current_sym_code
= DBX_REGPARM_STABS_CODE
;
1894 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
1896 /* DECL_RTL looks like (MEM (REG...). Get the register number. */
1897 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
1898 current_sym_addr
= 0;
1901 if (DECL_NAME (parms
))
1903 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
1905 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
1906 IDENTIFIER_POINTER (DECL_NAME (parms
)),
1907 DBX_REGPARM_STABS_LETTER
);
1911 current_sym_nchars
= 8;
1912 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
1913 DBX_REGPARM_STABS_LETTER
);
1916 dbxout_type (TREE_TYPE (parms
), 0, 0);
1917 dbxout_finish_symbol (parms
);
1919 else if (GET_CODE (DECL_RTL (parms
)) == MEM
1920 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
)
1922 /* Parm was passed in registers but lives on the stack. */
1924 current_sym_code
= N_PSYM
;
1925 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
1926 in which case we want the value of that CONST_INT,
1927 or (MEM (REG ...)) or (MEM (MEM ...)),
1928 in which case we use a value of zero. */
1929 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
1930 || GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
1931 current_sym_value
= 0;
1933 current_sym_value
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
1934 current_sym_addr
= 0;
1937 if (DECL_NAME (parms
))
1939 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
1941 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
1942 IDENTIFIER_POINTER (DECL_NAME (parms
)),
1943 DBX_MEMPARM_STABS_LETTER
);
1947 current_sym_nchars
= 8;
1948 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
1949 DBX_MEMPARM_STABS_LETTER
);
1953 = DEBUGGER_ARG_OFFSET (current_sym_value
,
1954 XEXP (DECL_RTL (parms
), 0));
1955 dbxout_type (TREE_TYPE (parms
), 0, 0);
1956 dbxout_finish_symbol (parms
);
1961 /* Output definitions for the places where parms live during the function,
1962 when different from where they were passed, when the parms were passed
1965 It is not useful to do this for parms passed in registers
1966 that live during the function in different registers, because it is
1967 impossible to look in the passed register for the passed value,
1968 so we use the within-the-function register to begin with.
1970 PARMS is a chain of PARM_DECL nodes. */
1973 dbxout_reg_parms (parms
)
1976 for (; parms
; parms
= TREE_CHAIN (parms
))
1977 if (DECL_NAME (parms
))
1979 dbxout_prepare_symbol (parms
);
1981 /* Report parms that live in registers during the function
1982 but were passed in memory. */
1983 if (GET_CODE (DECL_RTL (parms
)) == REG
1984 && REGNO (DECL_RTL (parms
)) >= 0
1985 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
1986 && PARM_PASSED_IN_MEMORY (parms
))
1988 current_sym_code
= N_RSYM
;
1989 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms
)));
1990 current_sym_addr
= 0;
1993 if (DECL_NAME (parms
))
1995 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
1996 fprintf (asmfile
, "%s \"%s:r", ASM_STABS_OP
,
1997 IDENTIFIER_POINTER (DECL_NAME (parms
)));
2001 current_sym_nchars
= 8;
2002 fprintf (asmfile
, "%s \"(anon):r", ASM_STABS_OP
);
2004 dbxout_type (TREE_TYPE (parms
), 0, 0);
2005 dbxout_finish_symbol (parms
);
2007 /* Report parms that live in memory but not where they were passed. */
2008 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2009 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == PLUS
2010 && GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == CONST_INT
2011 && PARM_PASSED_IN_MEMORY (parms
)
2012 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
2014 #if 0 /* ??? It is not clear yet what should replace this. */
2015 int offset
= DECL_OFFSET (parms
) / BITS_PER_UNIT
;
2016 /* A parm declared char is really passed as an int,
2017 so it occupies the least significant bytes.
2018 On a big-endian machine those are not the low-numbered ones. */
2019 #if BYTES_BIG_ENDIAN
2020 if (offset
!= -1 && TREE_TYPE (parms
) != DECL_ARG_TYPE (parms
))
2021 offset
+= (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms
)))
2022 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
))));
2024 if (INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) != offset
) {...}
2026 current_sym_code
= N_LSYM
;
2027 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (DECL_RTL (parms
), 0));
2028 current_sym_addr
= 0;
2030 if (DECL_NAME (parms
))
2032 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2033 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
,
2034 IDENTIFIER_POINTER (DECL_NAME (parms
)));
2038 current_sym_nchars
= 8;
2039 fprintf (asmfile
, "%s \"(anon):", ASM_STABS_OP
);
2041 dbxout_type (TREE_TYPE (parms
), 0, 0);
2042 dbxout_finish_symbol (parms
);
2047 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2048 output definitions of those names, in raw form */
2056 putc (',', asmfile
);
2057 dbxout_type (TREE_VALUE (args
), 0, 0);
2059 args
= TREE_CHAIN (args
);
2063 /* Given a chain of ..._TYPE nodes,
2064 find those which have typedef names and output those names.
2065 This is to ensure those types get output. */
2068 dbxout_types (types
)
2069 register tree types
;
2073 if (TYPE_NAME (types
)
2074 && TREE_CODE (TYPE_NAME (types
)) == TYPE_DECL
2075 && ! TREE_ASM_WRITTEN (TYPE_NAME (types
)))
2076 dbxout_symbol (TYPE_NAME (types
), 1);
2077 types
= TREE_CHAIN (types
);
2081 /* Output everything about a symbol block (a BLOCK node
2082 that represents a scope level),
2083 including recursive output of contained blocks.
2085 BLOCK is the BLOCK node.
2086 DEPTH is its depth within containing symbol blocks.
2087 ARGS is usually zero; but for the outermost block of the
2088 body of a function, it is a chain of PARM_DECLs for the function parameters.
2089 We output definitions of all the register parms
2090 as if they were local variables of that block.
2092 If -g1 was used, we count blocks just the same, but output nothing
2093 except for the outermost block.
2095 Actually, BLOCK may be several blocks chained together.
2096 We handle them all in sequence. */
2099 dbxout_block (block
, depth
, args
)
2100 register tree block
;
2108 /* Ignore blocks never expanded or otherwise marked as real. */
2109 if (TREE_USED (block
))
2111 #ifndef DBX_LBRAC_FIRST
2112 /* In dbx format, the syms of a block come before the N_LBRAC. */
2113 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2114 dbxout_syms (BLOCK_VARS (block
));
2116 dbxout_reg_parms (args
);
2119 /* Now output an N_LBRAC symbol to represent the beginning of
2120 the block. Use the block's tree-walk order to generate
2121 the assembler symbols LBBn and LBEn
2122 that final will define around the code in this block. */
2123 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2126 blocknum
= next_block_number
++;
2127 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
2129 if (BLOCK_HANDLER_BLOCK (block
))
2131 /* A catch block. Must precede N_LBRAC. */
2132 tree decl
= BLOCK_VARS (block
);
2135 #ifdef DBX_OUTPUT_CATCH
2136 DBX_OUTPUT_CATCH (asmfile
, decl
, buf
);
2138 fprintf (asmfile
, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP
,
2139 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
2140 assemble_name (asmfile
, buf
);
2141 fprintf (asmfile
, "\n");
2143 decl
= TREE_CHAIN (decl
);
2147 #ifdef DBX_OUTPUT_LBRAC
2148 DBX_OUTPUT_LBRAC (asmfile
, buf
);
2150 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_LBRAC
);
2151 assemble_name (asmfile
, buf
);
2152 fprintf (asmfile
, "\n");
2156 /* Count blocks the same way regardless of debug_info_level. */
2157 next_block_number
++;
2159 #ifdef DBX_LBRAC_FIRST
2160 /* On some weird machines, the syms of a block
2161 come after the N_LBRAC. */
2162 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2163 dbxout_syms (BLOCK_VARS (block
));
2165 dbxout_reg_parms (args
);
2168 /* Output the subblocks. */
2169 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, 0);
2171 /* Refer to the marker for the end of the block. */
2172 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2175 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
2176 #ifdef DBX_OUTPUT_RBRAC
2177 DBX_OUTPUT_RBRAC (asmfile
, buf
);
2179 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_RBRAC
);
2180 assemble_name (asmfile
, buf
);
2181 fprintf (asmfile
, "\n");
2185 block
= BLOCK_CHAIN (block
);
2189 /* Output the information about a function and its arguments and result.
2190 Usually this follows the function's code,
2191 but on some systems, it comes before. */
2194 dbxout_really_begin_function (decl
)
2197 dbxout_symbol (decl
, 0);
2198 dbxout_parms (DECL_ARGUMENTS (decl
));
2199 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
2200 dbxout_symbol (DECL_RESULT (decl
), 1);
2203 /* Called at beginning of output of function definition. */
2206 dbxout_begin_function (decl
)
2209 #ifdef DBX_FUNCTION_FIRST
2210 dbxout_really_begin_function (decl
);
2214 /* Output dbx data for a function definition.
2215 This includes a definition of the function name itself (a symbol),
2216 definitions of the parameters (locating them in the parameter list)
2217 and then output the block that makes up the function's body
2218 (including all the auto variables of the function). */
2221 dbxout_function (decl
)
2224 #ifndef DBX_FUNCTION_FIRST
2225 dbxout_really_begin_function (decl
);
2227 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
2228 #ifdef DBX_OUTPUT_FUNCTION_END
2229 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
2232 #endif /* DBX_DEBUGGING_INFO */