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 /* Nonzero means if the type has methods, only output debugging
120 information if methods are actually written to the asm file. */
122 static int flag_minimal_debug = 1;
124 /* Nonzero if we have actually used any of the GDB extensions
125 to the debugging format. The idea is that we use them for the
126 first time only if there's a strong reason, but once we have done that,
127 we use them whenever convenient. */
129 static int have_used_extensions = 0;
133 /* Typical USG systems don't have stab.h, and they also have
134 no use for DBX-format debugging info. */
136 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
138 #ifdef DEBUG_SYMS_TEXT
139 #define FORCE_TEXT text_section ();
144 #if defined (USG) || defined (NO_STAB_H)
145 #include "gstab.h" /* If doing DBX on sysV, use our own stab.h. */
147 #include <stab.h> /* On BSD, use the system's stab.h. */
149 /* This is a GNU extension we need to reference in this file. */
156 #define STAB_CODE_TYPE enum __stab_debug_code
158 #define STAB_CODE_TYPE int
161 /* 1 if PARM is passed to this function in memory. */
163 #define PARM_PASSED_IN_MEMORY(PARM) \
164 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
166 /* A C expression for the integer offset value of an automatic variable
167 (N_LSYM) having address X (an RTX). */
168 #ifndef DEBUGGER_AUTO_OFFSET
169 #define DEBUGGER_AUTO_OFFSET(X) \
170 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
173 /* A C expression for the integer offset value of an argument (N_PSYM)
174 having address X (an RTX). The nominal offset is OFFSET. */
175 #ifndef DEBUGGER_ARG_OFFSET
176 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
179 /* Stream for writing to assembler file. */
181 static FILE *asmfile;
183 /* Last source file name mentioned in a NOTE insn. */
185 static char *lastfile;
187 /* Current working directory. */
191 enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
193 /* Vector recording the status of describing C data types.
194 When we first notice a data type (a tree node),
195 we assign it a number using next_type_number.
196 That is its index in this vector.
197 The vector element says whether we have yet output
198 the definition of the type. TYPE_XREF says we have
199 output it as a cross-reference only. */
201 enum typestatus *typevec;
203 /* Number of elements of space allocated in `typevec'. */
205 static int typevec_len;
207 /* In dbx output, each type gets a unique number.
208 This is the number for the next type output.
209 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
211 static int next_type_number;
213 /* In dbx output, we must assign symbol-blocks id numbers
214 in the order in which their beginnings are encountered.
215 We output debugging info that refers to the beginning and
216 end of the ranges of code in each block
217 with assembler labels LBBn and LBEn, where n is the block number.
218 The labels are generated in final, which assigns numbers to the
219 blocks in the same way. */
221 static int next_block_number;
223 /* These variables are for dbxout_symbol to communicate to
224 dbxout_finish_symbol.
225 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
226 current_sym_value and current_sym_addr are two ways to address the
227 value to store in the symtab entry.
228 current_sym_addr if nonzero represents the value as an rtx.
229 If that is zero, current_sym_value is used. This is used
230 when the value is an offset (such as for auto variables,
231 register variables and parms). */
233 static STAB_CODE_TYPE current_sym_code;
234 static int current_sym_value;
235 static rtx current_sym_addr;
237 /* Number of chars of symbol-description generated so far for the
238 current symbol. Used by CHARS and CONTIN. */
240 static int current_sym_nchars;
242 /* Report having output N chars of the current symbol-description. */
244 #define CHARS(N) (current_sym_nchars += (N))
246 /* Break the current symbol-description, generating a continuation,
247 if it has become long. */
249 #ifndef DBX_CONTIN_LENGTH
250 #define DBX_CONTIN_LENGTH 80
253 #if DBX_CONTIN_LENGTH > 0
255 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
260 void dbxout_types ();
262 void dbxout_symbol ();
263 static void dbxout_type_name ();
264 static void dbxout_type ();
265 static void dbxout_typedefs ();
266 static void dbxout_prepare_symbol ();
267 static void dbxout_finish_symbol ();
268 static void dbxout_continue ();
269 static void print_int_cst_octal ();
270 static void print_octal ();
272 #if 0 /* Not clear we will actually need this. */
274 /* Return the absolutized filename for the given relative
275 filename. Note that if that filename is already absolute, it may
276 still be returned in a modified form because this routine also
277 eliminates redundant slashes and single dots and eliminates double
278 dots to get a shortest possible filename from the given input
279 filename. The absolutization of relative filenames is made by
280 assuming that the given filename is to be taken as relative to
281 the first argument (cwd) or to the current directory if cwd is
285 abspath (rel_filename)
288 /* Setup the current working directory as needed. */
290 = (char *) alloca (strlen (cwd) + strlen (rel_filename) + 1);
291 char *endp = abs_buffer;
295 /* Copy the filename (possibly preceded by the current working
296 directory name) into the absolutization buffer. */
301 if (rel_filename[0] != '/')
304 while (*endp++ = *src_p++)
306 *(endp-1) = '/'; /* overwrite null */
308 src_p = rel_filename;
309 while (*endp++ = *src_p++)
314 /* Now make a copy of abs_buffer into abs_buffer, shortening the
315 filename (by taking out slashes and dots) as we go. */
317 outp = inp = abs_buffer;
318 *outp++ = *inp++; /* copy first slash */
323 else if (inp[0] == '/' && outp[-1] == '/')
328 else if (inp[0] == '.' && outp[-1] == '/')
332 else if (inp[1] == '/')
337 else if ((inp[1] == '.') && (inp[2] == 0 || inp[2] == '/'))
339 inp += (inp[2] == '/') ? 3 : 2;
341 while (outp >= abs_buffer && *outp != '/')
343 if (outp < abs_buffer)
345 /* Catch cases like /.. where we try to backup to a
346 point above the absolute root of the logical file
349 fprintf (stderr, "%s: invalid file name: %s\n",
350 pname, rel_filename);
360 /* On exit, make sure that there is a trailing null, and make sure that
361 the last character of the returned string is *not* a slash. */
367 /* Make a copy (in the heap) of the stuff left in the absolutization
368 buffer and return a pointer to the copy. */
370 value = (char *) oballoc (strlen (abs_buffer) + 1);
371 strcpy (value, abs_buffer);
376 /* At the beginning of compilation, start writing the symbol table.
377 Initialize `typevec' and output the standard data types of C. */
380 dbxout_init (asm_file, input_file_name, syms)
382 char *input_file_name;
385 char ltext_label_name[100];
390 typevec = (enum typestatus *) xmalloc (typevec_len * sizeof typevec[0]);
391 bzero (typevec, typevec_len * sizeof typevec[0]);
393 /* Convert Ltext into the appropriate format for local labels in case
394 the system doesn't insert underscores in front of user generated
396 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
398 /* Put the current working directory in an N_SO symbol. */
399 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
400 but GDB always does. */
401 if (use_gnu_debug_info_extensions)
404 if (cwd || (cwd = getpwd ()))
406 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
407 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd);
408 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
409 fprintf (asmfile, "%s \"%s/\",%d,0,0,%s\n", ASM_STABS_OP,
410 cwd, N_SO, <ext_label_name[1]);
411 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
415 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
416 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
417 would give us an N_SOL, and we want an N_SO. */
418 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile, input_file_name);
419 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
420 /* We include outputting `Ltext:' here,
421 because that gives you a way to override it. */
422 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
423 fprintf (asmfile, "%s \"%s\",%d,0,0,%s\n", ASM_STABS_OP, input_file_name,
424 N_SO, <ext_label_name[1]);
426 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Ltext", 0);
427 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
429 /* Possibly output something to inform GDB that this compilation was by
430 GCC. It's easier for GDB to parse it when after the N_SO's. This
431 is used in Solaris 2. */
432 #ifdef ASM_IDENTIFY_GCC_AFTER_SOURCE
433 ASM_IDENTIFY_GCC_AFTER_SOURCE (asmfile);
436 lastfile = input_file_name;
438 next_type_number = 1;
439 next_block_number = 2;
441 /* Make sure that types `int' and `char' have numbers 1 and 2.
442 Definitions of other integer types will refer to those numbers.
443 (Actually it should no longer matter what their numbers are.
444 Also, if any types with tags have been defined, dbxout_symbol
445 will output them first, so the numbers won't be 1 and 2. That
446 happens in C++. So it's a good thing it should no longer matter). */
448 #ifdef DBX_OUTPUT_STANDARD_TYPES
449 DBX_OUTPUT_STANDARD_TYPES (syms);
451 dbxout_symbol (TYPE_NAME (integer_type_node), 0);
452 dbxout_symbol (TYPE_NAME (char_type_node), 0);
455 /* Get all permanent types that have typedef names,
456 and output them all, except for those already output. */
458 dbxout_typedefs (syms);
461 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
462 in the reverse order from that which is found in SYMS. */
465 dbxout_typedefs (syms)
470 dbxout_typedefs (TREE_CHAIN (syms));
471 if (TREE_CODE (syms) == TYPE_DECL)
473 tree type = TREE_TYPE (syms);
475 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
476 && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
477 dbxout_symbol (TYPE_NAME (type), 0);
482 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
485 dbxout_source_file (file, filename)
489 char ltext_label_name[100];
491 if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
493 #ifdef DBX_OUTPUT_SOURCE_FILENAME
494 DBX_OUTPUT_SOURCE_FILENAME (file, filename);
496 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
497 fprintf (file, "%s \"%s\",%d,0,0,%s\n", ASM_STABS_OP,
498 filename, N_SOL, <ext_label_name[1]);
504 /* Output a line number symbol entry into output stream FILE,
505 for source file FILENAME and line number LINENO. */
508 dbxout_source_line (file, filename, lineno)
513 dbxout_source_file (file, filename);
515 #ifdef ASM_OUTPUT_SOURCE_LINE
516 ASM_OUTPUT_SOURCE_LINE (file, lineno);
518 fprintf (file, "\t%s %d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno);
522 /* At the end of compilation, finish writing the symbol table.
523 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
527 dbxout_finish (file, filename)
531 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
532 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file, filename);
533 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
536 /* Continue a symbol-description that gets too big.
537 End one symbol table entry with a double-backslash
538 and start a new one, eventually producing something like
539 .stabs "start......\\",code,0,value
540 .stabs "...rest",code,0,value */
545 #ifdef DBX_CONTIN_CHAR
546 fprintf (asmfile, "%c", DBX_CONTIN_CHAR);
548 fprintf (asmfile, "\\\\");
550 dbxout_finish_symbol (NULL_TREE);
551 fprintf (asmfile, "%s \"", ASM_STABS_OP);
552 current_sym_nchars = 0;
555 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
556 This must be a separate function because anonymous unions require
560 dbxout_type_fields (type)
564 /* Output the name, type, position (in bits), size (in bits) of each
566 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
568 /* For nameless subunions and subrecords, treat their fields as ours. */
569 if (DECL_NAME (tem) == NULL_TREE
570 && (TREE_CODE (TREE_TYPE (tem)) == UNION_TYPE
571 || TREE_CODE (TREE_TYPE (tem)) == QUAL_UNION_TYPE
572 || TREE_CODE (TREE_TYPE (tem)) == RECORD_TYPE))
573 dbxout_type_fields (TREE_TYPE (tem));
574 /* Omit here local type decls until we know how to support them. */
575 else if (TREE_CODE (tem) == TYPE_DECL)
577 /* Omit here the nameless fields that are used to skip bits. */
578 else if (DECL_NAME (tem) != 0 && TREE_CODE (tem) != CONST_DECL)
580 /* Continue the line if necessary,
581 but not before the first field. */
582 if (tem != TYPE_FIELDS (type))
585 if (use_gnu_debug_info_extensions
586 && flag_minimal_debug
587 && TREE_CODE (tem) == FIELD_DECL
588 && DECL_VIRTUAL_P (tem)
589 && DECL_ASSEMBLER_NAME (tem))
591 have_used_extensions = 1;
592 CHARS (3 + IDENTIFIER_LENGTH (DECL_NAME (TYPE_NAME (DECL_FCONTEXT (tem)))));
593 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem)), asmfile);
594 dbxout_type (DECL_FCONTEXT (tem), 0, 0);
595 fprintf (asmfile, ":");
596 dbxout_type (TREE_TYPE (tem), 0, 0);
597 fprintf (asmfile, ",%d;",
598 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)));
602 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
603 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem)));
605 if (use_gnu_debug_info_extensions
606 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
607 || TREE_CODE (tem) != FIELD_DECL))
609 have_used_extensions = 1;
611 putc ((TREE_PRIVATE (tem) ? '0'
612 : TREE_PROTECTED (tem) ? '1' : '2'),
617 dbxout_type ((TREE_CODE (tem) == FIELD_DECL
618 && DECL_BIT_FIELD_TYPE (tem))
619 ? DECL_BIT_FIELD_TYPE (tem)
620 : TREE_TYPE (tem), 0, 0);
622 if (TREE_CODE (tem) == VAR_DECL)
624 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
626 char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem));
627 have_used_extensions = 1;
628 fprintf (asmfile, ":%s;", name);
629 CHARS (strlen (name));
633 /* If TEM is non-static, GDB won't understand it. */
634 fprintf (asmfile, ",0,0;");
637 else if (TREE_CODE (DECL_FIELD_BITPOS (tem)) == INTEGER_CST)
639 fprintf (asmfile, ",%d,%d;",
640 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)),
641 TREE_INT_CST_LOW (DECL_SIZE (tem)));
644 /* This has yet to be implemented. */
651 /* Subroutine of `dbxout_type_methods'. Output debug info about the
652 method described DECL. DEBUG_NAME is an encoding of the method's
653 type signature. ??? We may be able to do without DEBUG_NAME altogether
657 dbxout_type_method_1 (decl, debug_name)
661 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
664 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
666 else /* it's a METHOD_TYPE. */
668 /* A for normal functions.
669 B for `const' member functions.
670 C for `volatile' member functions.
671 D for `const volatile' member functions. */
672 if (TYPE_READONLY (TREE_TYPE (firstarg)))
674 if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
677 if (DECL_VINDEX (decl))
683 fprintf (asmfile, ":%s;%c%c%c", debug_name,
684 TREE_PRIVATE (decl) ? '0' : TREE_PROTECTED (decl) ? '1' : '2', c1, c2);
685 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)) + 6
686 - (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
687 if (DECL_VINDEX (decl))
689 fprintf (asmfile, "%d;",
690 TREE_INT_CST_LOW (DECL_VINDEX (decl)));
691 dbxout_type (DECL_CONTEXT (decl), 0, 0);
692 fprintf (asmfile, ";");
697 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
701 dbxout_type_methods (type)
704 /* C++: put out the method names and their parameter lists */
705 tree methods = TYPE_METHODS (type);
707 register tree fndecl;
709 char formatted_type_identifier_length[16];
710 register int type_identifier_length;
712 if (methods == NULL_TREE)
715 type_encoding = DECL_NAME (TYPE_NAME (type));
717 /* C++: Template classes break some assumptions made by this code about
718 the class names, constructor names, and encodings for assembler
719 label names. For now, disable output of dbx info for them. */
721 char *ptr = IDENTIFIER_POINTER (type_encoding);
722 /* This should use index. (mrs) */
723 while (*ptr && *ptr != '<') ptr++;
730 #ifdef HAVE_TEMPLATES
731 if (warn_template_debugging)
732 warning ("dbx info for template class methods not yet supported");
739 type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
741 sprintf(formatted_type_identifier_length, "%d", type_identifier_length);
743 if (TREE_CODE (methods) == FUNCTION_DECL)
745 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
746 fndecl = TREE_VEC_ELT (methods, 0);
748 fndecl = TREE_VEC_ELT (methods, 1);
752 tree name = DECL_NAME (fndecl);
755 /* Group together all the methods for the same operation.
756 These differ in the types of the arguments. */
757 for (last = NULL_TREE;
758 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
759 fndecl = TREE_CHAIN (fndecl))
760 /* Output the name of the field (after overloading), as
761 well as the name of the field before overloading, along
762 with its parameter list */
764 /* This is the "mangled" name of the method.
765 It encodes the argument types. */
766 char *debug_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
773 if (DECL_IGNORED_P (fndecl))
776 if (flag_minimal_debug)
778 /* Detect ordinary methods because their mangled names
779 start with the operation name. */
780 if (!strncmp (IDENTIFIER_POINTER (name), debug_name,
781 IDENTIFIER_LENGTH (name)))
783 debug_name += IDENTIFIER_LENGTH (name);
784 if (debug_name[0] == '_' && debug_name[1] == '_')
786 char *method_name = debug_name + 2;
787 char *length_ptr = formatted_type_identifier_length;
788 /* Get past const and volatile qualifiers. */
789 while (*method_name == 'C' || *method_name == 'V')
791 /* Skip digits for length of type_encoding. */
792 while (*method_name == *length_ptr && *length_ptr)
793 length_ptr++, method_name++;
794 if (! strncmp (method_name,
795 IDENTIFIER_POINTER (type_encoding),
796 type_identifier_length))
797 method_name += type_identifier_length;
798 debug_name = method_name;
801 /* Detect constructors by their style of name mangling. */
802 else if (debug_name[0] == '_' && debug_name[1] == '_')
804 char *ctor_name = debug_name + 2;
805 char *length_ptr = formatted_type_identifier_length;
806 while (*ctor_name == 'C' || *ctor_name == 'V')
808 /* Skip digits for length of type_encoding. */
809 while (*ctor_name == *length_ptr && *length_ptr)
810 length_ptr++, ctor_name++;
811 if (!strncmp (IDENTIFIER_POINTER (type_encoding), ctor_name,
812 type_identifier_length))
813 debug_name = ctor_name + type_identifier_length;
815 /* The other alternative is a destructor. */
819 /* Output the operation name just once, for the first method
823 fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
824 CHARS (IDENTIFIER_LENGTH (name) + 2);
829 dbxout_type (TREE_TYPE (fndecl), 0, destructor);
831 dbxout_type_method_1 (fndecl, debug_name);
841 /* Emit a "range" type specification, which has the form:
842 "r<index type>;<lower bound>;<upper bound>;".
843 TYPE is an INTEGER_TYPE. */
846 dbxout_range_type (type)
849 fprintf (asmfile, "r");
850 if (TREE_TYPE (type) && TREE_CODE (TREE_TYPE(type)) != INTEGER_TYPE)
851 dbxout_type (TREE_TYPE (type), 0, 0);
854 /* This used to say `r1' and we used to take care
855 to make sure that `int' was type number 1. */
856 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (integer_type_node));
858 if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
859 fprintf (asmfile, ";%d",
860 TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)));
862 fprintf (asmfile, ";0");
863 if (TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
864 fprintf (asmfile, ";%d;",
865 TREE_INT_CST_LOW (TYPE_MAX_VALUE (type)));
867 fprintf (asmfile, ";-1;");
870 /* Output a reference to a type. If the type has not yet been
871 described in the dbx output, output its definition now.
872 For a type already defined, just refer to its definition
873 using the type number.
875 If FULL is nonzero, and the type has been described only with
876 a forward-reference, output the definition now.
877 If FULL is zero in this case, just refer to the forward-reference
878 using the number previously allocated.
880 If SHOW_ARG_TYPES is nonzero, we output a description of the argument
881 types for a METHOD_TYPE. */
884 dbxout_type (type, full, show_arg_types)
890 static int anonymous_type_number = 0;
892 /* If there was an input error and we don't really have a type,
893 avoid crashing and write something that is at least valid
894 by assuming `int'. */
895 if (type == error_mark_node)
896 type = integer_type_node;
899 type = TYPE_MAIN_VARIANT (type);
901 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
902 && DECL_IGNORED_P (TYPE_NAME (type)))
906 if (TYPE_SYMTAB_ADDRESS (type) == 0)
908 /* Type has no dbx number assigned. Assign next available number. */
909 TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
911 /* Make sure type vector is long enough to record about this type. */
913 if (next_type_number == typevec_len)
915 typevec = (enum typestatus *) xrealloc (typevec, typevec_len * 2 * sizeof typevec[0]);
916 bzero (typevec + typevec_len, typevec_len * sizeof typevec[0]);
921 /* Output the number of this type, to refer to it. */
922 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
925 #ifdef DBX_TYPE_DEFINED
926 if (DBX_TYPE_DEFINED (type))
930 /* If this type's definition has been output or is now being output,
933 switch (typevec[TYPE_SYMTAB_ADDRESS (type)])
938 /* If we have already had a cross reference,
939 and either that's all we want or that's the best we could do,
940 don't repeat the cross reference.
941 Sun dbx crashes if we do. */
942 if (! full || TYPE_SIZE (type) == 0
943 /* No way in DBX fmt to describe a variable size. */
944 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
952 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
953 leave the type-number completely undefined rather than output
954 a cross-reference. */
955 if (TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
956 || TREE_CODE (type) == QUAL_UNION_TYPE
957 || TREE_CODE (type) == ENUMERAL_TYPE)
959 if ((TYPE_NAME (type) != 0 && !full)
960 || TYPE_SIZE (type) == 0)
962 typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_XREF;
967 /* Output a definition now. */
969 fprintf (asmfile, "=");
972 /* Mark it as defined, so that if it is self-referent
973 we will not get into an infinite recursion of definitions. */
975 typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_DEFINED;
977 switch (TREE_CODE (type))
981 /* For a void type, just define it as itself; ie, "5=5".
982 This makes us consider it defined
983 without saying what it is. The debugger will make it
984 a void type when the reference is seen, and nothing will
985 ever override that default. */
986 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
991 if (type == char_type_node && ! TREE_UNSIGNED (type))
992 /* Output the type `char' as a subrange of itself!
993 I don't understand this definition, just copied it
994 from the output of pcc.
995 This used to use `r2' explicitly and we used to
996 take care to make sure that `char' was type number 2. */
997 fprintf (asmfile, "r%d;0;127;", TYPE_SYMTAB_ADDRESS (type));
998 else if (use_gnu_debug_info_extensions && TYPE_PRECISION (type) > BITS_PER_WORD)
1000 /* This used to say `r1' and we used to take care
1001 to make sure that `int' was type number 1. */
1002 fprintf (asmfile, "r%d;", TYPE_SYMTAB_ADDRESS (integer_type_node));
1003 print_int_cst_octal (TYPE_MIN_VALUE (type));
1004 fprintf (asmfile, ";");
1005 print_int_cst_octal (TYPE_MAX_VALUE (type));
1006 fprintf (asmfile, ";");
1008 else /* Output other integer types as subranges of `int'. */
1009 dbxout_range_type (type);
1014 /* This used to say `r1' and we used to take care
1015 to make sure that `int' was type number 1. */
1016 fprintf (asmfile, "r%d;%d;0;", TYPE_SYMTAB_ADDRESS (integer_type_node),
1017 int_size_in_bytes (type));
1022 /* Output the type `char' as a subrange of itself.
1023 That is what pcc seems to do. */
1024 fprintf (asmfile, "r%d;0;%d;", TYPE_SYMTAB_ADDRESS (char_type_node),
1025 TREE_UNSIGNED (type) ? 255 : 127);
1029 case BOOLEAN_TYPE: /* Define as enumeral type (False, True) */
1030 fprintf (asmfile, "eFalse:0,True:1,;");
1035 putc ('d', asmfile);
1037 dbxout_type (TREE_TYPE (type), 0, 0);
1041 /* Differs from the REAL_TYPE by its new data type number */
1043 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1045 fprintf (asmfile, "r%d;%d;0;",
1046 TYPE_SYMTAB_ADDRESS (type),
1047 int_size_in_bytes (TREE_TYPE (type)));
1048 CHARS (15); /* The number is probably incorrect here. */
1052 /* Output a complex integer type as a structure,
1053 pending some other way to do it. */
1054 fprintf (asmfile, "s%d", int_size_in_bytes (type));
1056 fprintf (asmfile, "real:");
1058 dbxout_type (TREE_TYPE (type), 0, 0);
1059 fprintf (asmfile, ",%d,%d;",
1060 0, TYPE_PRECISION (TREE_TYPE (type)));
1062 fprintf (asmfile, "imag:");
1064 dbxout_type (TREE_TYPE (type), 0, 0);
1065 fprintf (asmfile, ",%d,%d;;",
1066 TYPE_PRECISION (TREE_TYPE (type)),
1067 TYPE_PRECISION (TREE_TYPE (type)));
1073 putc ('S', asmfile);
1075 dbxout_type (TREE_TYPE (type), 0, 0);
1079 /* Output "a" followed by a range type definition
1080 for the index type of the array
1081 followed by a reference to the target-type.
1082 ar1;0;N;M for a C array of type M and size N+1. */
1083 tem = TYPE_DOMAIN (type);
1085 fprintf (asmfile, "ar%d;0;-1;",
1086 TYPE_SYMTAB_ADDRESS (integer_type_node));
1089 fprintf (asmfile, "a");
1090 dbxout_range_type (tem);
1093 dbxout_type (TREE_TYPE (type), 0, 0);
1098 case QUAL_UNION_TYPE:
1100 int i, n_baseclasses = 0;
1102 if (TYPE_BINFO (type) != 0 && TYPE_BINFO_BASETYPES (type) != 0)
1103 n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
1105 /* Output a structure type. */
1106 if ((TYPE_NAME (type) != 0
1107 /* Long ago, Tiemann said this creates output that "confuses GDB".
1108 In April 93, mrs@cygnus.com said there is no such problem.
1109 The type decls made automatically by struct specifiers
1110 are marked with DECL_IGNORED_P in C++. */
1111 #if 0 /* This creates output for anonymous classes which confuses GDB. */
1112 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1113 && DECL_IGNORED_P (TYPE_NAME (type)))
1116 || TYPE_SIZE (type) == 0
1117 /* No way in DBX fmt to describe a variable size. */
1118 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1120 /* If the type is just a cross reference, output one
1121 and mark the type as partially described.
1122 If it later becomes defined, we will output
1123 its real definition.
1124 If the type has a name, don't nest its definition within
1125 another type's definition; instead, output an xref
1126 and let the definition come when the name is defined. */
1127 fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
1129 #if 0 /* This assertion is legitimately false in C++. */
1130 /* We shouldn't be outputting a reference to a type before its
1131 definition unless the type has a tag name.
1132 A typedef name without a tag name should be impossible. */
1133 if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
1136 if (TYPE_NAME (type) != 0)
1137 dbxout_type_name (type);
1139 fprintf (asmfile, "$$%d", anonymous_type_number++);
1140 fprintf (asmfile, ":");
1141 typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_XREF;
1145 /* Identify record or union, and print its size. */
1146 fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "s%d" : "u%d",
1147 int_size_in_bytes (type));
1149 if (use_gnu_debug_info_extensions)
1153 have_used_extensions = 1;
1154 fprintf (asmfile, "!%d,", n_baseclasses);
1158 for (i = 0; i < n_baseclasses; i++)
1160 tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i);
1161 if (use_gnu_debug_info_extensions)
1163 have_used_extensions = 1;
1164 putc (TREE_VIA_VIRTUAL (child) ? '1'
1167 putc (TREE_VIA_PUBLIC (child) ? '2'
1170 fprintf (asmfile, "%d,",
1171 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT);
1173 dbxout_type (BINFO_TYPE (child), 0, 0);
1174 putc (';', asmfile);
1178 /* Print out the base class information with fields
1179 which have the same names at the types they hold. */
1180 dbxout_type_name (BINFO_TYPE (child));
1181 putc (':', asmfile);
1182 dbxout_type (BINFO_TYPE (child), full, 0);
1183 fprintf (asmfile, ",%d,%d;",
1184 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT,
1185 TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child)))) * BITS_PER_UNIT);
1193 /* Write out the field declarations. */
1194 dbxout_type_fields (type);
1195 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
1197 have_used_extensions = 1;
1198 dbxout_type_methods (type);
1200 putc (';', asmfile);
1202 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
1203 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1204 && TYPE_VFIELD (type))
1206 have_used_extensions = 1;
1208 /* Tell GDB+ that it may keep reading. */
1209 putc ('~', asmfile);
1211 /* We need to write out info about what field this class
1212 uses as its "main" vtable pointer field, because if this
1213 field is inherited from a base class, GDB cannot necessarily
1214 figure out which field it's using in time. */
1215 if (TYPE_VFIELD (type))
1217 putc ('%', asmfile);
1218 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0, 0);
1220 putc (';', asmfile);
1226 if ((TYPE_NAME (type) != 0 && !full
1227 && (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1228 && ! DECL_IGNORED_P (TYPE_NAME (type))))
1229 || TYPE_SIZE (type) == 0)
1231 fprintf (asmfile, "xe");
1233 dbxout_type_name (type);
1234 typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_XREF;
1235 fprintf (asmfile, ":");
1238 #ifdef DBX_OUTPUT_ENUM
1239 DBX_OUTPUT_ENUM (asmfile, type);
1241 putc ('e', asmfile);
1243 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
1245 fprintf (asmfile, "%s:%d,", IDENTIFIER_POINTER (TREE_PURPOSE (tem)),
1246 TREE_INT_CST_LOW (TREE_VALUE (tem)));
1247 CHARS (11 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem)));
1248 if (TREE_CHAIN (tem) != 0)
1251 putc (';', asmfile);
1257 putc ('*', asmfile);
1259 dbxout_type (TREE_TYPE (type), 0, 0);
1263 if (use_gnu_debug_info_extensions)
1265 have_used_extensions = 1;
1266 putc ('#', asmfile);
1268 if (flag_minimal_debug && !show_arg_types)
1270 /* Normally, just output the return type.
1271 The argument types are encoded in the method name. */
1272 putc ('#', asmfile);
1273 dbxout_type (TREE_TYPE (type), 0, 0);
1274 putc (';', asmfile);
1279 /* When outputting destructors, we need to write
1280 the argument types out longhand. */
1281 dbxout_type (TYPE_METHOD_BASETYPE (type), 0, 0);
1282 putc (',', asmfile);
1284 dbxout_type (TREE_TYPE (type), 0, 0);
1285 dbxout_args (TYPE_ARG_TYPES (type));
1286 putc (';', asmfile);
1292 /* Treat it as a function type. */
1293 dbxout_type (TREE_TYPE (type), 0, 0);
1298 if (use_gnu_debug_info_extensions)
1300 have_used_extensions = 1;
1301 putc ('@', asmfile);
1303 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0, 0);
1304 putc (',', asmfile);
1306 dbxout_type (TREE_TYPE (type), 0, 0);
1310 /* Should print as an int, because it is really
1312 dbxout_type (integer_type_node, 0, 0);
1316 case REFERENCE_TYPE:
1317 if (use_gnu_debug_info_extensions)
1318 have_used_extensions = 1;
1319 putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
1321 dbxout_type (TREE_TYPE (type), 0, 0);
1325 putc ('f', asmfile);
1327 dbxout_type (TREE_TYPE (type), 0, 0);
1335 /* Print the value of integer constant C, in octal,
1336 handling double precision. */
1339 print_int_cst_octal (c)
1342 unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
1343 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
1344 int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
1346 fprintf (asmfile, "0");
1350 print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
1351 print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
1355 unsigned HOST_WIDE_INT beg = high >> excess;
1356 unsigned HOST_WIDE_INT middle
1357 = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
1358 | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
1359 unsigned HOST_WIDE_INT end
1360 = low & (((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 3 * 3)) - 1);
1361 fprintf (asmfile, "%o%01o", beg, middle);
1362 print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
1367 print_octal (value, digits)
1368 unsigned HOST_WIDE_INT value;
1373 for (i = digits - 1; i >= 0; i--)
1374 fprintf (asmfile, "%01o", ((value >> (3 * i)) & 7));
1377 /* Output the name of type TYPE, with no punctuation.
1378 Such names can be set up either by typedef declarations
1379 or by struct, enum and union tags. */
1382 dbxout_type_name (type)
1386 if (TYPE_NAME (type) == 0)
1388 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
1390 t = TYPE_NAME (type);
1392 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1394 t = DECL_NAME (TYPE_NAME (type));
1399 fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
1400 CHARS (IDENTIFIER_LENGTH (t));
1403 /* Output a .stabs for the symbol defined by DECL,
1404 which must be a ..._DECL node in the normal namespace.
1405 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1406 LOCAL is nonzero if the scope is less than the entire file. */
1409 dbxout_symbol (decl, local)
1414 tree type = TREE_TYPE (decl);
1415 tree context = NULL_TREE;
1418 /* Cast avoids warning in old compilers. */
1419 current_sym_code = (STAB_CODE_TYPE) 0;
1420 current_sym_value = 0;
1421 current_sym_addr = 0;
1423 /* Ignore nameless syms, but don't ignore type tags. */
1425 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
1426 || DECL_IGNORED_P (decl))
1429 dbxout_prepare_symbol (decl);
1431 /* The output will always start with the symbol name,
1432 so always count that in the length-output-so-far. */
1434 if (DECL_NAME (decl) != 0)
1435 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
1437 switch (TREE_CODE (decl))
1440 /* Enum values are defined by defining the enum type. */
1444 if (DECL_RTL (decl) == 0)
1446 if (DECL_EXTERNAL (decl))
1448 /* Don't mention a nested function under its parent. */
1449 context = decl_function_context (decl);
1450 if (context == current_function_decl)
1452 if (GET_CODE (DECL_RTL (decl)) != MEM
1453 || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
1457 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
1458 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1459 TREE_PUBLIC (decl) ? 'F' : 'f');
1461 current_sym_code = N_FUN;
1462 current_sym_addr = XEXP (DECL_RTL (decl), 0);
1464 if (TREE_TYPE (type))
1465 dbxout_type (TREE_TYPE (type), 0, 0);
1467 dbxout_type (void_type_node, 0, 0);
1469 /* For a nested function, when that function is compiled,
1470 mention the containing function name
1471 as well as (since dbx wants it) our own assembler-name. */
1473 fprintf (asmfile, ",%s,%s",
1474 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1475 IDENTIFIER_POINTER (DECL_NAME (context)));
1477 dbxout_finish_symbol (decl);
1482 /* This seems all wrong. Outputting most kinds of types gives no name
1483 at all. A true definition gives no name; a cross-ref for a
1484 structure can give the tag name, but not a type name.
1485 It seems that no typedef name is defined by outputting a type. */
1487 /* If this typedef name was defined by outputting the type,
1488 don't duplicate it. */
1489 if (typevec[TYPE_SYMTAB_ADDRESS (type)] == TYPE_DEFINED
1490 && TYPE_NAME (TREE_TYPE (decl)) == decl)
1493 /* Don't output the same typedef twice.
1494 And don't output what language-specific stuff doesn't want output. */
1495 if (TREE_ASM_WRITTEN (decl) || DECL_IGNORED_P (decl))
1504 if (DECL_NAME (decl))
1506 /* Nonzero means we must output a tag as well as a typedef. */
1509 /* Handle the case of a C++ structure or union
1510 where the TYPE_NAME is a TYPE_DECL
1511 which gives both a typedef name and a tag. */
1512 /* dbx requires the tag first and the typedef second. */
1513 if ((TREE_CODE (type) == RECORD_TYPE
1514 || TREE_CODE (type) == UNION_TYPE
1515 || TREE_CODE (type) == QUAL_UNION_TYPE)
1516 && TYPE_NAME (type) == decl
1517 && !(use_gnu_debug_info_extensions && have_used_extensions)
1518 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
1519 /* Distinguish the implicit typedefs of C++
1520 from explicit ones that might be found in C. */
1521 && DECL_SOURCE_LINE (decl) == 0)
1523 tree name = TYPE_NAME (type);
1524 if (TREE_CODE (name) == TYPE_DECL)
1525 name = DECL_NAME (name);
1527 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1528 current_sym_value = 0;
1529 current_sym_addr = 0;
1530 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1532 fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP,
1533 IDENTIFIER_POINTER (name));
1534 dbxout_type (type, 1, 0);
1535 dbxout_finish_symbol (NULL_TREE);
1538 /* Output typedef name. */
1539 fprintf (asmfile, "%s \"%s:", ASM_STABS_OP,
1540 IDENTIFIER_POINTER (DECL_NAME (decl)));
1542 /* Short cut way to output a tag also. */
1543 if ((TREE_CODE (type) == RECORD_TYPE
1544 || TREE_CODE (type) == UNION_TYPE
1545 || TREE_CODE (type) == QUAL_UNION_TYPE)
1546 && TYPE_NAME (type) == decl)
1548 if (use_gnu_debug_info_extensions && have_used_extensions)
1550 putc ('T', asmfile);
1551 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
1553 #if 0 /* Now we generate the tag for this case up above. */
1559 putc ('t', asmfile);
1560 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1562 dbxout_type (type, 1, 0);
1563 dbxout_finish_symbol (decl);
1567 /* Don't output a tag if this is an incomplete type (TYPE_SIZE is
1568 zero). This prevents the sun4 Sun OS 4.x dbx from crashing. */
1570 if (tag_needed && TYPE_NAME (type) != 0 && TYPE_SIZE (type) != 0
1571 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
1573 /* For a TYPE_DECL with no name, but the type has a name,
1575 This is what represents `struct foo' with no typedef. */
1576 /* In C++, the name of a type is the corresponding typedef.
1577 In C, it is an IDENTIFIER_NODE. */
1578 tree name = TYPE_NAME (type);
1579 if (TREE_CODE (name) == TYPE_DECL)
1580 name = DECL_NAME (name);
1582 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1583 current_sym_value = 0;
1584 current_sym_addr = 0;
1585 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1587 fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP,
1588 IDENTIFIER_POINTER (name));
1589 dbxout_type (type, 1, 0);
1590 dbxout_finish_symbol (NULL_TREE);
1594 /* If an enum type has no name, it cannot be referred to,
1595 but we must output it anyway, since the enumeration constants
1596 can be referred to. */
1597 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
1599 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1600 current_sym_value = 0;
1601 current_sym_addr = 0;
1602 current_sym_nchars = 2;
1604 /* Some debuggers fail when given NULL names, so give this a
1605 harmless name of ` '. */
1606 fprintf (asmfile, "%s \" :T", ASM_STABS_OP);
1607 dbxout_type (type, 1, 0);
1608 dbxout_finish_symbol (NULL_TREE);
1611 /* Prevent duplicate output of a typedef. */
1612 TREE_ASM_WRITTEN (decl) = 1;
1617 /* Parm decls go in their own separate chains
1618 and are output by dbxout_reg_parms and dbxout_parms. */
1622 /* Named return value, treat like a VAR_DECL. */
1624 if (DECL_RTL (decl) == 0)
1626 /* Don't mention a variable that is external.
1627 Let the file that defines it describe it. */
1628 if (DECL_EXTERNAL (decl))
1631 /* If the variable is really a constant
1632 and not written in memory, inform the debugger. */
1633 if (TREE_STATIC (decl) && TREE_READONLY (decl)
1634 && DECL_INITIAL (decl) != 0
1635 && ! TREE_ASM_WRITTEN (decl)
1636 && (DECL_FIELD_CONTEXT (decl) == NULL_TREE
1637 || TREE_CODE (DECL_FIELD_CONTEXT (decl)) == BLOCK))
1639 if (TREE_PUBLIC (decl) == 0)
1641 /* The sun4 assembler does not grok this. */
1642 char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1643 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
1644 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
1646 HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl));
1647 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1648 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile, name, ival);
1650 fprintf (asmfile, "%s \"%s:c=i%d\",0x%x,0,0,0\n",
1651 ASM_STABS_OP, name, ival, N_LSYM);
1655 else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
1657 /* don't know how to do this yet. */
1661 /* else it is something we handle like a normal variable. */
1664 DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, NULL_RTX);
1665 #ifdef LEAF_REG_REMAP
1667 leaf_renumber_regs_insn (DECL_RTL (decl));
1670 /* Don't mention a variable at all
1671 if it was completely optimized into nothingness.
1673 If DECL was from an inline function, then it's rtl
1674 is not identically the rtl that was used in this
1675 particular compilation. */
1676 if (GET_CODE (DECL_RTL (decl)) == REG)
1678 regno = REGNO (DECL_RTL (decl));
1679 if (regno >= FIRST_PSEUDO_REGISTER)
1682 else if (GET_CODE (DECL_RTL (decl)) == SUBREG)
1684 rtx value = DECL_RTL (decl);
1686 while (GET_CODE (value) == SUBREG)
1688 offset += SUBREG_WORD (value);
1689 value = SUBREG_REG (value);
1691 if (GET_CODE (value) == REG)
1693 regno = REGNO (value);
1694 if (regno >= FIRST_PSEUDO_REGISTER)
1698 alter_subreg (DECL_RTL (decl));
1701 /* The kind-of-variable letter depends on where
1702 the variable is and on the scope of its name:
1703 G and N_GSYM for static storage and global scope,
1704 S for static storage and file scope,
1705 V for static storage and local scope,
1706 for those two, use N_LCSYM if data is in bss segment,
1707 N_STSYM if in data segment, N_FUN otherwise.
1708 (We used N_FUN originally, then changed to N_STSYM
1709 to please GDB. However, it seems that confused ld.
1710 Now GDB has been fixed to like N_FUN, says Kingdon.)
1711 no letter at all, and N_LSYM, for auto variable,
1712 r and N_RSYM for register variable. */
1714 if (GET_CODE (DECL_RTL (decl)) == MEM
1715 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == SYMBOL_REF)
1717 if (TREE_PUBLIC (decl))
1720 current_sym_code = N_GSYM;
1724 current_sym_addr = XEXP (DECL_RTL (decl), 0);
1726 letter = decl_function_context (decl) ? 'V' : 'S';
1728 if (!DECL_INITIAL (decl))
1729 current_sym_code = N_LCSYM;
1730 else if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl))
1731 /* This is not quite right, but it's the closest
1732 of all the codes that Unix defines. */
1733 current_sym_code = DBX_STATIC_CONST_VAR_CODE;
1736 /* Ultrix `as' seems to need this. */
1737 #ifdef DBX_STATIC_STAB_DATA_SECTION
1740 current_sym_code = N_STSYM;
1744 else if (regno >= 0)
1747 current_sym_code = N_RSYM;
1748 current_sym_value = DBX_REGISTER_NUMBER (regno);
1750 else if (GET_CODE (DECL_RTL (decl)) == MEM
1751 && (GET_CODE (XEXP (DECL_RTL (decl), 0)) == MEM
1752 || (GET_CODE (XEXP (DECL_RTL (decl), 0)) == REG
1753 && REGNO (XEXP (DECL_RTL (decl), 0)) != FRAME_POINTER_REGNUM)))
1754 /* If the value is indirect by memory or by a register
1755 that isn't the frame pointer
1756 then it means the object is variable-sized and address through
1757 that register or stack slot. DBX has no way to represent this
1758 so all we can do is output the variable as a pointer.
1759 If it's not a parameter, ignore it.
1760 (VAR_DECLs like this can be made by integrate.c.) */
1762 if (GET_CODE (XEXP (DECL_RTL (decl), 0)) == REG)
1765 current_sym_code = N_RSYM;
1766 current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (DECL_RTL (decl), 0)));
1770 current_sym_code = N_LSYM;
1771 /* DECL_RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
1772 We want the value of that CONST_INT. */
1774 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (DECL_RTL (decl), 0), 0));
1777 /* Effectively do build_pointer_type, but don't cache this type,
1778 since it might be temporary whereas the type it points to
1779 might have been saved for inlining. */
1780 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
1781 type = make_node (POINTER_TYPE);
1782 TREE_TYPE (type) = TREE_TYPE (decl);
1784 else if (GET_CODE (DECL_RTL (decl)) == MEM
1785 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == REG)
1787 current_sym_code = N_LSYM;
1788 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (DECL_RTL (decl), 0));
1790 else if (GET_CODE (DECL_RTL (decl)) == MEM
1791 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == PLUS
1792 && GET_CODE (XEXP (XEXP (DECL_RTL (decl), 0), 1)) == CONST_INT)
1794 current_sym_code = N_LSYM;
1795 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
1796 We want the value of that CONST_INT. */
1797 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (DECL_RTL (decl), 0));
1799 else if (GET_CODE (DECL_RTL (decl)) == MEM
1800 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == CONST)
1802 /* Handle an obscure case which can arise when optimizing and
1803 when there are few available registers. (This is *always*
1804 the case for i386/i486 targets). The DECL_RTL looks like
1805 (MEM (CONST ...)) even though this variable is a local `auto'
1806 or a local `register' variable. In effect, what has happened
1807 is that the reload pass has seen that all assignments and
1808 references for one such a local variable can be replaced by
1809 equivalent assignments and references to some static storage
1810 variable, thereby avoiding the need for a register. In such
1811 cases we're forced to lie to debuggers and tell them that
1812 this variable was itself `static'. */
1813 current_sym_code = N_LCSYM;
1815 current_sym_addr = XEXP (XEXP (DECL_RTL (decl), 0), 0);
1818 /* Address might be a MEM, when DECL is a variable-sized object.
1819 Or it might be const0_rtx, meaning previous passes
1820 want us to ignore this variable. */
1823 /* Ok, start a symtab entry and output the variable name. */
1826 #ifdef DBX_STATIC_BLOCK_START
1827 DBX_STATIC_BLOCK_START (asmfile, current_sym_code);
1830 /* One slight hitch: if this is a VAR_DECL which is a static
1831 class member, we must put out the mangled name instead of the
1835 /* Note also that static member (variable) names DO NOT begin
1836 with underscores in .stabs directives. */
1837 if (DECL_LANG_SPECIFIC (decl))
1838 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1840 name = IDENTIFIER_POINTER (DECL_NAME (decl));
1841 fprintf (asmfile, "%s \"%s:", ASM_STABS_OP, name);
1843 if (letter) putc (letter, asmfile);
1844 dbxout_type (type, 0, 0);
1845 dbxout_finish_symbol (decl);
1847 #ifdef DBX_STATIC_BLOCK_END
1848 DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
1855 dbxout_prepare_symbol (decl)
1859 char *filename = DECL_SOURCE_FILE (decl);
1861 dbxout_source_file (asmfile, filename);
1866 dbxout_finish_symbol (sym)
1869 #ifdef DBX_FINISH_SYMBOL
1870 DBX_FINISH_SYMBOL (sym);
1873 if (use_gnu_debug_info_extensions && sym != 0)
1874 line = DECL_SOURCE_LINE (sym);
1876 fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line);
1877 if (current_sym_addr)
1878 output_addr_const (asmfile, current_sym_addr);
1880 fprintf (asmfile, "%d", current_sym_value);
1881 putc ('\n', asmfile);
1885 /* Output definitions of all the decls in a chain. */
1893 dbxout_symbol (syms, 1);
1894 syms = TREE_CHAIN (syms);
1898 /* The following two functions output definitions of function parameters.
1899 Each parameter gets a definition locating it in the parameter list.
1900 Each parameter that is a register variable gets a second definition
1901 locating it in the register.
1903 Printing or argument lists in gdb uses the definitions that
1904 locate in the parameter list. But reference to the variable in
1905 expressions uses preferentially the definition as a register. */
1907 /* Output definitions, referring to storage in the parmlist,
1908 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
1911 dbxout_parms (parms)
1914 for (; parms; parms = TREE_CHAIN (parms))
1915 if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node)
1917 dbxout_prepare_symbol (parms);
1919 /* Perform any necessary register eliminations on the parameter's rtl,
1920 so that the debugging output will be accurate. */
1921 DECL_INCOMING_RTL (parms)
1922 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
1923 DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX);
1924 #ifdef LEAF_REG_REMAP
1927 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
1928 leaf_renumber_regs_insn (DECL_RTL (parms));
1932 if (PARM_PASSED_IN_MEMORY (parms))
1934 rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
1936 /* ??? Here we assume that the parm address is indexed
1937 off the frame pointer or arg pointer.
1938 If that is not true, we produce meaningless results,
1939 but do not crash. */
1940 if (GET_CODE (addr) == PLUS
1941 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
1942 current_sym_value = INTVAL (XEXP (addr, 1));
1944 current_sym_value = 0;
1946 current_sym_code = N_PSYM;
1947 current_sym_addr = 0;
1950 if (DECL_NAME (parms))
1952 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
1954 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
1955 IDENTIFIER_POINTER (DECL_NAME (parms)),
1956 DBX_MEMPARM_STABS_LETTER);
1960 current_sym_nchars = 8;
1961 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
1962 DBX_MEMPARM_STABS_LETTER);
1965 if (GET_CODE (DECL_RTL (parms)) == REG
1966 && REGNO (DECL_RTL (parms)) >= 0
1967 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1968 dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
1971 int original_value = current_sym_value;
1973 /* This is the case where the parm is passed as an int or double
1974 and it is converted to a char, short or float and stored back
1975 in the parmlist. In this case, describe the parm
1976 with the variable's declared type, and adjust the address
1977 if the least significant bytes (which we are using) are not
1979 #if BYTES_BIG_ENDIAN
1980 if (TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1981 current_sym_value += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1982 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1985 if (GET_CODE (DECL_RTL (parms)) == MEM
1986 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1987 && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
1988 && INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == current_sym_value)
1989 dbxout_type (TREE_TYPE (parms), 0, 0);
1992 current_sym_value = original_value;
1993 dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
1996 current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
1997 dbxout_finish_symbol (parms);
1999 else if (GET_CODE (DECL_RTL (parms)) == REG)
2002 char regparm_letter;
2003 /* Parm passed in registers and lives in registers or nowhere. */
2005 current_sym_code = DBX_REGPARM_STABS_CODE;
2006 regparm_letter = DBX_REGPARM_STABS_LETTER;
2007 current_sym_addr = 0;
2009 /* If parm lives in a register, use that register;
2010 pretend the parm was passed there. It would be more consistent
2011 to describe the register where the parm was passed,
2012 but in practice that register usually holds something else. */
2013 if (REGNO (DECL_RTL (parms)) >= 0
2014 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2015 best_rtl = DECL_RTL (parms);
2016 /* If the parm lives nowhere,
2017 use the register where it was passed. */
2019 best_rtl = DECL_INCOMING_RTL (parms);
2020 current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
2023 if (DECL_NAME (parms))
2025 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2026 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2027 IDENTIFIER_POINTER (DECL_NAME (parms)),
2032 current_sym_nchars = 8;
2033 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2037 dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
2038 dbxout_finish_symbol (parms);
2040 else if (GET_CODE (DECL_RTL (parms)) == MEM
2041 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG)
2042 /* && rtx_equal_p (XEXP (DECL_RTL (parms), 0),
2043 DECL_INCOMING_RTL (parms))) */
2045 /* Parm was passed via invisible reference.
2046 That is, its address was passed in a register.
2047 Output it as if it lived in that register.
2048 The debugger will know from the type
2049 that it was actually passed by invisible reference. */
2051 char regparm_letter;
2052 /* Parm passed in registers and lives in registers or nowhere. */
2054 current_sym_code = DBX_REGPARM_STABS_CODE;
2055 regparm_letter = DBX_REGPARM_STABS_LETTER;
2057 /* DECL_RTL looks like (MEM (REG...). Get the register number. */
2058 current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2059 current_sym_addr = 0;
2062 if (DECL_NAME (parms))
2064 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2066 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2067 IDENTIFIER_POINTER (DECL_NAME (parms)),
2068 DBX_REGPARM_STABS_LETTER);
2072 current_sym_nchars = 8;
2073 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2074 DBX_REGPARM_STABS_LETTER);
2077 dbxout_type (TREE_TYPE (parms), 0, 0);
2078 dbxout_finish_symbol (parms);
2080 else if (GET_CODE (DECL_RTL (parms)) == MEM
2081 && XEXP (DECL_RTL (parms), 0) != const0_rtx
2082 /* ??? A constant address for a parm can happen
2083 when the reg it lives in is equiv to a constant in memory.
2084 Should make this not happen, after 2.4. */
2085 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
2087 /* Parm was passed in registers but lives on the stack. */
2089 current_sym_code = N_PSYM;
2090 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2091 in which case we want the value of that CONST_INT,
2092 or (MEM (REG ...)) or (MEM (MEM ...)),
2093 in which case we use a value of zero. */
2094 if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2095 || GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
2096 current_sym_value = 0;
2098 current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
2099 current_sym_addr = 0;
2102 if (DECL_NAME (parms))
2104 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2106 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2107 IDENTIFIER_POINTER (DECL_NAME (parms)),
2108 DBX_MEMPARM_STABS_LETTER);
2112 current_sym_nchars = 8;
2113 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2114 DBX_MEMPARM_STABS_LETTER);
2118 = DEBUGGER_ARG_OFFSET (current_sym_value,
2119 XEXP (DECL_RTL (parms), 0));
2120 dbxout_type (TREE_TYPE (parms), 0, 0);
2121 dbxout_finish_symbol (parms);
2126 /* Output definitions for the places where parms live during the function,
2127 when different from where they were passed, when the parms were passed
2130 It is not useful to do this for parms passed in registers
2131 that live during the function in different registers, because it is
2132 impossible to look in the passed register for the passed value,
2133 so we use the within-the-function register to begin with.
2135 PARMS is a chain of PARM_DECL nodes. */
2138 dbxout_reg_parms (parms)
2141 for (; parms; parms = TREE_CHAIN (parms))
2142 if (DECL_NAME (parms))
2144 dbxout_prepare_symbol (parms);
2146 /* Report parms that live in registers during the function
2147 but were passed in memory. */
2148 if (GET_CODE (DECL_RTL (parms)) == REG
2149 && REGNO (DECL_RTL (parms)) >= 0
2150 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER
2151 && PARM_PASSED_IN_MEMORY (parms))
2153 current_sym_code = N_RSYM;
2154 current_sym_value = DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms)));
2155 current_sym_addr = 0;
2158 if (DECL_NAME (parms))
2160 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2161 fprintf (asmfile, "%s \"%s:r", ASM_STABS_OP,
2162 IDENTIFIER_POINTER (DECL_NAME (parms)));
2166 current_sym_nchars = 8;
2167 fprintf (asmfile, "%s \"(anon):r", ASM_STABS_OP);
2169 dbxout_type (TREE_TYPE (parms), 0, 0);
2170 dbxout_finish_symbol (parms);
2172 /* Report parms that live in memory but not where they were passed. */
2173 else if (GET_CODE (DECL_RTL (parms)) == MEM
2174 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
2175 && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
2176 && PARM_PASSED_IN_MEMORY (parms)
2177 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
2179 #if 0 /* ??? It is not clear yet what should replace this. */
2180 int offset = DECL_OFFSET (parms) / BITS_PER_UNIT;
2181 /* A parm declared char is really passed as an int,
2182 so it occupies the least significant bytes.
2183 On a big-endian machine those are not the low-numbered ones. */
2184 #if BYTES_BIG_ENDIAN
2185 if (offset != -1 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
2186 offset += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
2187 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
2189 if (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) != offset) {...}
2191 current_sym_code = N_LSYM;
2192 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (DECL_RTL (parms), 0));
2193 current_sym_addr = 0;
2195 if (DECL_NAME (parms))
2197 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2198 fprintf (asmfile, "%s \"%s:", ASM_STABS_OP,
2199 IDENTIFIER_POINTER (DECL_NAME (parms)));
2203 current_sym_nchars = 8;
2204 fprintf (asmfile, "%s \"(anon):", ASM_STABS_OP);
2206 dbxout_type (TREE_TYPE (parms), 0, 0);
2207 dbxout_finish_symbol (parms);
2210 else if (GET_CODE (DECL_RTL (parms)) == MEM
2211 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG)
2213 /* Parm was passed via invisible reference.
2214 That is, its address was passed in a register.
2215 Output it as if it lived in that register.
2216 The debugger will know from the type
2217 that it was actually passed by invisible reference. */
2219 current_sym_code = N_RSYM;
2221 /* DECL_RTL looks like (MEM (REG...). Get the register number. */
2222 current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2223 current_sym_addr = 0;
2226 if (DECL_NAME (parms))
2228 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2230 fprintf (asmfile, "%s \"%s:r", ASM_STABS_OP,
2231 IDENTIFIER_POINTER (DECL_NAME (parms)));
2235 current_sym_nchars = 8;
2236 fprintf (asmfile, "%s \"(anon):r", ASM_STABS_OP);
2239 dbxout_type (TREE_TYPE (parms), 0, 0);
2240 dbxout_finish_symbol (parms);
2246 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2247 output definitions of those names, in raw form */
2255 putc (',', asmfile);
2256 dbxout_type (TREE_VALUE (args), 0, 0);
2258 args = TREE_CHAIN (args);
2262 /* Given a chain of ..._TYPE nodes,
2263 find those which have typedef names and output those names.
2264 This is to ensure those types get output. */
2267 dbxout_types (types)
2268 register tree types;
2272 if (TYPE_NAME (types)
2273 && TREE_CODE (TYPE_NAME (types)) == TYPE_DECL
2274 && ! TREE_ASM_WRITTEN (TYPE_NAME (types)))
2275 dbxout_symbol (TYPE_NAME (types), 1);
2276 types = TREE_CHAIN (types);
2280 /* Output everything about a symbol block (a BLOCK node
2281 that represents a scope level),
2282 including recursive output of contained blocks.
2284 BLOCK is the BLOCK node.
2285 DEPTH is its depth within containing symbol blocks.
2286 ARGS is usually zero; but for the outermost block of the
2287 body of a function, it is a chain of PARM_DECLs for the function parameters.
2288 We output definitions of all the register parms
2289 as if they were local variables of that block.
2291 If -g1 was used, we count blocks just the same, but output nothing
2292 except for the outermost block.
2294 Actually, BLOCK may be several blocks chained together.
2295 We handle them all in sequence. */
2298 dbxout_block (block, depth, args)
2299 register tree block;
2307 /* Ignore blocks never expanded or otherwise marked as real. */
2308 if (TREE_USED (block))
2310 #ifndef DBX_LBRAC_FIRST
2311 /* In dbx format, the syms of a block come before the N_LBRAC. */
2312 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2313 dbxout_syms (BLOCK_VARS (block));
2315 dbxout_reg_parms (args);
2318 /* Now output an N_LBRAC symbol to represent the beginning of
2319 the block. Use the block's tree-walk order to generate
2320 the assembler symbols LBBn and LBEn
2321 that final will define around the code in this block. */
2322 if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE)
2325 blocknum = next_block_number++;
2326 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
2328 if (BLOCK_HANDLER_BLOCK (block))
2330 /* A catch block. Must precede N_LBRAC. */
2331 tree decl = BLOCK_VARS (block);
2334 #ifdef DBX_OUTPUT_CATCH
2335 DBX_OUTPUT_CATCH (asmfile, decl, buf);
2337 fprintf (asmfile, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP,
2338 IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
2339 assemble_name (asmfile, buf);
2340 fprintf (asmfile, "\n");
2342 decl = TREE_CHAIN (decl);
2346 #ifdef DBX_OUTPUT_LBRAC
2347 DBX_OUTPUT_LBRAC (asmfile, buf);
2349 fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_LBRAC);
2350 assemble_name (asmfile, buf);
2351 #if DBX_BLOCKS_FUNCTION_RELATIVE
2352 fputc ('-', asmfile);
2353 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
2355 fprintf (asmfile, "\n");
2359 /* Count blocks the same way regardless of debug_info_level. */
2360 next_block_number++;
2362 #ifdef DBX_LBRAC_FIRST
2363 /* On some weird machines, the syms of a block
2364 come after the N_LBRAC. */
2365 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2366 dbxout_syms (BLOCK_VARS (block));
2368 dbxout_reg_parms (args);
2371 /* Output the subblocks. */
2372 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
2374 /* Refer to the marker for the end of the block. */
2375 if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE)
2378 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
2379 #ifdef DBX_OUTPUT_RBRAC
2380 DBX_OUTPUT_RBRAC (asmfile, buf);
2382 fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_RBRAC);
2383 assemble_name (asmfile, buf);
2384 #if DBX_BLOCKS_FUNCTION_RELATIVE
2385 fputc ('-', asmfile);
2386 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
2388 fprintf (asmfile, "\n");
2392 block = BLOCK_CHAIN (block);
2396 /* Output the information about a function and its arguments and result.
2397 Usually this follows the function's code,
2398 but on some systems, it comes before. */
2401 dbxout_really_begin_function (decl)
2404 dbxout_symbol (decl, 0);
2405 dbxout_parms (DECL_ARGUMENTS (decl));
2406 if (DECL_NAME (DECL_RESULT (decl)) != 0)
2407 dbxout_symbol (DECL_RESULT (decl), 1);
2410 /* Called at beginning of output of function definition. */
2413 dbxout_begin_function (decl)
2416 #ifdef DBX_FUNCTION_FIRST
2417 dbxout_really_begin_function (decl);
2421 /* Output dbx data for a function definition.
2422 This includes a definition of the function name itself (a symbol),
2423 definitions of the parameters (locating them in the parameter list)
2424 and then output the block that makes up the function's body
2425 (including all the auto variables of the function). */
2428 dbxout_function (decl)
2431 #ifndef DBX_FUNCTION_FIRST
2432 dbxout_really_begin_function (decl);
2434 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
2435 #ifdef DBX_OUTPUT_FUNCTION_END
2436 DBX_OUTPUT_FUNCTION_END (asmfile, decl);
2439 #endif /* DBX_DEBUGGING_INFO */