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)) == RECORD_TYPE))
572 dbxout_type_fields (TREE_TYPE (tem));
573 /* Omit here local type decls until we know how to support them. */
574 else if (TREE_CODE (tem) == TYPE_DECL)
576 /* Omit here the nameless fields that are used to skip bits. */
577 else if (DECL_NAME (tem) != 0 && TREE_CODE (tem) != CONST_DECL)
579 /* Continue the line if necessary,
580 but not before the first field. */
581 if (tem != TYPE_FIELDS (type))
584 if (use_gnu_debug_info_extensions
585 && flag_minimal_debug
586 && TREE_CODE (tem) == FIELD_DECL
587 && DECL_VIRTUAL_P (tem)
588 && DECL_ASSEMBLER_NAME (tem))
590 have_used_extensions = 1;
591 CHARS (3 + IDENTIFIER_LENGTH (DECL_NAME (TYPE_NAME (DECL_FCONTEXT (tem)))));
592 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem)), asmfile);
593 dbxout_type (DECL_FCONTEXT (tem), 0, 0);
594 fprintf (asmfile, ":");
595 dbxout_type (TREE_TYPE (tem), 0, 0);
596 fprintf (asmfile, ",%d;",
597 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)));
601 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
602 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem)));
604 if (use_gnu_debug_info_extensions
605 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
606 || TREE_CODE (tem) != FIELD_DECL))
608 have_used_extensions = 1;
610 putc ((TREE_PRIVATE (tem) ? '0'
611 : TREE_PROTECTED (tem) ? '1' : '2'),
616 dbxout_type ((TREE_CODE (tem) == FIELD_DECL
617 && DECL_BIT_FIELD_TYPE (tem))
618 ? DECL_BIT_FIELD_TYPE (tem)
619 : TREE_TYPE (tem), 0, 0);
621 if (TREE_CODE (tem) == VAR_DECL)
623 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
625 char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem));
626 have_used_extensions = 1;
627 fprintf (asmfile, ":%s;", name);
628 CHARS (strlen (name));
632 /* If TEM is non-static, GDB won't understand it. */
633 fprintf (asmfile, ",0,0;");
636 else if (TREE_CODE (DECL_FIELD_BITPOS (tem)) == INTEGER_CST)
638 fprintf (asmfile, ",%d,%d;",
639 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)),
640 TREE_INT_CST_LOW (DECL_SIZE (tem)));
643 /* This has yet to be implemented. */
650 /* Subroutine of `dbxout_type_methods'. Output debug info about the
651 method described DECL. DEBUG_NAME is an encoding of the method's
652 type signature. ??? We may be able to do without DEBUG_NAME altogether
656 dbxout_type_method_1 (decl, debug_name)
660 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
663 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
665 else /* it's a METHOD_TYPE. */
667 /* A for normal functions.
668 B for `const' member functions.
669 C for `volatile' member functions.
670 D for `const volatile' member functions. */
671 if (TYPE_READONLY (TREE_TYPE (firstarg)))
673 if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
676 if (DECL_VINDEX (decl))
682 fprintf (asmfile, ":%s;%c%c%c", debug_name,
683 TREE_PRIVATE (decl) ? '0' : TREE_PROTECTED (decl) ? '1' : '2', c1, c2);
684 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)) + 6
685 - (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
686 if (DECL_VINDEX (decl))
688 fprintf (asmfile, "%d;",
689 TREE_INT_CST_LOW (DECL_VINDEX (decl)));
690 dbxout_type (DECL_CONTEXT (decl), 0, 0);
691 fprintf (asmfile, ";");
696 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
700 dbxout_type_methods (type)
703 /* C++: put out the method names and their parameter lists */
704 tree methods = TYPE_METHODS (type);
706 register tree fndecl;
708 char formatted_type_identifier_length[16];
709 register int type_identifier_length;
711 if (methods == NULL_TREE)
714 type_encoding = DECL_NAME (TYPE_NAME (type));
716 /* C++: Template classes break some assumptions made by this code about
717 the class names, constructor names, and encodings for assembler
718 label names. For now, disable output of dbx info for them. */
720 char *ptr = IDENTIFIER_POINTER (type_encoding);
721 /* This should use index. (mrs) */
722 while (*ptr && *ptr != '<') ptr++;
729 #ifdef HAVE_TEMPLATES
730 if (warn_template_debugging)
731 warning ("dbx info for template class methods not yet supported");
738 type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
740 sprintf(formatted_type_identifier_length, "%d", type_identifier_length);
742 if (TREE_CODE (methods) == FUNCTION_DECL)
744 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
745 fndecl = TREE_VEC_ELT (methods, 0);
747 fndecl = TREE_VEC_ELT (methods, 1);
751 tree name = DECL_NAME (fndecl);
754 /* Group together all the methods for the same operation.
755 These differ in the types of the arguments. */
756 for (last = NULL_TREE;
757 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
758 fndecl = TREE_CHAIN (fndecl))
759 /* Output the name of the field (after overloading), as
760 well as the name of the field before overloading, along
761 with its parameter list */
763 /* This is the "mangled" name of the method.
764 It encodes the argument types. */
765 char *debug_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
772 if (DECL_IGNORED_P (fndecl))
775 if (flag_minimal_debug)
777 /* Detect ordinary methods because their mangled names
778 start with the operation name. */
779 if (!strncmp (IDENTIFIER_POINTER (name), debug_name,
780 IDENTIFIER_LENGTH (name)))
782 debug_name += IDENTIFIER_LENGTH (name);
783 if (debug_name[0] == '_' && debug_name[1] == '_')
785 char *method_name = debug_name + 2;
786 char *length_ptr = formatted_type_identifier_length;
787 /* Get past const and volatile qualifiers. */
788 while (*method_name == 'C' || *method_name == 'V')
790 /* Skip digits for length of type_encoding. */
791 while (*method_name == *length_ptr && *length_ptr)
792 length_ptr++, method_name++;
793 if (! strncmp (method_name,
794 IDENTIFIER_POINTER (type_encoding),
795 type_identifier_length))
796 method_name += type_identifier_length;
797 debug_name = method_name;
800 /* Detect constructors by their style of name mangling. */
801 else if (debug_name[0] == '_' && debug_name[1] == '_')
803 char *ctor_name = debug_name + 2;
804 char *length_ptr = formatted_type_identifier_length;
805 while (*ctor_name == 'C' || *ctor_name == 'V')
807 /* Skip digits for length of type_encoding. */
808 while (*ctor_name == *length_ptr && *length_ptr)
809 length_ptr++, ctor_name++;
810 if (!strncmp (IDENTIFIER_POINTER (type_encoding), ctor_name,
811 type_identifier_length))
812 debug_name = ctor_name + type_identifier_length;
814 /* The other alternative is a destructor. */
818 /* Output the operation name just once, for the first method
822 fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
823 CHARS (IDENTIFIER_LENGTH (name) + 2);
828 dbxout_type (TREE_TYPE (fndecl), 0, destructor);
830 dbxout_type_method_1 (fndecl, debug_name);
840 /* Emit a "range" type specification, which has the form:
841 "r<index type>;<lower bound>;<upper bound>;".
842 TYPE is an INTEGER_TYPE. */
845 dbxout_range_type (type)
848 fprintf (asmfile, "r");
849 if (TREE_TYPE (type) && TREE_CODE (TREE_TYPE(type)) != INTEGER_TYPE)
850 dbxout_type (TREE_TYPE (type), 0, 0);
853 /* This used to say `r1' and we used to take care
854 to make sure that `int' was type number 1. */
855 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (integer_type_node));
857 if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
858 fprintf (asmfile, ";%d",
859 TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)));
861 fprintf (asmfile, ";0");
862 if (TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
863 fprintf (asmfile, ";%d;",
864 TREE_INT_CST_LOW (TYPE_MAX_VALUE (type)));
866 fprintf (asmfile, ";-1;");
869 /* Output a reference to a type. If the type has not yet been
870 described in the dbx output, output its definition now.
871 For a type already defined, just refer to its definition
872 using the type number.
874 If FULL is nonzero, and the type has been described only with
875 a forward-reference, output the definition now.
876 If FULL is zero in this case, just refer to the forward-reference
877 using the number previously allocated.
879 If SHOW_ARG_TYPES is nonzero, we output a description of the argument
880 types for a METHOD_TYPE. */
883 dbxout_type (type, full, show_arg_types)
889 static int anonymous_type_number = 0;
891 /* If there was an input error and we don't really have a type,
892 avoid crashing and write something that is at least valid
893 by assuming `int'. */
894 if (type == error_mark_node)
895 type = integer_type_node;
898 type = TYPE_MAIN_VARIANT (type);
900 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
901 && DECL_IGNORED_P (TYPE_NAME (type)))
905 if (TYPE_SYMTAB_ADDRESS (type) == 0)
907 /* Type has no dbx number assigned. Assign next available number. */
908 TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
910 /* Make sure type vector is long enough to record about this type. */
912 if (next_type_number == typevec_len)
914 typevec = (enum typestatus *) xrealloc (typevec, typevec_len * 2 * sizeof typevec[0]);
915 bzero (typevec + typevec_len, typevec_len * sizeof typevec[0]);
920 /* Output the number of this type, to refer to it. */
921 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
924 #ifdef DBX_TYPE_DEFINED
925 if (DBX_TYPE_DEFINED (type))
929 /* If this type's definition has been output or is now being output,
932 switch (typevec[TYPE_SYMTAB_ADDRESS (type)])
937 /* If we have already had a cross reference,
938 and either that's all we want or that's the best we could do,
939 don't repeat the cross reference.
940 Sun dbx crashes if we do. */
941 if (! full || TYPE_SIZE (type) == 0
942 /* No way in DBX fmt to describe a variable size. */
943 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
951 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
952 leave the type-number completely undefined rather than output
953 a cross-reference. */
954 if (TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
955 || TREE_CODE (type) == ENUMERAL_TYPE)
957 if ((TYPE_NAME (type) != 0 && !full)
958 || TYPE_SIZE (type) == 0)
960 typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_XREF;
965 /* Output a definition now. */
967 fprintf (asmfile, "=");
970 /* Mark it as defined, so that if it is self-referent
971 we will not get into an infinite recursion of definitions. */
973 typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_DEFINED;
975 switch (TREE_CODE (type))
979 /* For a void type, just define it as itself; ie, "5=5".
980 This makes us consider it defined
981 without saying what it is. The debugger will make it
982 a void type when the reference is seen, and nothing will
983 ever override that default. */
984 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
989 if (type == char_type_node && ! TREE_UNSIGNED (type))
990 /* Output the type `char' as a subrange of itself!
991 I don't understand this definition, just copied it
992 from the output of pcc.
993 This used to use `r2' explicitly and we used to
994 take care to make sure that `char' was type number 2. */
995 fprintf (asmfile, "r%d;0;127;", TYPE_SYMTAB_ADDRESS (type));
996 else if (use_gnu_debug_info_extensions && TYPE_PRECISION (type) > BITS_PER_WORD)
998 /* This used to say `r1' and we used to take care
999 to make sure that `int' was type number 1. */
1000 fprintf (asmfile, "r%d;", TYPE_SYMTAB_ADDRESS (integer_type_node));
1001 print_int_cst_octal (TYPE_MIN_VALUE (type));
1002 fprintf (asmfile, ";");
1003 print_int_cst_octal (TYPE_MAX_VALUE (type));
1004 fprintf (asmfile, ";");
1006 else /* Output other integer types as subranges of `int'. */
1007 dbxout_range_type (type);
1012 /* This used to say `r1' and we used to take care
1013 to make sure that `int' was type number 1. */
1014 fprintf (asmfile, "r%d;%d;0;", TYPE_SYMTAB_ADDRESS (integer_type_node),
1015 int_size_in_bytes (type));
1020 /* Output the type `char' as a subrange of itself.
1021 That is what pcc seems to do. */
1022 fprintf (asmfile, "r%d;0;%d;", TYPE_SYMTAB_ADDRESS (char_type_node),
1023 TREE_UNSIGNED (type) ? 255 : 127);
1027 case BOOLEAN_TYPE: /* Define as enumeral type (False, True) */
1028 fprintf (asmfile, "eFalse:0,True:1,;");
1033 putc ('d', asmfile);
1035 dbxout_type (TREE_TYPE (type), 0, 0);
1039 /* Differs from the REAL_TYPE by its new data type number */
1041 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1043 fprintf (asmfile, "r%d;%d;0;",
1044 TYPE_SYMTAB_ADDRESS (type),
1045 int_size_in_bytes (TREE_TYPE (type)));
1046 CHARS (15); /* The number is probably incorrect here. */
1050 /* Output a complex integer type as a structure,
1051 pending some other way to do it. */
1052 fprintf (asmfile, "s%d", int_size_in_bytes (type));
1054 fprintf (asmfile, "real:");
1056 dbxout_type (TREE_TYPE (type), 0, 0);
1057 fprintf (asmfile, ",%d,%d;",
1058 0, TYPE_PRECISION (TREE_TYPE (type)));
1060 fprintf (asmfile, "imag:");
1062 dbxout_type (TREE_TYPE (type), 0, 0);
1063 fprintf (asmfile, ",%d,%d;;",
1064 TYPE_PRECISION (TREE_TYPE (type)),
1065 TYPE_PRECISION (TREE_TYPE (type)));
1071 putc ('S', asmfile);
1073 dbxout_type (TREE_TYPE (type), 0, 0);
1077 /* Output "a" followed by a range type definition
1078 for the index type of the array
1079 followed by a reference to the target-type.
1080 ar1;0;N;M for a C array of type M and size N+1. */
1081 tem = TYPE_DOMAIN (type);
1083 fprintf(asmfile, "ar%d;0;-1",
1084 TYPE_SYMTAB_ADDRESS (integer_type_node));
1087 fprintf(asmfile, "a");
1088 dbxout_range_type (tem);
1091 dbxout_type (TREE_TYPE (type), 0, 0);
1097 int i, n_baseclasses = 0;
1099 if (TYPE_BINFO (type) != 0 && TYPE_BINFO_BASETYPES (type) != 0)
1100 n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
1102 /* Output a structure type. */
1103 if ((TYPE_NAME (type) != 0
1104 #if 0 /* Tiemann says this creates output tha "confuses GDB".
1105 Too bad the info is so vague. Hope this doesn't lose. */
1106 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1107 && DECL_IGNORED_P (TYPE_NAME (type)))
1110 || TYPE_SIZE (type) == 0
1111 /* No way in DBX fmt to describe a variable size. */
1112 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1114 /* If the type is just a cross reference, output one
1115 and mark the type as partially described.
1116 If it later becomes defined, we will output
1117 its real definition.
1118 If the type has a name, don't nest its definition within
1119 another type's definition; instead, output an xref
1120 and let the definition come when the name is defined. */
1121 fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
1123 #if 0 /* This assertion is legitimately false in C++. */
1124 /* We shouldn't be outputting a reference to a type before its
1125 definition unless the type has a tag name.
1126 A typedef name without a tag name should be impossible. */
1127 if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
1130 if (TYPE_NAME (type) != 0)
1131 dbxout_type_name (type);
1133 fprintf (asmfile, "$$%d", anonymous_type_number++);
1134 fprintf (asmfile, ":");
1135 typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_XREF;
1139 /* Identify record or union, and print its size. */
1140 fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "s%d" : "u%d",
1141 int_size_in_bytes (type));
1143 if (use_gnu_debug_info_extensions)
1147 have_used_extensions = 1;
1148 fprintf (asmfile, "!%d,", n_baseclasses);
1152 for (i = 0; i < n_baseclasses; i++)
1154 tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i);
1155 if (use_gnu_debug_info_extensions)
1157 have_used_extensions = 1;
1158 putc (TREE_VIA_VIRTUAL (child) ? '1'
1161 putc (TREE_VIA_PUBLIC (child) ? '2'
1164 fprintf (asmfile, "%d,",
1165 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT);
1167 dbxout_type (BINFO_TYPE (child), 0, 0);
1168 putc (';', asmfile);
1172 /* Print out the base class information with fields
1173 which have the same names at the types they hold. */
1174 dbxout_type_name (BINFO_TYPE (child));
1175 putc (':', asmfile);
1176 dbxout_type (BINFO_TYPE (child), full, 0);
1177 fprintf (asmfile, ",%d,%d;",
1178 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT,
1179 TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child)))) * BITS_PER_UNIT);
1187 /* Write out the field declarations. */
1188 dbxout_type_fields (type);
1189 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
1191 have_used_extensions = 1;
1192 dbxout_type_methods (type);
1194 putc (';', asmfile);
1196 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
1197 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1198 && TYPE_VFIELD (type))
1200 have_used_extensions = 1;
1202 /* Tell GDB+ that it may keep reading. */
1203 putc ('~', asmfile);
1205 /* We need to write out info about what field this class
1206 uses as its "main" vtable pointer field, because if this
1207 field is inherited from a base class, GDB cannot necessarily
1208 figure out which field it's using in time. */
1209 if (TYPE_VFIELD (type))
1211 putc ('%', asmfile);
1212 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0, 0);
1214 putc (';', asmfile);
1220 if ((TYPE_NAME (type) != 0 && !full
1221 && (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1222 && ! DECL_IGNORED_P (TYPE_NAME (type))))
1223 || TYPE_SIZE (type) == 0)
1225 fprintf (asmfile, "xe");
1227 dbxout_type_name (type);
1228 typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_XREF;
1229 fprintf (asmfile, ":");
1232 #ifdef DBX_OUTPUT_ENUM
1233 DBX_OUTPUT_ENUM (asmfile, type);
1235 putc ('e', asmfile);
1237 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
1239 fprintf (asmfile, "%s:%d,", IDENTIFIER_POINTER (TREE_PURPOSE (tem)),
1240 TREE_INT_CST_LOW (TREE_VALUE (tem)));
1241 CHARS (11 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem)));
1242 if (TREE_CHAIN (tem) != 0)
1245 putc (';', asmfile);
1251 putc ('*', asmfile);
1253 dbxout_type (TREE_TYPE (type), 0, 0);
1257 if (use_gnu_debug_info_extensions)
1259 have_used_extensions = 1;
1260 putc ('#', asmfile);
1262 if (flag_minimal_debug && !show_arg_types)
1264 /* Normally, just output the return type.
1265 The argument types are encoded in the method name. */
1266 putc ('#', asmfile);
1267 dbxout_type (TREE_TYPE (type), 0, 0);
1268 putc (';', asmfile);
1273 /* When outputting destructors, we need to write
1274 the argument types out longhand. */
1275 dbxout_type (TYPE_METHOD_BASETYPE (type), 0, 0);
1276 putc (',', asmfile);
1278 dbxout_type (TREE_TYPE (type), 0, 0);
1279 dbxout_args (TYPE_ARG_TYPES (type));
1280 putc (';', asmfile);
1286 /* Treat it as a function type. */
1287 dbxout_type (TREE_TYPE (type), 0, 0);
1292 if (use_gnu_debug_info_extensions)
1294 have_used_extensions = 1;
1295 putc ('@', asmfile);
1297 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0, 0);
1298 putc (',', asmfile);
1300 dbxout_type (TREE_TYPE (type), 0, 0);
1304 /* Should print as an int, because it is really
1306 dbxout_type (integer_type_node, 0, 0);
1310 case REFERENCE_TYPE:
1311 if (use_gnu_debug_info_extensions)
1312 have_used_extensions = 1;
1313 putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
1315 dbxout_type (TREE_TYPE (type), 0, 0);
1319 putc ('f', asmfile);
1321 dbxout_type (TREE_TYPE (type), 0, 0);
1329 /* Print the value of integer constant C, in octal,
1330 handling double precision. */
1333 print_int_cst_octal (c)
1336 unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
1337 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
1338 int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
1340 fprintf (asmfile, "0");
1344 print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
1345 print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
1349 unsigned HOST_WIDE_INT beg = high >> excess;
1350 unsigned HOST_WIDE_INT middle
1351 = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
1352 | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
1353 unsigned HOST_WIDE_INT end
1354 = low & (((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 3 * 3)) - 1);
1355 fprintf (asmfile, "%o%01o", beg, middle);
1356 print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
1361 print_octal (value, digits)
1362 unsigned HOST_WIDE_INT value;
1367 for (i = digits - 1; i >= 0; i--)
1368 fprintf (asmfile, "%01o", ((value >> (3 * i)) & 7));
1371 /* Output the name of type TYPE, with no punctuation.
1372 Such names can be set up either by typedef declarations
1373 or by struct, enum and union tags. */
1376 dbxout_type_name (type)
1380 if (TYPE_NAME (type) == 0)
1382 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
1384 t = TYPE_NAME (type);
1386 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1388 t = DECL_NAME (TYPE_NAME (type));
1393 fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
1394 CHARS (IDENTIFIER_LENGTH (t));
1397 /* Output a .stabs for the symbol defined by DECL,
1398 which must be a ..._DECL node in the normal namespace.
1399 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1400 LOCAL is nonzero if the scope is less than the entire file. */
1403 dbxout_symbol (decl, local)
1408 tree type = TREE_TYPE (decl);
1409 tree context = NULL_TREE;
1412 /* Cast avoids warning in old compilers. */
1413 current_sym_code = (STAB_CODE_TYPE) 0;
1414 current_sym_value = 0;
1415 current_sym_addr = 0;
1417 /* Ignore nameless syms, but don't ignore type tags. */
1419 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
1420 || DECL_IGNORED_P (decl))
1423 dbxout_prepare_symbol (decl);
1425 /* The output will always start with the symbol name,
1426 so always count that in the length-output-so-far. */
1428 if (DECL_NAME (decl) != 0)
1429 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
1431 switch (TREE_CODE (decl))
1434 /* Enum values are defined by defining the enum type. */
1438 if (DECL_RTL (decl) == 0)
1440 if (DECL_EXTERNAL (decl))
1442 /* Don't mention a nested function under its parent. */
1443 context = decl_function_context (decl);
1444 if (context == current_function_decl)
1446 if (GET_CODE (DECL_RTL (decl)) != MEM
1447 || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
1451 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
1452 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1453 TREE_PUBLIC (decl) ? 'F' : 'f');
1455 current_sym_code = N_FUN;
1456 current_sym_addr = XEXP (DECL_RTL (decl), 0);
1458 if (TREE_TYPE (type))
1459 dbxout_type (TREE_TYPE (type), 0, 0);
1461 dbxout_type (void_type_node, 0, 0);
1463 /* For a nested function, when that function is compiled,
1464 mention the containing function name
1465 as well as (since dbx wants it) our own assembler-name. */
1467 fprintf (asmfile, ",%s,%s",
1468 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1469 IDENTIFIER_POINTER (DECL_NAME (context)));
1471 dbxout_finish_symbol (decl);
1476 /* This seems all wrong. Outputting most kinds of types gives no name
1477 at all. A true definition gives no name; a cross-ref for a
1478 structure can give the tag name, but not a type name.
1479 It seems that no typedef name is defined by outputting a type. */
1481 /* If this typedef name was defined by outputting the type,
1482 don't duplicate it. */
1483 if (typevec[TYPE_SYMTAB_ADDRESS (type)] == TYPE_DEFINED
1484 && TYPE_NAME (TREE_TYPE (decl)) == decl)
1487 /* Don't output the same typedef twice.
1488 And don't output what language-specific stuff doesn't want output. */
1489 if (TREE_ASM_WRITTEN (decl) || DECL_IGNORED_P (decl))
1498 if (DECL_NAME (decl))
1500 /* Nonzero means we must output a tag as well as a typedef. */
1503 /* Handle the case of a C++ structure or union
1504 where the TYPE_NAME is a TYPE_DECL
1505 which gives both a typedef name and a tag. */
1506 /* dbx requires the tag first and the typedef second. */
1507 if ((TREE_CODE (type) == RECORD_TYPE
1508 || TREE_CODE (type) == UNION_TYPE)
1509 && TYPE_NAME (type) == decl
1510 && !(use_gnu_debug_info_extensions && have_used_extensions)
1511 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
1512 /* Distinguish the implicit typedefs of C++
1513 from explicit ones that might be found in C. */
1514 && DECL_SOURCE_LINE (decl) == 0)
1516 tree name = TYPE_NAME (type);
1517 if (TREE_CODE (name) == TYPE_DECL)
1518 name = DECL_NAME (name);
1520 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1521 current_sym_value = 0;
1522 current_sym_addr = 0;
1523 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1525 fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP,
1526 IDENTIFIER_POINTER (name));
1527 dbxout_type (type, 1, 0);
1528 dbxout_finish_symbol (NULL_TREE);
1531 /* Output typedef name. */
1532 fprintf (asmfile, "%s \"%s:", ASM_STABS_OP,
1533 IDENTIFIER_POINTER (DECL_NAME (decl)));
1535 /* Short cut way to output a tag also. */
1536 if ((TREE_CODE (type) == RECORD_TYPE
1537 || TREE_CODE (type) == UNION_TYPE)
1538 && TYPE_NAME (type) == decl)
1540 if (use_gnu_debug_info_extensions && have_used_extensions)
1542 putc ('T', asmfile);
1543 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
1545 #if 0 /* Now we generate the tag for this case up above. */
1551 putc ('t', asmfile);
1552 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1554 dbxout_type (type, 1, 0);
1555 dbxout_finish_symbol (decl);
1559 /* Don't output a tag if this is an incomplete type (TYPE_SIZE is
1560 zero). This prevents the sun4 Sun OS 4.x dbx from crashing. */
1562 if (tag_needed && TYPE_NAME (type) != 0 && TYPE_SIZE (type) != 0
1563 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
1565 /* For a TYPE_DECL with no name, but the type has a name,
1567 This is what represents `struct foo' with no typedef. */
1568 /* In C++, the name of a type is the corresponding typedef.
1569 In C, it is an IDENTIFIER_NODE. */
1570 tree name = TYPE_NAME (type);
1571 if (TREE_CODE (name) == TYPE_DECL)
1572 name = DECL_NAME (name);
1574 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1575 current_sym_value = 0;
1576 current_sym_addr = 0;
1577 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1579 fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP,
1580 IDENTIFIER_POINTER (name));
1581 dbxout_type (type, 1, 0);
1582 dbxout_finish_symbol (NULL_TREE);
1586 /* If an enum type has no name, it cannot be referred to,
1587 but we must output it anyway, since the enumeration constants
1588 can be referred to. */
1589 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
1591 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1592 current_sym_value = 0;
1593 current_sym_addr = 0;
1594 current_sym_nchars = 2;
1596 /* Some debuggers fail when given NULL names, so give this a
1597 harmless name of ` '. */
1598 fprintf (asmfile, "%s \" :T", ASM_STABS_OP);
1599 dbxout_type (type, 1, 0);
1600 dbxout_finish_symbol (NULL_TREE);
1603 /* Prevent duplicate output of a typedef. */
1604 TREE_ASM_WRITTEN (decl) = 1;
1609 /* Parm decls go in their own separate chains
1610 and are output by dbxout_reg_parms and dbxout_parms. */
1614 /* Named return value, treat like a VAR_DECL. */
1616 if (DECL_RTL (decl) == 0)
1618 /* Don't mention a variable that is external.
1619 Let the file that defines it describe it. */
1620 if (DECL_EXTERNAL (decl))
1623 /* If the variable is really a constant
1624 and not written in memory, inform the debugger. */
1625 if (TREE_STATIC (decl) && TREE_READONLY (decl)
1626 && DECL_INITIAL (decl) != 0
1627 && ! TREE_ASM_WRITTEN (decl)
1628 && (DECL_FIELD_CONTEXT (decl) == NULL_TREE
1629 || TREE_CODE (DECL_FIELD_CONTEXT (decl)) == BLOCK))
1631 if (TREE_PUBLIC (decl) == 0)
1633 /* The sun4 assembler does not grok this. */
1634 char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1635 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
1636 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
1638 HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl));
1639 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1640 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile, name, ival);
1642 fprintf (asmfile, "%s \"%s:c=i%d\",0x%x,0,0,0\n",
1643 ASM_STABS_OP, name, ival, N_LSYM);
1647 else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
1649 /* don't know how to do this yet. */
1653 /* else it is something we handle like a normal variable. */
1656 DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, 0);
1657 #ifdef LEAF_REG_REMAP
1659 leaf_renumber_regs_insn (DECL_RTL (decl));
1662 /* Don't mention a variable at all
1663 if it was completely optimized into nothingness.
1665 If DECL was from an inline function, then it's rtl
1666 is not identically the rtl that was used in this
1667 particular compilation. */
1668 if (GET_CODE (DECL_RTL (decl)) == REG)
1670 regno = REGNO (DECL_RTL (decl));
1671 if (regno >= FIRST_PSEUDO_REGISTER)
1674 else if (GET_CODE (DECL_RTL (decl)) == SUBREG)
1676 rtx value = DECL_RTL (decl);
1678 while (GET_CODE (value) == SUBREG)
1680 offset += SUBREG_WORD (value);
1681 value = SUBREG_REG (value);
1683 if (GET_CODE (value) == REG)
1685 regno = REGNO (value);
1686 if (regno >= FIRST_PSEUDO_REGISTER)
1690 alter_subreg (DECL_RTL (decl));
1693 /* The kind-of-variable letter depends on where
1694 the variable is and on the scope of its name:
1695 G and N_GSYM for static storage and global scope,
1696 S for static storage and file scope,
1697 V for static storage and local scope,
1698 for those two, use N_LCSYM if data is in bss segment,
1699 N_STSYM if in data segment, N_FUN otherwise.
1700 (We used N_FUN originally, then changed to N_STSYM
1701 to please GDB. However, it seems that confused ld.
1702 Now GDB has been fixed to like N_FUN, says Kingdon.)
1703 no letter at all, and N_LSYM, for auto variable,
1704 r and N_RSYM for register variable. */
1706 if (GET_CODE (DECL_RTL (decl)) == MEM
1707 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == SYMBOL_REF)
1709 if (TREE_PUBLIC (decl))
1712 current_sym_code = N_GSYM;
1716 current_sym_addr = XEXP (DECL_RTL (decl), 0);
1718 letter = decl_function_context (decl) ? 'V' : 'S';
1720 if (!DECL_INITIAL (decl))
1721 current_sym_code = N_LCSYM;
1722 else if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl))
1723 /* This is not quite right, but it's the closest
1724 of all the codes that Unix defines. */
1725 current_sym_code = DBX_STATIC_CONST_VAR_CODE;
1728 /* Ultrix `as' seems to need this. */
1729 #ifdef DBX_STATIC_STAB_DATA_SECTION
1732 current_sym_code = N_STSYM;
1736 else if (regno >= 0)
1739 current_sym_code = N_RSYM;
1740 current_sym_value = DBX_REGISTER_NUMBER (regno);
1742 else if (GET_CODE (DECL_RTL (decl)) == MEM
1743 && (GET_CODE (XEXP (DECL_RTL (decl), 0)) == MEM
1744 || (GET_CODE (XEXP (DECL_RTL (decl), 0)) == REG
1745 && REGNO (XEXP (DECL_RTL (decl), 0)) != FRAME_POINTER_REGNUM)))
1746 /* If the value is indirect by memory or by a register
1747 that isn't the frame pointer
1748 then it means the object is variable-sized and address through
1749 that register or stack slot. DBX has no way to represent this
1750 so all we can do is output the variable as a pointer.
1751 If it's not a parameter, ignore it.
1752 (VAR_DECLs like this can be made by integrate.c.) */
1754 if (GET_CODE (XEXP (DECL_RTL (decl), 0)) == REG)
1757 current_sym_code = N_RSYM;
1758 current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (DECL_RTL (decl), 0)));
1762 current_sym_code = N_LSYM;
1763 /* DECL_RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
1764 We want the value of that CONST_INT. */
1766 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (DECL_RTL (decl), 0), 0));
1769 /* Effectively do build_pointer_type, but don't cache this type,
1770 since it might be temporary whereas the type it points to
1771 might have been saved for inlining. */
1772 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
1773 type = make_node (POINTER_TYPE);
1774 TREE_TYPE (type) = TREE_TYPE (decl);
1776 else if (GET_CODE (DECL_RTL (decl)) == MEM
1777 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == REG)
1779 current_sym_code = N_LSYM;
1780 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (DECL_RTL (decl), 0));
1782 else if (GET_CODE (DECL_RTL (decl)) == MEM
1783 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == PLUS
1784 && GET_CODE (XEXP (XEXP (DECL_RTL (decl), 0), 1)) == CONST_INT)
1786 current_sym_code = N_LSYM;
1787 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
1788 We want the value of that CONST_INT. */
1789 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (DECL_RTL (decl), 0));
1791 else if (GET_CODE (DECL_RTL (decl)) == MEM
1792 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == CONST)
1794 /* Handle an obscure case which can arise when optimizing and
1795 when there are few available registers. (This is *always*
1796 the case for i386/i486 targets). The DECL_RTL looks like
1797 (MEM (CONST ...)) even though this variable is a local `auto'
1798 or a local `register' variable. In effect, what has happened
1799 is that the reload pass has seen that all assignments and
1800 references for one such a local variable can be replaced by
1801 equivalent assignments and references to some static storage
1802 variable, thereby avoiding the need for a register. In such
1803 cases we're forced to lie to debuggers and tell them that
1804 this variable was itself `static'. */
1805 current_sym_code = N_LCSYM;
1807 current_sym_addr = XEXP (XEXP (DECL_RTL (decl), 0), 0);
1810 /* Address might be a MEM, when DECL is a variable-sized object.
1811 Or it might be const0_rtx, meaning previous passes
1812 want us to ignore this variable. */
1815 /* Ok, start a symtab entry and output the variable name. */
1818 #ifdef DBX_STATIC_BLOCK_START
1819 DBX_STATIC_BLOCK_START (asmfile, current_sym_code);
1822 /* One slight hitch: if this is a VAR_DECL which is a static
1823 class member, we must put out the mangled name instead of the
1827 /* Note also that static member (variable) names DO NOT begin
1828 with underscores in .stabs directives. */
1829 if (DECL_LANG_SPECIFIC (decl))
1830 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1832 name = IDENTIFIER_POINTER (DECL_NAME (decl));
1833 fprintf (asmfile, "%s \"%s:", ASM_STABS_OP, name);
1835 if (letter) putc (letter, asmfile);
1836 dbxout_type (type, 0, 0);
1837 dbxout_finish_symbol (decl);
1839 #ifdef DBX_STATIC_BLOCK_END
1840 DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
1847 dbxout_prepare_symbol (decl)
1851 char *filename = DECL_SOURCE_FILE (decl);
1853 dbxout_source_file (asmfile, filename);
1858 dbxout_finish_symbol (sym)
1861 #ifdef DBX_FINISH_SYMBOL
1862 DBX_FINISH_SYMBOL (sym);
1865 if (use_gnu_debug_info_extensions && sym != 0)
1866 line = DECL_SOURCE_LINE (sym);
1868 fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line);
1869 if (current_sym_addr)
1870 output_addr_const (asmfile, current_sym_addr);
1872 fprintf (asmfile, "%d", current_sym_value);
1873 putc ('\n', asmfile);
1877 /* Output definitions of all the decls in a chain. */
1885 dbxout_symbol (syms, 1);
1886 syms = TREE_CHAIN (syms);
1890 /* The following two functions output definitions of function parameters.
1891 Each parameter gets a definition locating it in the parameter list.
1892 Each parameter that is a register variable gets a second definition
1893 locating it in the register.
1895 Printing or argument lists in gdb uses the definitions that
1896 locate in the parameter list. But reference to the variable in
1897 expressions uses preferentially the definition as a register. */
1899 /* Output definitions, referring to storage in the parmlist,
1900 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
1903 dbxout_parms (parms)
1906 for (; parms; parms = TREE_CHAIN (parms))
1907 if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node)
1909 dbxout_prepare_symbol (parms);
1911 /* Perform any necessary register eliminations on the parameter's rtl,
1912 so that the debugging output will be accurate. */
1913 DECL_INCOMING_RTL (parms)
1914 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
1915 DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX);
1916 #ifdef LEAF_REG_REMAP
1919 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
1920 leaf_renumber_regs_insn (DECL_RTL (parms));
1924 if (PARM_PASSED_IN_MEMORY (parms))
1926 rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
1928 /* ??? Here we assume that the parm address is indexed
1929 off the frame pointer or arg pointer.
1930 If that is not true, we produce meaningless results,
1931 but do not crash. */
1932 if (GET_CODE (addr) == PLUS
1933 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
1934 current_sym_value = INTVAL (XEXP (addr, 1));
1936 current_sym_value = 0;
1938 current_sym_code = N_PSYM;
1939 current_sym_addr = 0;
1942 if (DECL_NAME (parms))
1944 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
1946 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
1947 IDENTIFIER_POINTER (DECL_NAME (parms)),
1948 DBX_MEMPARM_STABS_LETTER);
1952 current_sym_nchars = 8;
1953 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
1954 DBX_MEMPARM_STABS_LETTER);
1957 if (GET_CODE (DECL_RTL (parms)) == REG
1958 && REGNO (DECL_RTL (parms)) >= 0
1959 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1960 dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
1963 int original_value = current_sym_value;
1965 /* This is the case where the parm is passed as an int or double
1966 and it is converted to a char, short or float and stored back
1967 in the parmlist. In this case, describe the parm
1968 with the variable's declared type, and adjust the address
1969 if the least significant bytes (which we are using) are not
1971 #if BYTES_BIG_ENDIAN
1972 if (TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1973 current_sym_value += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1974 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1977 if (GET_CODE (DECL_RTL (parms)) == MEM
1978 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1979 && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
1980 && INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == current_sym_value)
1981 dbxout_type (TREE_TYPE (parms), 0, 0);
1984 current_sym_value = original_value;
1985 dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
1988 current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
1989 dbxout_finish_symbol (parms);
1991 else if (GET_CODE (DECL_RTL (parms)) == REG)
1994 char regparm_letter;
1995 /* Parm passed in registers and lives in registers or nowhere. */
1997 current_sym_code = DBX_REGPARM_STABS_CODE;
1998 regparm_letter = DBX_REGPARM_STABS_LETTER;
1999 current_sym_addr = 0;
2001 /* If parm lives in a register, use that register;
2002 pretend the parm was passed there. It would be more consistent
2003 to describe the register where the parm was passed,
2004 but in practice that register usually holds something else. */
2005 if (REGNO (DECL_RTL (parms)) >= 0
2006 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2007 best_rtl = DECL_RTL (parms);
2008 /* If the parm lives nowhere,
2009 use the register where it was passed. */
2011 best_rtl = DECL_INCOMING_RTL (parms);
2012 current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
2015 if (DECL_NAME (parms))
2017 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2018 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2019 IDENTIFIER_POINTER (DECL_NAME (parms)),
2024 current_sym_nchars = 8;
2025 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2029 dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
2030 dbxout_finish_symbol (parms);
2032 else if (GET_CODE (DECL_RTL (parms)) == MEM
2033 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG)
2034 /* && rtx_equal_p (XEXP (DECL_RTL (parms), 0),
2035 DECL_INCOMING_RTL (parms))) */
2037 /* Parm was passed via invisible reference.
2038 That is, its address was passed in a register.
2039 Output it as if it lived in that register.
2040 The debugger will know from the type
2041 that it was actually passed by invisible reference. */
2043 char regparm_letter;
2044 /* Parm passed in registers and lives in registers or nowhere. */
2046 current_sym_code = DBX_REGPARM_STABS_CODE;
2047 regparm_letter = DBX_REGPARM_STABS_LETTER;
2049 /* DECL_RTL looks like (MEM (REG...). Get the register number. */
2050 current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2051 current_sym_addr = 0;
2054 if (DECL_NAME (parms))
2056 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2058 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2059 IDENTIFIER_POINTER (DECL_NAME (parms)),
2060 DBX_REGPARM_STABS_LETTER);
2064 current_sym_nchars = 8;
2065 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2066 DBX_REGPARM_STABS_LETTER);
2069 dbxout_type (TREE_TYPE (parms), 0, 0);
2070 dbxout_finish_symbol (parms);
2072 else if (GET_CODE (DECL_RTL (parms)) == MEM
2073 && XEXP (DECL_RTL (parms), 0) != const0_rtx)
2075 /* Parm was passed in registers but lives on the stack. */
2077 current_sym_code = N_PSYM;
2078 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2079 in which case we want the value of that CONST_INT,
2080 or (MEM (REG ...)) or (MEM (MEM ...)),
2081 in which case we use a value of zero. */
2082 if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2083 || GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
2084 current_sym_value = 0;
2086 current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
2087 current_sym_addr = 0;
2090 if (DECL_NAME (parms))
2092 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2094 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2095 IDENTIFIER_POINTER (DECL_NAME (parms)),
2096 DBX_MEMPARM_STABS_LETTER);
2100 current_sym_nchars = 8;
2101 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2102 DBX_MEMPARM_STABS_LETTER);
2106 = DEBUGGER_ARG_OFFSET (current_sym_value,
2107 XEXP (DECL_RTL (parms), 0));
2108 dbxout_type (TREE_TYPE (parms), 0, 0);
2109 dbxout_finish_symbol (parms);
2114 /* Output definitions for the places where parms live during the function,
2115 when different from where they were passed, when the parms were passed
2118 It is not useful to do this for parms passed in registers
2119 that live during the function in different registers, because it is
2120 impossible to look in the passed register for the passed value,
2121 so we use the within-the-function register to begin with.
2123 PARMS is a chain of PARM_DECL nodes. */
2126 dbxout_reg_parms (parms)
2129 for (; parms; parms = TREE_CHAIN (parms))
2130 if (DECL_NAME (parms))
2132 dbxout_prepare_symbol (parms);
2134 /* Report parms that live in registers during the function
2135 but were passed in memory. */
2136 if (GET_CODE (DECL_RTL (parms)) == REG
2137 && REGNO (DECL_RTL (parms)) >= 0
2138 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER
2139 && PARM_PASSED_IN_MEMORY (parms))
2141 current_sym_code = N_RSYM;
2142 current_sym_value = DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms)));
2143 current_sym_addr = 0;
2146 if (DECL_NAME (parms))
2148 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2149 fprintf (asmfile, "%s \"%s:r", ASM_STABS_OP,
2150 IDENTIFIER_POINTER (DECL_NAME (parms)));
2154 current_sym_nchars = 8;
2155 fprintf (asmfile, "%s \"(anon):r", ASM_STABS_OP);
2157 dbxout_type (TREE_TYPE (parms), 0, 0);
2158 dbxout_finish_symbol (parms);
2160 /* Report parms that live in memory but not where they were passed. */
2161 else if (GET_CODE (DECL_RTL (parms)) == MEM
2162 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
2163 && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
2164 && PARM_PASSED_IN_MEMORY (parms)
2165 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
2167 #if 0 /* ??? It is not clear yet what should replace this. */
2168 int offset = DECL_OFFSET (parms) / BITS_PER_UNIT;
2169 /* A parm declared char is really passed as an int,
2170 so it occupies the least significant bytes.
2171 On a big-endian machine those are not the low-numbered ones. */
2172 #if BYTES_BIG_ENDIAN
2173 if (offset != -1 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
2174 offset += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
2175 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
2177 if (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) != offset) {...}
2179 current_sym_code = N_LSYM;
2180 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (DECL_RTL (parms), 0));
2181 current_sym_addr = 0;
2183 if (DECL_NAME (parms))
2185 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2186 fprintf (asmfile, "%s \"%s:", ASM_STABS_OP,
2187 IDENTIFIER_POINTER (DECL_NAME (parms)));
2191 current_sym_nchars = 8;
2192 fprintf (asmfile, "%s \"(anon):", ASM_STABS_OP);
2194 dbxout_type (TREE_TYPE (parms), 0, 0);
2195 dbxout_finish_symbol (parms);
2198 else if (GET_CODE (DECL_RTL (parms)) == MEM
2199 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG)
2201 /* Parm was passed via invisible reference.
2202 That is, its address was passed in a register.
2203 Output it as if it lived in that register.
2204 The debugger will know from the type
2205 that it was actually passed by invisible reference. */
2207 current_sym_code = N_RSYM;
2209 /* DECL_RTL looks like (MEM (REG...). Get the register number. */
2210 current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2211 current_sym_addr = 0;
2214 if (DECL_NAME (parms))
2216 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2218 fprintf (asmfile, "%s \"%s:r", ASM_STABS_OP,
2219 IDENTIFIER_POINTER (DECL_NAME (parms)));
2223 current_sym_nchars = 8;
2224 fprintf (asmfile, "%s \"(anon):r", ASM_STABS_OP);
2227 dbxout_type (TREE_TYPE (parms), 0, 0);
2228 dbxout_finish_symbol (parms);
2234 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2235 output definitions of those names, in raw form */
2243 putc (',', asmfile);
2244 dbxout_type (TREE_VALUE (args), 0, 0);
2246 args = TREE_CHAIN (args);
2250 /* Given a chain of ..._TYPE nodes,
2251 find those which have typedef names and output those names.
2252 This is to ensure those types get output. */
2255 dbxout_types (types)
2256 register tree types;
2260 if (TYPE_NAME (types)
2261 && TREE_CODE (TYPE_NAME (types)) == TYPE_DECL
2262 && ! TREE_ASM_WRITTEN (TYPE_NAME (types)))
2263 dbxout_symbol (TYPE_NAME (types), 1);
2264 types = TREE_CHAIN (types);
2268 /* Output everything about a symbol block (a BLOCK node
2269 that represents a scope level),
2270 including recursive output of contained blocks.
2272 BLOCK is the BLOCK node.
2273 DEPTH is its depth within containing symbol blocks.
2274 ARGS is usually zero; but for the outermost block of the
2275 body of a function, it is a chain of PARM_DECLs for the function parameters.
2276 We output definitions of all the register parms
2277 as if they were local variables of that block.
2279 If -g1 was used, we count blocks just the same, but output nothing
2280 except for the outermost block.
2282 Actually, BLOCK may be several blocks chained together.
2283 We handle them all in sequence. */
2286 dbxout_block (block, depth, args)
2287 register tree block;
2295 /* Ignore blocks never expanded or otherwise marked as real. */
2296 if (TREE_USED (block))
2298 #ifndef DBX_LBRAC_FIRST
2299 /* In dbx format, the syms of a block come before the N_LBRAC. */
2300 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2301 dbxout_syms (BLOCK_VARS (block));
2303 dbxout_reg_parms (args);
2306 /* Now output an N_LBRAC symbol to represent the beginning of
2307 the block. Use the block's tree-walk order to generate
2308 the assembler symbols LBBn and LBEn
2309 that final will define around the code in this block. */
2310 if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE)
2313 blocknum = next_block_number++;
2314 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
2316 if (BLOCK_HANDLER_BLOCK (block))
2318 /* A catch block. Must precede N_LBRAC. */
2319 tree decl = BLOCK_VARS (block);
2322 #ifdef DBX_OUTPUT_CATCH
2323 DBX_OUTPUT_CATCH (asmfile, decl, buf);
2325 fprintf (asmfile, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP,
2326 IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
2327 assemble_name (asmfile, buf);
2328 fprintf (asmfile, "\n");
2330 decl = TREE_CHAIN (decl);
2334 #ifdef DBX_OUTPUT_LBRAC
2335 DBX_OUTPUT_LBRAC (asmfile, buf);
2337 fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_LBRAC);
2338 assemble_name (asmfile, buf);
2339 #if DBX_BLOCKS_FUNCTION_RELATIVE
2340 fputc ('-', asmfile);
2341 assemble_name (asmfile, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)));
2343 fprintf (asmfile, "\n");
2347 /* Count blocks the same way regardless of debug_info_level. */
2348 next_block_number++;
2350 #ifdef DBX_LBRAC_FIRST
2351 /* On some weird machines, the syms of a block
2352 come after the N_LBRAC. */
2353 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2354 dbxout_syms (BLOCK_VARS (block));
2356 dbxout_reg_parms (args);
2359 /* Output the subblocks. */
2360 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
2362 /* Refer to the marker for the end of the block. */
2363 if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE)
2366 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
2367 #ifdef DBX_OUTPUT_RBRAC
2368 DBX_OUTPUT_RBRAC (asmfile, buf);
2370 fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_RBRAC);
2371 assemble_name (asmfile, buf);
2372 #if DBX_BLOCKS_FUNCTION_RELATIVE
2373 fputc ('-', asmfile);
2374 assemble_name (asmfile, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)));
2376 fprintf (asmfile, "\n");
2380 block = BLOCK_CHAIN (block);
2384 /* Output the information about a function and its arguments and result.
2385 Usually this follows the function's code,
2386 but on some systems, it comes before. */
2389 dbxout_really_begin_function (decl)
2392 dbxout_symbol (decl, 0);
2393 dbxout_parms (DECL_ARGUMENTS (decl));
2394 if (DECL_NAME (DECL_RESULT (decl)) != 0)
2395 dbxout_symbol (DECL_RESULT (decl), 1);
2398 /* Called at beginning of output of function definition. */
2401 dbxout_begin_function (decl)
2404 #ifdef DBX_FUNCTION_FIRST
2405 dbxout_really_begin_function (decl);
2409 /* Output dbx data for a function definition.
2410 This includes a definition of the function name itself (a symbol),
2411 definitions of the parameters (locating them in the parameter list)
2412 and then output the block that makes up the function's body
2413 (including all the auto variables of the function). */
2416 dbxout_function (decl)
2419 #ifndef DBX_FUNCTION_FIRST
2420 dbxout_really_begin_function (decl);
2422 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
2423 #ifdef DBX_OUTPUT_FUNCTION_END
2424 DBX_OUTPUT_FUNCTION_END (asmfile, decl);
2427 #endif /* DBX_DEBUGGING_INFO */