1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* Output dbx-format symbol table data.
22 This consists of many symbol table entries, each of them
23 a .stabs assembler pseudo-op with four operands:
24 a "name" which is really a description of one symbol and its type,
25 a "code", which is a symbol defined in stab.h whose name starts with N_,
26 an unused operand always 0,
27 and a "value" which is an address or an offset.
28 The name is enclosed in doublequote characters.
30 Each function, variable, typedef, and structure tag
31 has a symbol table entry to define it.
32 The beginning and end of each level of name scoping within
33 a function are also marked by special symbol table entries.
35 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
36 and a data type number. The data type number may be followed by
37 "=" and a type definition; normally this will happen the first time
38 the type number is mentioned. The type definition may refer to
39 other types by number, and those type numbers may be followed
40 by "=" and nested definitions.
42 This can make the "name" quite long.
43 When a name is more than 80 characters, we split the .stabs pseudo-op
44 into two .stabs pseudo-ops, both sharing the same "code" and "value".
45 The first one is marked as continued with a double-backslash at the
48 The kind-of-symbol letter distinguished function names from global
49 variables from file-scope variables from parameters from auto
50 variables in memory from typedef names from register variables.
53 The "code" is mostly redundant with the kind-of-symbol letter
54 that goes in the "name", but not entirely: for symbols located
55 in static storage, the "code" says which segment the address is in,
56 which controls how it is relocated.
58 The "value" for a symbol in static storage
59 is the core address of the symbol (actually, the assembler
60 label for the symbol). For a symbol located in a stack slot
61 it is the stack offset; for one in a register, the register number.
62 For a typedef symbol, it is zero.
64 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
65 output while in the text section.
67 For more on data type definitions, see `dbxout_type'. */
69 /* Include these first, because they may define MIN and MAX. */
78 #include "insn-config.h"
81 #include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions. */
87 #ifdef XCOFF_DEBUGGING_INFO
92 #define ASM_STABS_OP ".stabs"
96 #define ASM_STABN_OP ".stabn"
99 #ifndef DBX_TYPE_DECL_STABS_CODE
100 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
103 #ifndef DBX_STATIC_CONST_VAR_CODE
104 #define DBX_STATIC_CONST_VAR_CODE N_FUN
107 #ifndef DBX_REGPARM_STABS_CODE
108 #define DBX_REGPARM_STABS_CODE N_RSYM
111 #ifndef DBX_REGPARM_STABS_LETTER
112 #define DBX_REGPARM_STABS_LETTER 'P'
115 #ifndef DBX_MEMPARM_STABS_LETTER
116 #define DBX_MEMPARM_STABS_LETTER 'p'
119 #ifndef FILE_NAME_JOINER
120 #define FILE_NAME_JOINER "/"
123 /* Nonzero means if the type has methods, only output debugging
124 information if methods are actually written to the asm file. */
126 static int flag_minimal_debug = 1;
128 /* Nonzero if we have actually used any of the GDB extensions
129 to the debugging format. The idea is that we use them for the
130 first time only if there's a strong reason, but once we have done that,
131 we use them whenever convenient. */
133 static int have_used_extensions = 0;
135 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
136 for the N_SO filename stabs label. */
138 static int source_label_number = 1;
142 /* Typical USG systems don't have stab.h, and they also have
143 no use for DBX-format debugging info. */
145 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
147 #ifdef DEBUG_SYMS_TEXT
148 #define FORCE_TEXT text_section ();
153 #if defined (USG) || defined (NO_STAB_H)
154 #include "gstab.h" /* If doing DBX on sysV, use our own stab.h. */
156 #include <stab.h> /* On BSD, use the system's stab.h. */
158 /* This is a GNU extension we need to reference in this file. */
165 #define STAB_CODE_TYPE enum __stab_debug_code
167 #define STAB_CODE_TYPE int
170 /* 1 if PARM is passed to this function in memory. */
172 #define PARM_PASSED_IN_MEMORY(PARM) \
173 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
175 /* A C expression for the integer offset value of an automatic variable
176 (N_LSYM) having address X (an RTX). */
177 #ifndef DEBUGGER_AUTO_OFFSET
178 #define DEBUGGER_AUTO_OFFSET(X) \
179 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
182 /* A C expression for the integer offset value of an argument (N_PSYM)
183 having address X (an RTX). The nominal offset is OFFSET. */
184 #ifndef DEBUGGER_ARG_OFFSET
185 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
188 /* Stream for writing to assembler file. */
190 static FILE *asmfile;
192 /* Last source file name mentioned in a NOTE insn. */
194 static char *lastfile;
196 /* Current working directory. */
200 enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
202 /* Vector recording the status of describing C data types.
203 When we first notice a data type (a tree node),
204 we assign it a number using next_type_number.
205 That is its index in this vector.
206 The vector element says whether we have yet output
207 the definition of the type. TYPE_XREF says we have
208 output it as a cross-reference only. */
210 enum typestatus *typevec;
212 /* Number of elements of space allocated in `typevec'. */
214 static int typevec_len;
216 /* In dbx output, each type gets a unique number.
217 This is the number for the next type output.
218 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
220 static int next_type_number;
222 /* In dbx output, we must assign symbol-blocks id numbers
223 in the order in which their beginnings are encountered.
224 We output debugging info that refers to the beginning and
225 end of the ranges of code in each block
226 with assembler labels LBBn and LBEn, where n is the block number.
227 The labels are generated in final, which assigns numbers to the
228 blocks in the same way. */
230 static int next_block_number;
232 /* These variables are for dbxout_symbol to communicate to
233 dbxout_finish_symbol.
234 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
235 current_sym_value and current_sym_addr are two ways to address the
236 value to store in the symtab entry.
237 current_sym_addr if nonzero represents the value as an rtx.
238 If that is zero, current_sym_value is used. This is used
239 when the value is an offset (such as for auto variables,
240 register variables and parms). */
242 static STAB_CODE_TYPE current_sym_code;
243 static int current_sym_value;
244 static rtx current_sym_addr;
246 /* Number of chars of symbol-description generated so far for the
247 current symbol. Used by CHARS and CONTIN. */
249 static int current_sym_nchars;
251 /* Report having output N chars of the current symbol-description. */
253 #define CHARS(N) (current_sym_nchars += (N))
255 /* Break the current symbol-description, generating a continuation,
256 if it has become long. */
258 #ifndef DBX_CONTIN_LENGTH
259 #define DBX_CONTIN_LENGTH 80
262 #if DBX_CONTIN_LENGTH > 0
264 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
269 void dbxout_types ();
271 void dbxout_symbol ();
272 static void dbxout_type_name ();
273 static void dbxout_type ();
274 static void dbxout_typedefs ();
275 static void dbxout_symbol_name ();
276 static void dbxout_symbol_location ();
277 static void dbxout_prepare_symbol ();
278 static void dbxout_finish_symbol ();
279 static void dbxout_continue ();
280 static void print_int_cst_octal ();
281 static void print_octal ();
283 #if 0 /* Not clear we will actually need this. */
285 /* Return the absolutized filename for the given relative
286 filename. Note that if that filename is already absolute, it may
287 still be returned in a modified form because this routine also
288 eliminates redundant slashes and single dots and eliminates double
289 dots to get a shortest possible filename from the given input
290 filename. The absolutization of relative filenames is made by
291 assuming that the given filename is to be taken as relative to
292 the first argument (cwd) or to the current directory if cwd is
296 abspath (rel_filename)
299 /* Setup the current working directory as needed. */
301 = (char *) alloca (strlen (cwd) + strlen (rel_filename) + 1);
302 char *endp = abs_buffer;
306 /* Copy the filename (possibly preceded by the current working
307 directory name) into the absolutization buffer. */
312 if (rel_filename[0] != '/')
315 while (*endp++ = *src_p++)
317 *(endp-1) = '/'; /* overwrite null */
319 src_p = rel_filename;
320 while (*endp++ = *src_p++)
325 /* Now make a copy of abs_buffer into abs_buffer, shortening the
326 filename (by taking out slashes and dots) as we go. */
328 outp = inp = abs_buffer;
329 *outp++ = *inp++; /* copy first slash */
334 else if (inp[0] == '/' && outp[-1] == '/')
339 else if (inp[0] == '.' && outp[-1] == '/')
343 else if (inp[1] == '/')
348 else if ((inp[1] == '.') && (inp[2] == 0 || inp[2] == '/'))
350 inp += (inp[2] == '/') ? 3 : 2;
352 while (outp >= abs_buffer && *outp != '/')
354 if (outp < abs_buffer)
356 /* Catch cases like /.. where we try to backup to a
357 point above the absolute root of the logical file
360 fprintf (stderr, "%s: invalid file name: %s\n",
361 pname, rel_filename);
371 /* On exit, make sure that there is a trailing null, and make sure that
372 the last character of the returned string is *not* a slash. */
378 /* Make a copy (in the heap) of the stuff left in the absolutization
379 buffer and return a pointer to the copy. */
381 value = (char *) oballoc (strlen (abs_buffer) + 1);
382 strcpy (value, abs_buffer);
387 /* At the beginning of compilation, start writing the symbol table.
388 Initialize `typevec' and output the standard data types of C. */
391 dbxout_init (asm_file, input_file_name, syms)
393 char *input_file_name;
396 char ltext_label_name[100];
401 typevec = (enum typestatus *) xmalloc (typevec_len * sizeof typevec[0]);
402 bzero ((char *) typevec, typevec_len * sizeof typevec[0]);
404 /* Convert Ltext into the appropriate format for local labels in case
405 the system doesn't insert underscores in front of user generated
407 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
409 /* Put the current working directory in an N_SO symbol. */
410 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
411 but GDB always does. */
412 if (use_gnu_debug_info_extensions)
415 if (!cwd && (cwd = getpwd ()) && (!*cwd || cwd[strlen (cwd) - 1] != '/'))
417 char *wdslash = xmalloc (strlen (cwd) + sizeof (FILE_NAME_JOINER));
418 sprintf (wdslash, "%s%s", cwd, FILE_NAME_JOINER);
423 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
424 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd);
425 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
426 fprintf (asmfile, "%s ", ASM_STABS_OP);
427 output_quoted_string (asmfile, cwd);
428 fprintf (asmfile, ",%d,0,0,%s\n", N_SO, <ext_label_name[1]);
429 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
433 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
434 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
435 would give us an N_SOL, and we want an N_SO. */
436 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile, input_file_name);
437 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
438 /* We include outputting `Ltext:' here,
439 because that gives you a way to override it. */
440 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
441 fprintf (asmfile, "%s ", ASM_STABS_OP);
442 output_quoted_string (asmfile, input_file_name);
443 fprintf (asmfile, ",%d,0,0,%s\n",
444 N_SO, <ext_label_name[1]);
446 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Ltext", 0);
447 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
449 /* Possibly output something to inform GDB that this compilation was by
450 GCC. It's easier for GDB to parse it when after the N_SO's. This
451 is used in Solaris 2. */
452 #ifdef ASM_IDENTIFY_GCC_AFTER_SOURCE
453 ASM_IDENTIFY_GCC_AFTER_SOURCE (asmfile);
456 lastfile = input_file_name;
458 next_type_number = 1;
459 next_block_number = 2;
461 /* Make sure that types `int' and `char' have numbers 1 and 2.
462 Definitions of other integer types will refer to those numbers.
463 (Actually it should no longer matter what their numbers are.
464 Also, if any types with tags have been defined, dbxout_symbol
465 will output them first, so the numbers won't be 1 and 2. That
466 happens in C++. So it's a good thing it should no longer matter). */
468 #ifdef DBX_OUTPUT_STANDARD_TYPES
469 DBX_OUTPUT_STANDARD_TYPES (syms);
471 dbxout_symbol (TYPE_NAME (integer_type_node), 0);
472 dbxout_symbol (TYPE_NAME (char_type_node), 0);
475 /* Get all permanent types that have typedef names,
476 and output them all, except for those already output. */
478 dbxout_typedefs (syms);
481 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
482 in the reverse order from that which is found in SYMS. */
485 dbxout_typedefs (syms)
490 dbxout_typedefs (TREE_CHAIN (syms));
491 if (TREE_CODE (syms) == TYPE_DECL)
493 tree type = TREE_TYPE (syms);
495 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
496 && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
497 dbxout_symbol (TYPE_NAME (type), 0);
502 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
505 dbxout_source_file (file, filename)
509 char ltext_label_name[100];
511 if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
513 #ifdef DBX_OUTPUT_SOURCE_FILENAME
514 DBX_OUTPUT_SOURCE_FILENAME (file, filename);
516 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext",
517 source_label_number);
518 fprintf (file, "%s ", ASM_STABS_OP);
519 output_quoted_string (file, filename);
520 fprintf (file, ",%d,0,0,%s\n", N_SOL, <ext_label_name[1]);
522 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Ltext", source_label_number);
523 source_label_number++;
529 /* Output a line number symbol entry into output stream FILE,
530 for source file FILENAME and line number LINENO. */
533 dbxout_source_line (file, filename, lineno)
538 dbxout_source_file (file, filename);
540 #ifdef ASM_OUTPUT_SOURCE_LINE
541 ASM_OUTPUT_SOURCE_LINE (file, lineno);
543 fprintf (file, "\t%s %d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno);
547 /* At the end of compilation, finish writing the symbol table.
548 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
552 dbxout_finish (file, filename)
556 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
557 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file, filename);
558 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
561 /* Continue a symbol-description that gets too big.
562 End one symbol table entry with a double-backslash
563 and start a new one, eventually producing something like
564 .stabs "start......\\",code,0,value
565 .stabs "...rest",code,0,value */
570 #ifdef DBX_CONTIN_CHAR
571 fprintf (asmfile, "%c", DBX_CONTIN_CHAR);
573 fprintf (asmfile, "\\\\");
575 dbxout_finish_symbol (NULL_TREE);
576 fprintf (asmfile, "%s \"", ASM_STABS_OP);
577 current_sym_nchars = 0;
580 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
581 This must be a separate function because anonymous unions require
585 dbxout_type_fields (type)
589 /* Output the name, type, position (in bits), size (in bits) of each
591 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
593 /* Omit here local type decls until we know how to support them. */
594 if (TREE_CODE (tem) == TYPE_DECL)
596 /* Omit fields whose position or size are variable. */
597 else if (TREE_CODE (tem) == FIELD_DECL
598 && (TREE_CODE (DECL_FIELD_BITPOS (tem)) != INTEGER_CST
599 || TREE_CODE (DECL_SIZE (tem)) != INTEGER_CST))
601 /* Omit here the nameless fields that are used to skip bits. */
602 else if (TREE_CODE (tem) != CONST_DECL)
604 /* Continue the line if necessary,
605 but not before the first field. */
606 if (tem != TYPE_FIELDS (type))
609 if (use_gnu_debug_info_extensions
610 && flag_minimal_debug
611 && TREE_CODE (tem) == FIELD_DECL
612 && DECL_VIRTUAL_P (tem)
613 && DECL_ASSEMBLER_NAME (tem))
615 have_used_extensions = 1;
616 CHARS (3 + IDENTIFIER_LENGTH (DECL_NAME (TYPE_NAME (DECL_FCONTEXT (tem)))));
617 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem)), asmfile);
618 dbxout_type (DECL_FCONTEXT (tem), 0, 0);
619 fprintf (asmfile, ":");
620 dbxout_type (TREE_TYPE (tem), 0, 0);
621 fprintf (asmfile, ",%d;",
622 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)));
628 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
629 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem)));
633 fprintf (asmfile, ":");
637 if (use_gnu_debug_info_extensions
638 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
639 || TREE_CODE (tem) != FIELD_DECL))
641 have_used_extensions = 1;
643 putc ((TREE_PRIVATE (tem) ? '0'
644 : TREE_PROTECTED (tem) ? '1' : '2'),
649 dbxout_type ((TREE_CODE (tem) == FIELD_DECL
650 && DECL_BIT_FIELD_TYPE (tem))
651 ? DECL_BIT_FIELD_TYPE (tem)
652 : TREE_TYPE (tem), 0, 0);
654 if (TREE_CODE (tem) == VAR_DECL)
656 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
658 char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem));
659 have_used_extensions = 1;
660 fprintf (asmfile, ":%s;", name);
661 CHARS (strlen (name));
665 /* If TEM is non-static, GDB won't understand it. */
666 fprintf (asmfile, ",0,0;");
669 else if (TREE_CODE (DECL_FIELD_BITPOS (tem)) == INTEGER_CST)
671 fprintf (asmfile, ",%d,%d;",
672 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)),
673 TREE_INT_CST_LOW (DECL_SIZE (tem)));
680 /* Subroutine of `dbxout_type_methods'. Output debug info about the
681 method described DECL. DEBUG_NAME is an encoding of the method's
682 type signature. ??? We may be able to do without DEBUG_NAME altogether
686 dbxout_type_method_1 (decl, debug_name)
690 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
693 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
695 else /* it's a METHOD_TYPE. */
697 /* A for normal functions.
698 B for `const' member functions.
699 C for `volatile' member functions.
700 D for `const volatile' member functions. */
701 if (TYPE_READONLY (TREE_TYPE (firstarg)))
703 if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
706 if (DECL_VINDEX (decl))
712 fprintf (asmfile, ":%s;%c%c%c", debug_name,
713 TREE_PRIVATE (decl) ? '0' : TREE_PROTECTED (decl) ? '1' : '2', c1, c2);
714 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)) + 6
715 - (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
716 if (DECL_VINDEX (decl))
718 fprintf (asmfile, "%d;",
719 TREE_INT_CST_LOW (DECL_VINDEX (decl)));
720 dbxout_type (DECL_CONTEXT (decl), 0, 0);
721 fprintf (asmfile, ";");
726 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
730 dbxout_type_methods (type)
733 /* C++: put out the method names and their parameter lists */
734 tree methods = TYPE_METHODS (type);
736 register tree fndecl;
738 char formatted_type_identifier_length[16];
739 register int type_identifier_length;
741 if (methods == NULL_TREE)
744 type_encoding = DECL_NAME (TYPE_NAME (type));
747 /* C++: Template classes break some assumptions made by this code about
748 the class names, constructor names, and encodings for assembler
749 label names. For now, disable output of dbx info for them. */
751 char *ptr = IDENTIFIER_POINTER (type_encoding);
752 /* This should use index. (mrs) */
753 while (*ptr && *ptr != '<') ptr++;
760 #ifdef HAVE_TEMPLATES
761 if (warn_template_debugging)
762 warning ("dbx info for template class methods not yet supported");
770 type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
772 sprintf(formatted_type_identifier_length, "%d", type_identifier_length);
774 if (TREE_CODE (methods) == FUNCTION_DECL)
776 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
777 fndecl = TREE_VEC_ELT (methods, 0);
779 fndecl = TREE_VEC_ELT (methods, 1);
783 tree name = DECL_NAME (fndecl);
786 /* Group together all the methods for the same operation.
787 These differ in the types of the arguments. */
788 for (last = NULL_TREE;
789 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
790 fndecl = TREE_CHAIN (fndecl))
791 /* Output the name of the field (after overloading), as
792 well as the name of the field before overloading, along
793 with its parameter list */
795 /* This is the "mangled" name of the method.
796 It encodes the argument types. */
797 char *debug_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
804 if (DECL_IGNORED_P (fndecl))
807 if (flag_minimal_debug)
809 /* Detect ordinary methods because their mangled names
810 start with the operation name. */
811 if (!strncmp (IDENTIFIER_POINTER (name), debug_name,
812 IDENTIFIER_LENGTH (name)))
814 debug_name += IDENTIFIER_LENGTH (name);
815 if (debug_name[0] == '_' && debug_name[1] == '_')
817 char *method_name = debug_name + 2;
818 char *length_ptr = formatted_type_identifier_length;
819 /* Get past const and volatile qualifiers. */
820 while (*method_name == 'C' || *method_name == 'V')
822 /* Skip digits for length of type_encoding. */
823 while (*method_name == *length_ptr && *length_ptr)
824 length_ptr++, method_name++;
825 if (! strncmp (method_name,
826 IDENTIFIER_POINTER (type_encoding),
827 type_identifier_length))
828 method_name += type_identifier_length;
829 debug_name = method_name;
832 /* Detect constructors by their style of name mangling. */
833 else if (debug_name[0] == '_' && debug_name[1] == '_')
835 char *ctor_name = debug_name + 2;
836 char *length_ptr = formatted_type_identifier_length;
837 while (*ctor_name == 'C' || *ctor_name == 'V')
839 /* Skip digits for length of type_encoding. */
840 while (*ctor_name == *length_ptr && *length_ptr)
841 length_ptr++, ctor_name++;
842 if (!strncmp (IDENTIFIER_POINTER (type_encoding), ctor_name,
843 type_identifier_length))
844 debug_name = ctor_name + type_identifier_length;
846 /* The other alternative is a destructor. */
850 /* Output the operation name just once, for the first method
854 fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
855 CHARS (IDENTIFIER_LENGTH (name) + 2);
860 dbxout_type (TREE_TYPE (fndecl), 0, destructor);
862 dbxout_type_method_1 (fndecl, debug_name);
872 /* Emit a "range" type specification, which has the form:
873 "r<index type>;<lower bound>;<upper bound>;".
874 TYPE is an INTEGER_TYPE. */
877 dbxout_range_type (type)
880 fprintf (asmfile, "r");
881 if (TREE_TYPE (type))
882 dbxout_type (TREE_TYPE (type), 0, 0);
883 else if (TREE_CODE (type) != INTEGER_TYPE)
884 dbxout_type (type, 0, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
887 /* This used to say `r1' and we used to take care
888 to make sure that `int' was type number 1. */
889 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (integer_type_node));
891 if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
892 fprintf (asmfile, ";%d",
893 TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)));
895 fprintf (asmfile, ";0");
896 if (TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
897 fprintf (asmfile, ";%d;",
898 TREE_INT_CST_LOW (TYPE_MAX_VALUE (type)));
900 fprintf (asmfile, ";-1;");
903 /* Output a reference to a type. If the type has not yet been
904 described in the dbx output, output its definition now.
905 For a type already defined, just refer to its definition
906 using the type number.
908 If FULL is nonzero, and the type has been described only with
909 a forward-reference, output the definition now.
910 If FULL is zero in this case, just refer to the forward-reference
911 using the number previously allocated.
913 If SHOW_ARG_TYPES is nonzero, we output a description of the argument
914 types for a METHOD_TYPE. */
917 dbxout_type (type, full, show_arg_types)
923 static int anonymous_type_number = 0;
925 /* If there was an input error and we don't really have a type,
926 avoid crashing and write something that is at least valid
927 by assuming `int'. */
928 if (type == error_mark_node)
929 type = integer_type_node;
932 type = TYPE_MAIN_VARIANT (type);
934 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
935 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
939 if (TYPE_SYMTAB_ADDRESS (type) == 0)
941 /* Type has no dbx number assigned. Assign next available number. */
942 TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
944 /* Make sure type vector is long enough to record about this type. */
946 if (next_type_number == typevec_len)
949 (enum typestatus *) xrealloc (typevec,
950 typevec_len * 2 * sizeof typevec[0]);
951 bzero ((char *) (typevec + typevec_len),
952 typevec_len * sizeof typevec[0]);
957 /* Output the number of this type, to refer to it. */
958 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
961 #ifdef DBX_TYPE_DEFINED
962 if (DBX_TYPE_DEFINED (type))
966 /* If this type's definition has been output or is now being output,
969 switch (typevec[TYPE_SYMTAB_ADDRESS (type)])
974 /* If we have already had a cross reference,
975 and either that's all we want or that's the best we could do,
976 don't repeat the cross reference.
977 Sun dbx crashes if we do. */
978 if (! full || TYPE_SIZE (type) == 0
979 /* No way in DBX fmt to describe a variable size. */
980 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
988 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
989 leave the type-number completely undefined rather than output
990 a cross-reference. If we have already used GNU debug info extensions,
991 then it is OK to output a cross reference. This is necessary to get
992 proper C++ debug output. */
993 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
994 || TREE_CODE (type) == QUAL_UNION_TYPE
995 || TREE_CODE (type) == ENUMERAL_TYPE)
996 && ! use_gnu_debug_info_extensions)
997 /* We must use the same test here as we use twice below when deciding
998 whether to emit a cross-reference. */
999 if ((TYPE_NAME (type) != 0
1000 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1001 && DECL_IGNORED_P (TYPE_NAME (type)))
1003 || TYPE_SIZE (type) == 0
1004 /* No way in DBX fmt to describe a variable size. */
1005 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1007 typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_XREF;
1012 /* Output a definition now. */
1014 fprintf (asmfile, "=");
1017 /* Mark it as defined, so that if it is self-referent
1018 we will not get into an infinite recursion of definitions. */
1020 typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_DEFINED;
1022 switch (TREE_CODE (type))
1026 /* For a void type, just define it as itself; ie, "5=5".
1027 This makes us consider it defined
1028 without saying what it is. The debugger will make it
1029 a void type when the reference is seen, and nothing will
1030 ever override that default. */
1031 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
1036 if (type == char_type_node && ! TREE_UNSIGNED (type))
1037 /* Output the type `char' as a subrange of itself!
1038 I don't understand this definition, just copied it
1039 from the output of pcc.
1040 This used to use `r2' explicitly and we used to
1041 take care to make sure that `char' was type number 2. */
1042 fprintf (asmfile, "r%d;0;127;", TYPE_SYMTAB_ADDRESS (type));
1043 else if (use_gnu_debug_info_extensions
1044 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
1045 || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT))
1047 /* This used to say `r1' and we used to take care
1048 to make sure that `int' was type number 1. */
1049 fprintf (asmfile, "r%d;", TYPE_SYMTAB_ADDRESS (integer_type_node));
1050 print_int_cst_octal (TYPE_MIN_VALUE (type));
1051 fprintf (asmfile, ";");
1052 print_int_cst_octal (TYPE_MAX_VALUE (type));
1053 fprintf (asmfile, ";");
1055 else /* Output other integer types as subranges of `int'. */
1056 dbxout_range_type (type);
1061 /* This used to say `r1' and we used to take care
1062 to make sure that `int' was type number 1. */
1063 fprintf (asmfile, "r%d;%d;0;", TYPE_SYMTAB_ADDRESS (integer_type_node),
1064 int_size_in_bytes (type));
1069 if (use_gnu_debug_info_extensions)
1070 fprintf (asmfile, "@s%d;-20;",
1071 BITS_PER_UNIT * int_size_in_bytes (type));
1073 /* Output the type `char' as a subrange of itself.
1074 That is what pcc seems to do. */
1075 fprintf (asmfile, "r%d;0;%d;", TYPE_SYMTAB_ADDRESS (char_type_node),
1076 TREE_UNSIGNED (type) ? 255 : 127);
1081 if (use_gnu_debug_info_extensions)
1082 fprintf (asmfile, "@s%d;-16;",
1083 BITS_PER_UNIT * int_size_in_bytes (type));
1084 else /* Define as enumeral type (False, True) */
1085 fprintf (asmfile, "eFalse:0,True:1,;");
1090 putc ('d', asmfile);
1092 dbxout_type (TREE_TYPE (type), 0, 0);
1096 /* Differs from the REAL_TYPE by its new data type number */
1098 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1100 fprintf (asmfile, "r%d;%d;0;",
1101 TYPE_SYMTAB_ADDRESS (type),
1102 int_size_in_bytes (TREE_TYPE (type)));
1103 CHARS (15); /* The number is probably incorrect here. */
1107 /* Output a complex integer type as a structure,
1108 pending some other way to do it. */
1109 fprintf (asmfile, "s%d", int_size_in_bytes (type));
1111 fprintf (asmfile, "real:");
1113 dbxout_type (TREE_TYPE (type), 0, 0);
1114 fprintf (asmfile, ",%d,%d;",
1115 0, TYPE_PRECISION (TREE_TYPE (type)));
1117 fprintf (asmfile, "imag:");
1119 dbxout_type (TREE_TYPE (type), 0, 0);
1120 fprintf (asmfile, ",%d,%d;;",
1121 TYPE_PRECISION (TREE_TYPE (type)),
1122 TYPE_PRECISION (TREE_TYPE (type)));
1128 if (use_gnu_debug_info_extensions)
1130 have_used_extensions = 1;
1131 fprintf (asmfile, "@s%d;",
1132 BITS_PER_UNIT * int_size_in_bytes (type));
1133 /* Check if a bitstring type, which in Chill is
1134 different from a [power]set. */
1135 if (TYPE_STRING_FLAG (type))
1136 fprintf (asmfile, "@S;");
1138 putc ('S', asmfile);
1140 dbxout_type (TYPE_DOMAIN (type), 0, 0);
1144 /* Output "a" followed by a range type definition
1145 for the index type of the array
1146 followed by a reference to the target-type.
1147 ar1;0;N;M for a C array of type M and size N+1. */
1148 /* Check if a character string type, which in Chill is
1149 different from an array of characters. */
1150 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
1152 have_used_extensions = 1;
1153 fprintf (asmfile, "@S;");
1155 tem = TYPE_DOMAIN (type);
1157 fprintf (asmfile, "ar%d;0;-1;",
1158 TYPE_SYMTAB_ADDRESS (integer_type_node));
1161 fprintf (asmfile, "a");
1162 dbxout_range_type (tem);
1165 dbxout_type (TREE_TYPE (type), 0, 0);
1170 case QUAL_UNION_TYPE:
1172 int i, n_baseclasses = 0;
1174 if (TYPE_BINFO (type) != 0 && TYPE_BINFO_BASETYPES (type) != 0)
1175 n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
1177 /* Output a structure type. We must use the same test here as we
1178 use in the DBX_NO_XREFS case above. */
1179 if ((TYPE_NAME (type) != 0
1180 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1181 && DECL_IGNORED_P (TYPE_NAME (type)))
1183 || TYPE_SIZE (type) == 0
1184 /* No way in DBX fmt to describe a variable size. */
1185 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1187 /* If the type is just a cross reference, output one
1188 and mark the type as partially described.
1189 If it later becomes defined, we will output
1190 its real definition.
1191 If the type has a name, don't nest its definition within
1192 another type's definition; instead, output an xref
1193 and let the definition come when the name is defined. */
1194 fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
1196 #if 0 /* This assertion is legitimately false in C++. */
1197 /* We shouldn't be outputting a reference to a type before its
1198 definition unless the type has a tag name.
1199 A typedef name without a tag name should be impossible. */
1200 if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
1203 if (TYPE_NAME (type) != 0)
1204 dbxout_type_name (type);
1206 fprintf (asmfile, "$$%d", anonymous_type_number++);
1207 fprintf (asmfile, ":");
1208 typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_XREF;
1212 /* Identify record or union, and print its size. */
1213 fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "s%d" : "u%d",
1214 int_size_in_bytes (type));
1216 if (use_gnu_debug_info_extensions)
1220 have_used_extensions = 1;
1221 fprintf (asmfile, "!%d,", n_baseclasses);
1225 for (i = 0; i < n_baseclasses; i++)
1227 tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i);
1228 if (use_gnu_debug_info_extensions)
1230 have_used_extensions = 1;
1231 putc (TREE_VIA_VIRTUAL (child) ? '1'
1234 putc (TREE_VIA_PUBLIC (child) ? '2'
1237 fprintf (asmfile, "%d,",
1238 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT);
1240 dbxout_type (BINFO_TYPE (child), 0, 0);
1241 putc (';', asmfile);
1245 /* Print out the base class information with fields
1246 which have the same names at the types they hold. */
1247 dbxout_type_name (BINFO_TYPE (child));
1248 putc (':', asmfile);
1249 dbxout_type (BINFO_TYPE (child), full, 0);
1250 fprintf (asmfile, ",%d,%d;",
1251 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT,
1252 TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child)))) * BITS_PER_UNIT);
1260 /* Write out the field declarations. */
1261 dbxout_type_fields (type);
1262 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
1264 have_used_extensions = 1;
1265 dbxout_type_methods (type);
1267 putc (';', asmfile);
1269 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
1270 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1271 && TYPE_VFIELD (type))
1273 have_used_extensions = 1;
1275 /* Tell GDB+ that it may keep reading. */
1276 putc ('~', asmfile);
1278 /* We need to write out info about what field this class
1279 uses as its "main" vtable pointer field, because if this
1280 field is inherited from a base class, GDB cannot necessarily
1281 figure out which field it's using in time. */
1282 if (TYPE_VFIELD (type))
1284 putc ('%', asmfile);
1285 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0, 0);
1287 putc (';', asmfile);
1293 /* We must use the same test here as we use in the DBX_NO_XREFS case
1294 above. We simplify it a bit since an enum will never have a variable
1296 if ((TYPE_NAME (type) != 0
1297 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1298 && DECL_IGNORED_P (TYPE_NAME (type)))
1300 || TYPE_SIZE (type) == 0)
1302 fprintf (asmfile, "xe");
1304 dbxout_type_name (type);
1305 typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_XREF;
1306 fprintf (asmfile, ":");
1309 #ifdef DBX_OUTPUT_ENUM
1310 DBX_OUTPUT_ENUM (asmfile, type);
1312 if (use_gnu_debug_info_extensions
1313 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1314 fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1315 putc ('e', asmfile);
1317 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
1319 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1320 if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
1321 fprintf (asmfile, "%lu",
1322 (unsigned long) TREE_INT_CST_LOW (TREE_VALUE (tem)));
1323 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
1324 && TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
1325 fprintf (asmfile, "%ld",
1326 (long) TREE_INT_CST_LOW (TREE_VALUE (tem)));
1328 print_int_cst_octal (TREE_VALUE (tem));
1329 fprintf (asmfile, ",");
1330 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem)));
1331 if (TREE_CHAIN (tem) != 0)
1334 putc (';', asmfile);
1340 putc ('*', asmfile);
1342 dbxout_type (TREE_TYPE (type), 0, 0);
1346 if (use_gnu_debug_info_extensions)
1348 have_used_extensions = 1;
1349 putc ('#', asmfile);
1351 if (flag_minimal_debug && !show_arg_types)
1353 /* Normally, just output the return type.
1354 The argument types are encoded in the method name. */
1355 putc ('#', asmfile);
1356 dbxout_type (TREE_TYPE (type), 0, 0);
1357 putc (';', asmfile);
1362 /* When outputting destructors, we need to write
1363 the argument types out longhand. */
1364 dbxout_type (TYPE_METHOD_BASETYPE (type), 0, 0);
1365 putc (',', asmfile);
1367 dbxout_type (TREE_TYPE (type), 0, 0);
1368 dbxout_args (TYPE_ARG_TYPES (type));
1369 putc (';', asmfile);
1375 /* Treat it as a function type. */
1376 dbxout_type (TREE_TYPE (type), 0, 0);
1381 if (use_gnu_debug_info_extensions)
1383 have_used_extensions = 1;
1384 putc ('@', asmfile);
1386 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0, 0);
1387 putc (',', asmfile);
1389 dbxout_type (TREE_TYPE (type), 0, 0);
1393 /* Should print as an int, because it is really
1395 dbxout_type (integer_type_node, 0, 0);
1399 case REFERENCE_TYPE:
1400 if (use_gnu_debug_info_extensions)
1401 have_used_extensions = 1;
1402 putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
1404 dbxout_type (TREE_TYPE (type), 0, 0);
1408 putc ('f', asmfile);
1410 dbxout_type (TREE_TYPE (type), 0, 0);
1418 /* Print the value of integer constant C, in octal,
1419 handling double precision. */
1422 print_int_cst_octal (c)
1425 unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
1426 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
1427 int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
1428 int width = TYPE_PRECISION (TREE_TYPE (c));
1430 /* GDB wants constants with no extra leading "1" bits, so
1431 we need to remove any sign-extension that might be
1433 if (width == HOST_BITS_PER_WIDE_INT * 2)
1435 else if (width > HOST_BITS_PER_WIDE_INT)
1436 high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
1437 else if (width == HOST_BITS_PER_WIDE_INT)
1440 high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
1442 fprintf (asmfile, "0");
1446 print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
1447 print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
1451 unsigned HOST_WIDE_INT beg = high >> excess;
1452 unsigned HOST_WIDE_INT middle
1453 = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
1454 | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
1455 unsigned HOST_WIDE_INT end
1456 = low & (((unsigned HOST_WIDE_INT) 1
1457 << (HOST_BITS_PER_WIDE_INT / 3 * 3))
1460 fprintf (asmfile, "%o%01o", beg, middle);
1461 print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
1466 print_octal (value, digits)
1467 unsigned HOST_WIDE_INT value;
1472 for (i = digits - 1; i >= 0; i--)
1473 fprintf (asmfile, "%01o", ((value >> (3 * i)) & 7));
1476 /* Output the name of type TYPE, with no punctuation.
1477 Such names can be set up either by typedef declarations
1478 or by struct, enum and union tags. */
1481 dbxout_type_name (type)
1485 if (TYPE_NAME (type) == 0)
1487 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
1489 t = TYPE_NAME (type);
1491 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1493 t = DECL_NAME (TYPE_NAME (type));
1498 fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
1499 CHARS (IDENTIFIER_LENGTH (t));
1502 /* Output a .stabs for the symbol defined by DECL,
1503 which must be a ..._DECL node in the normal namespace.
1504 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1505 LOCAL is nonzero if the scope is less than the entire file. */
1508 dbxout_symbol (decl, local)
1512 tree type = TREE_TYPE (decl);
1513 tree context = NULL_TREE;
1515 /* Cast avoids warning in old compilers. */
1516 current_sym_code = (STAB_CODE_TYPE) 0;
1517 current_sym_value = 0;
1518 current_sym_addr = 0;
1520 /* Ignore nameless syms, but don't ignore type tags. */
1522 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
1523 || DECL_IGNORED_P (decl))
1526 dbxout_prepare_symbol (decl);
1528 /* The output will always start with the symbol name,
1529 so always count that in the length-output-so-far. */
1531 if (DECL_NAME (decl) != 0)
1532 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
1534 switch (TREE_CODE (decl))
1537 /* Enum values are defined by defining the enum type. */
1541 if (DECL_RTL (decl) == 0)
1543 if (DECL_EXTERNAL (decl))
1545 /* Don't mention a nested function under its parent. */
1546 context = decl_function_context (decl);
1547 if (context == current_function_decl)
1549 if (GET_CODE (DECL_RTL (decl)) != MEM
1550 || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
1554 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
1555 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1556 TREE_PUBLIC (decl) ? 'F' : 'f');
1558 current_sym_code = N_FUN;
1559 current_sym_addr = XEXP (DECL_RTL (decl), 0);
1561 if (TREE_TYPE (type))
1562 dbxout_type (TREE_TYPE (type), 0, 0);
1564 dbxout_type (void_type_node, 0, 0);
1566 /* For a nested function, when that function is compiled,
1567 mention the containing function name
1568 as well as (since dbx wants it) our own assembler-name. */
1570 fprintf (asmfile, ",%s,%s",
1571 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1572 IDENTIFIER_POINTER (DECL_NAME (context)));
1574 dbxout_finish_symbol (decl);
1579 /* This seems all wrong. Outputting most kinds of types gives no name
1580 at all. A true definition gives no name; a cross-ref for a
1581 structure can give the tag name, but not a type name.
1582 It seems that no typedef name is defined by outputting a type. */
1584 /* If this typedef name was defined by outputting the type,
1585 don't duplicate it. */
1586 if (typevec[TYPE_SYMTAB_ADDRESS (type)] == TYPE_DEFINED
1587 && TYPE_NAME (TREE_TYPE (decl)) == decl)
1590 /* Don't output the same typedef twice.
1591 And don't output what language-specific stuff doesn't want output. */
1592 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
1601 if (DECL_NAME (decl))
1603 /* Nonzero means we must output a tag as well as a typedef. */
1606 /* Handle the case of a C++ structure or union
1607 where the TYPE_NAME is a TYPE_DECL
1608 which gives both a typedef name and a tag. */
1609 /* dbx requires the tag first and the typedef second. */
1610 if ((TREE_CODE (type) == RECORD_TYPE
1611 || TREE_CODE (type) == UNION_TYPE
1612 || TREE_CODE (type) == QUAL_UNION_TYPE)
1613 && TYPE_NAME (type) == decl
1614 && !(use_gnu_debug_info_extensions && have_used_extensions)
1615 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
1616 /* Distinguish the implicit typedefs of C++
1617 from explicit ones that might be found in C. */
1618 && (!strcmp (lang_identify (), "cplusplus")
1619 /* The following line maybe unnecessary;
1620 in 2.6, try removing it. */
1621 || DECL_SOURCE_LINE (decl) == 0))
1623 tree name = TYPE_NAME (type);
1624 if (TREE_CODE (name) == TYPE_DECL)
1625 name = DECL_NAME (name);
1627 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1628 current_sym_value = 0;
1629 current_sym_addr = 0;
1630 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1632 fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP,
1633 IDENTIFIER_POINTER (name));
1634 dbxout_type (type, 1, 0);
1635 dbxout_finish_symbol (NULL_TREE);
1638 /* Output typedef name. */
1639 fprintf (asmfile, "%s \"%s:", ASM_STABS_OP,
1640 IDENTIFIER_POINTER (DECL_NAME (decl)));
1642 /* Short cut way to output a tag also. */
1643 if ((TREE_CODE (type) == RECORD_TYPE
1644 || TREE_CODE (type) == UNION_TYPE
1645 || TREE_CODE (type) == QUAL_UNION_TYPE)
1646 && TYPE_NAME (type) == decl)
1648 if (use_gnu_debug_info_extensions && have_used_extensions)
1650 putc ('T', asmfile);
1651 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
1653 #if 0 /* Now we generate the tag for this case up above. */
1659 putc ('t', asmfile);
1660 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1662 dbxout_type (type, 1, 0);
1663 dbxout_finish_symbol (decl);
1667 /* Don't output a tag if this is an incomplete type (TYPE_SIZE is
1668 zero). This prevents the sun4 Sun OS 4.x dbx from crashing. */
1670 if (tag_needed && TYPE_NAME (type) != 0 && TYPE_SIZE (type) != 0
1671 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
1673 /* For a TYPE_DECL with no name, but the type has a name,
1675 This is what represents `struct foo' with no typedef. */
1676 /* In C++, the name of a type is the corresponding typedef.
1677 In C, it is an IDENTIFIER_NODE. */
1678 tree name = TYPE_NAME (type);
1679 if (TREE_CODE (name) == TYPE_DECL)
1680 name = DECL_NAME (name);
1682 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1683 current_sym_value = 0;
1684 current_sym_addr = 0;
1685 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1687 fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP,
1688 IDENTIFIER_POINTER (name));
1689 dbxout_type (type, 1, 0);
1690 dbxout_finish_symbol (NULL_TREE);
1694 /* If an enum type has no name, it cannot be referred to,
1695 but we must output it anyway, since the enumeration constants
1696 can be referred to. */
1697 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
1699 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1700 current_sym_value = 0;
1701 current_sym_addr = 0;
1702 current_sym_nchars = 2;
1704 /* Some debuggers fail when given NULL names, so give this a
1705 harmless name of ` '. */
1706 fprintf (asmfile, "%s \" :T", ASM_STABS_OP);
1707 dbxout_type (type, 1, 0);
1708 dbxout_finish_symbol (NULL_TREE);
1711 /* Prevent duplicate output of a typedef. */
1712 TREE_ASM_WRITTEN (decl) = 1;
1717 /* Parm decls go in their own separate chains
1718 and are output by dbxout_reg_parms and dbxout_parms. */
1722 /* Named return value, treat like a VAR_DECL. */
1724 if (DECL_RTL (decl) == 0)
1726 /* Don't mention a variable that is external.
1727 Let the file that defines it describe it. */
1728 if (DECL_EXTERNAL (decl))
1731 /* If the variable is really a constant
1732 and not written in memory, inform the debugger. */
1733 if (TREE_STATIC (decl) && TREE_READONLY (decl)
1734 && DECL_INITIAL (decl) != 0
1735 && ! TREE_ASM_WRITTEN (decl)
1736 && (DECL_FIELD_CONTEXT (decl) == NULL_TREE
1737 || TREE_CODE (DECL_FIELD_CONTEXT (decl)) == BLOCK))
1739 if (TREE_PUBLIC (decl) == 0)
1741 /* The sun4 assembler does not grok this. */
1742 char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1743 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
1744 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
1746 HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl));
1747 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1748 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile, name, ival);
1750 fprintf (asmfile, "%s \"%s:c=i%d\",0x%x,0,0,0\n",
1751 ASM_STABS_OP, name, ival, N_LSYM);
1755 else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
1757 /* don't know how to do this yet. */
1761 /* else it is something we handle like a normal variable. */
1764 DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, NULL_RTX);
1765 #ifdef LEAF_REG_REMAP
1767 leaf_renumber_regs_insn (DECL_RTL (decl));
1770 dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
1774 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1775 Add SUFFIX to its name, if SUFFIX is not 0.
1776 Describe the variable as residing in HOME
1777 (usually HOME is DECL_RTL (DECL), but not always). */
1780 dbxout_symbol_location (decl, type, suffix, home)
1788 /* Don't mention a variable at all
1789 if it was completely optimized into nothingness.
1791 If the decl was from an inline function, then it's rtl
1792 is not identically the rtl that was used in this
1793 particular compilation. */
1794 if (GET_CODE (home) == REG)
1796 regno = REGNO (home);
1797 if (regno >= FIRST_PSEUDO_REGISTER)
1800 else if (GET_CODE (home) == SUBREG)
1804 while (GET_CODE (value) == SUBREG)
1806 offset += SUBREG_WORD (value);
1807 value = SUBREG_REG (value);
1809 if (GET_CODE (value) == REG)
1811 regno = REGNO (value);
1812 if (regno >= FIRST_PSEUDO_REGISTER)
1816 alter_subreg (home);
1819 /* The kind-of-variable letter depends on where
1820 the variable is and on the scope of its name:
1821 G and N_GSYM for static storage and global scope,
1822 S for static storage and file scope,
1823 V for static storage and local scope,
1824 for those two, use N_LCSYM if data is in bss segment,
1825 N_STSYM if in data segment, N_FUN otherwise.
1826 (We used N_FUN originally, then changed to N_STSYM
1827 to please GDB. However, it seems that confused ld.
1828 Now GDB has been fixed to like N_FUN, says Kingdon.)
1829 no letter at all, and N_LSYM, for auto variable,
1830 r and N_RSYM for register variable. */
1832 if (GET_CODE (home) == MEM
1833 && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
1835 if (TREE_PUBLIC (decl))
1838 current_sym_code = N_GSYM;
1842 current_sym_addr = XEXP (home, 0);
1844 letter = decl_function_context (decl) ? 'V' : 'S';
1846 /* This should be the same condition as in assemble_variable, but
1847 we don't have access to dont_output_data here. So, instead,
1848 we rely on the fact that error_mark_node initializers always
1849 end up in bss for C++ and never end up in bss for C. */
1850 if (DECL_INITIAL (decl) == 0
1851 || (!strcmp (lang_identify (), "cplusplus")
1852 && DECL_INITIAL (decl) == error_mark_node))
1853 current_sym_code = N_LCSYM;
1854 else if (DECL_IN_TEXT_SECTION (decl))
1855 /* This is not quite right, but it's the closest
1856 of all the codes that Unix defines. */
1857 current_sym_code = DBX_STATIC_CONST_VAR_CODE;
1860 /* Ultrix `as' seems to need this. */
1861 #ifdef DBX_STATIC_STAB_DATA_SECTION
1864 current_sym_code = N_STSYM;
1868 else if (regno >= 0)
1871 current_sym_code = N_RSYM;
1872 current_sym_value = DBX_REGISTER_NUMBER (regno);
1874 else if (GET_CODE (home) == MEM
1875 && (GET_CODE (XEXP (home, 0)) == MEM
1876 || (GET_CODE (XEXP (home, 0)) == REG
1877 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM)))
1878 /* If the value is indirect by memory or by a register
1879 that isn't the frame pointer
1880 then it means the object is variable-sized and address through
1881 that register or stack slot. DBX has no way to represent this
1882 so all we can do is output the variable as a pointer.
1883 If it's not a parameter, ignore it.
1884 (VAR_DECLs like this can be made by integrate.c.) */
1886 if (GET_CODE (XEXP (home, 0)) == REG)
1889 current_sym_code = N_RSYM;
1890 current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
1894 current_sym_code = N_LSYM;
1895 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
1896 We want the value of that CONST_INT. */
1898 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
1901 /* Effectively do build_pointer_type, but don't cache this type,
1902 since it might be temporary whereas the type it points to
1903 might have been saved for inlining. */
1904 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
1905 type = make_node (POINTER_TYPE);
1906 TREE_TYPE (type) = TREE_TYPE (decl);
1908 else if (GET_CODE (home) == MEM
1909 && GET_CODE (XEXP (home, 0)) == REG)
1911 current_sym_code = N_LSYM;
1912 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
1914 else if (GET_CODE (home) == MEM
1915 && GET_CODE (XEXP (home, 0)) == PLUS
1916 && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
1918 current_sym_code = N_LSYM;
1919 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
1920 We want the value of that CONST_INT. */
1921 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
1923 else if (GET_CODE (home) == MEM
1924 && GET_CODE (XEXP (home, 0)) == CONST)
1926 /* Handle an obscure case which can arise when optimizing and
1927 when there are few available registers. (This is *always*
1928 the case for i386/i486 targets). The RTL looks like
1929 (MEM (CONST ...)) even though this variable is a local `auto'
1930 or a local `register' variable. In effect, what has happened
1931 is that the reload pass has seen that all assignments and
1932 references for one such a local variable can be replaced by
1933 equivalent assignments and references to some static storage
1934 variable, thereby avoiding the need for a register. In such
1935 cases we're forced to lie to debuggers and tell them that
1936 this variable was itself `static'. */
1937 current_sym_code = N_LCSYM;
1939 current_sym_addr = XEXP (XEXP (home, 0), 0);
1941 else if (GET_CODE (home) == CONCAT)
1943 tree subtype = TREE_TYPE (type);
1945 /* If the variable's storage is in two parts,
1946 output each as a separate stab with a modified name. */
1947 if (WORDS_BIG_ENDIAN)
1948 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
1950 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
1952 /* Cast avoids warning in old compilers. */
1953 current_sym_code = (STAB_CODE_TYPE) 0;
1954 current_sym_value = 0;
1955 current_sym_addr = 0;
1956 dbxout_prepare_symbol (decl);
1958 if (WORDS_BIG_ENDIAN)
1959 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
1961 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
1965 /* Address might be a MEM, when DECL is a variable-sized object.
1966 Or it might be const0_rtx, meaning previous passes
1967 want us to ignore this variable. */
1970 /* Ok, start a symtab entry and output the variable name. */
1973 #ifdef DBX_STATIC_BLOCK_START
1974 DBX_STATIC_BLOCK_START (asmfile, current_sym_code);
1977 dbxout_symbol_name (decl, suffix, letter);
1978 dbxout_type (type, 0, 0);
1979 dbxout_finish_symbol (decl);
1981 #ifdef DBX_STATIC_BLOCK_END
1982 DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
1986 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
1987 Then output LETTER to indicate the kind of location the symbol has. */
1990 dbxout_symbol_name (decl, suffix, letter)
1995 /* One slight hitch: if this is a VAR_DECL which is a static
1996 class member, we must put out the mangled name instead of the
2000 /* Note also that static member (variable) names DO NOT begin
2001 with underscores in .stabs directives. */
2002 if (DECL_LANG_SPECIFIC (decl))
2003 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2005 name = IDENTIFIER_POINTER (DECL_NAME (decl));
2008 fprintf (asmfile, "%s \"%s%s:", ASM_STABS_OP, name,
2009 (suffix ? suffix : ""));
2011 if (letter) putc (letter, asmfile);
2015 dbxout_prepare_symbol (decl)
2019 char *filename = DECL_SOURCE_FILE (decl);
2021 dbxout_source_file (asmfile, filename);
2026 dbxout_finish_symbol (sym)
2029 #ifdef DBX_FINISH_SYMBOL
2030 DBX_FINISH_SYMBOL (sym);
2033 if (use_gnu_debug_info_extensions && sym != 0)
2034 line = DECL_SOURCE_LINE (sym);
2036 fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line);
2037 if (current_sym_addr)
2038 output_addr_const (asmfile, current_sym_addr);
2040 fprintf (asmfile, "%d", current_sym_value);
2041 putc ('\n', asmfile);
2045 /* Output definitions of all the decls in a chain. */
2053 dbxout_symbol (syms, 1);
2054 syms = TREE_CHAIN (syms);
2058 /* The following two functions output definitions of function parameters.
2059 Each parameter gets a definition locating it in the parameter list.
2060 Each parameter that is a register variable gets a second definition
2061 locating it in the register.
2063 Printing or argument lists in gdb uses the definitions that
2064 locate in the parameter list. But reference to the variable in
2065 expressions uses preferentially the definition as a register. */
2067 /* Output definitions, referring to storage in the parmlist,
2068 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2071 dbxout_parms (parms)
2074 for (; parms; parms = TREE_CHAIN (parms))
2075 if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node)
2077 dbxout_prepare_symbol (parms);
2079 /* Perform any necessary register eliminations on the parameter's rtl,
2080 so that the debugging output will be accurate. */
2081 DECL_INCOMING_RTL (parms)
2082 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
2083 DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX);
2084 #ifdef LEAF_REG_REMAP
2087 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
2088 leaf_renumber_regs_insn (DECL_RTL (parms));
2092 if (PARM_PASSED_IN_MEMORY (parms))
2094 rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
2096 /* ??? Here we assume that the parm address is indexed
2097 off the frame pointer or arg pointer.
2098 If that is not true, we produce meaningless results,
2099 but do not crash. */
2100 if (GET_CODE (addr) == PLUS
2101 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
2102 current_sym_value = INTVAL (XEXP (addr, 1));
2104 current_sym_value = 0;
2106 current_sym_code = N_PSYM;
2107 current_sym_addr = 0;
2110 if (DECL_NAME (parms))
2112 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2114 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2115 IDENTIFIER_POINTER (DECL_NAME (parms)),
2116 DBX_MEMPARM_STABS_LETTER);
2120 current_sym_nchars = 8;
2121 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2122 DBX_MEMPARM_STABS_LETTER);
2125 if (GET_CODE (DECL_RTL (parms)) == REG
2126 && REGNO (DECL_RTL (parms)) >= 0
2127 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2128 dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
2131 int original_value = current_sym_value;
2133 /* This is the case where the parm is passed as an int or double
2134 and it is converted to a char, short or float and stored back
2135 in the parmlist. In this case, describe the parm
2136 with the variable's declared type, and adjust the address
2137 if the least significant bytes (which we are using) are not
2139 if (BYTES_BIG_ENDIAN
2140 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
2141 current_sym_value += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
2142 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
2144 if (GET_CODE (DECL_RTL (parms)) == MEM
2145 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
2146 && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
2147 && INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == current_sym_value)
2148 dbxout_type (TREE_TYPE (parms), 0, 0);
2151 current_sym_value = original_value;
2152 dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
2155 current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
2156 dbxout_finish_symbol (parms);
2158 else if (GET_CODE (DECL_RTL (parms)) == REG)
2161 char regparm_letter;
2163 /* Parm passed in registers and lives in registers or nowhere. */
2165 current_sym_code = DBX_REGPARM_STABS_CODE;
2166 regparm_letter = DBX_REGPARM_STABS_LETTER;
2167 current_sym_addr = 0;
2169 /* If parm lives in a register, use that register;
2170 pretend the parm was passed there. It would be more consistent
2171 to describe the register where the parm was passed,
2172 but in practice that register usually holds something else.
2174 If we use DECL_RTL, then we must use the declared type of
2175 the variable, not the type that it arrived in. */
2176 if (REGNO (DECL_RTL (parms)) >= 0
2177 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2179 best_rtl = DECL_RTL (parms);
2180 parm_type = TREE_TYPE (parms);
2182 /* If the parm lives nowhere, use the register where it was
2183 passed. It is also better to use the declared type here. */
2186 best_rtl = DECL_INCOMING_RTL (parms);
2187 parm_type = TREE_TYPE (parms);
2189 current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
2192 if (DECL_NAME (parms))
2194 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2195 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2196 IDENTIFIER_POINTER (DECL_NAME (parms)),
2201 current_sym_nchars = 8;
2202 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2206 dbxout_type (parm_type, 0, 0);
2207 dbxout_finish_symbol (parms);
2209 else if (GET_CODE (DECL_RTL (parms)) == MEM
2210 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2211 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
2212 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
2213 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2214 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
2218 /* Parm was passed via invisible reference.
2219 That is, its address was passed in a register.
2220 Output it as if it lived in that register.
2221 The debugger will know from the type
2222 that it was actually passed by invisible reference. */
2224 char regparm_letter;
2225 /* Parm passed in registers and lives in registers or nowhere. */
2227 current_sym_code = DBX_REGPARM_STABS_CODE;
2228 regparm_letter = DBX_REGPARM_STABS_LETTER;
2230 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2231 If it is an unallocated pseudo-reg, then use the register where
2232 it was passed instead. */
2233 if (REGNO (XEXP (DECL_RTL (parms), 0)) >= 0
2234 && REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
2235 current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2237 current_sym_value = REGNO (DECL_INCOMING_RTL (parms));
2239 current_sym_addr = 0;
2242 if (DECL_NAME (parms))
2244 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2246 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2247 IDENTIFIER_POINTER (DECL_NAME (parms)),
2248 DBX_REGPARM_STABS_LETTER);
2252 current_sym_nchars = 8;
2253 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2254 DBX_REGPARM_STABS_LETTER);
2257 dbxout_type (TREE_TYPE (parms), 0, 0);
2258 dbxout_finish_symbol (parms);
2260 else if (GET_CODE (DECL_RTL (parms)) == MEM
2261 && XEXP (DECL_RTL (parms), 0) != const0_rtx
2262 /* ??? A constant address for a parm can happen
2263 when the reg it lives in is equiv to a constant in memory.
2264 Should make this not happen, after 2.4. */
2265 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
2267 /* Parm was passed in registers but lives on the stack. */
2269 current_sym_code = N_PSYM;
2270 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2271 in which case we want the value of that CONST_INT,
2272 or (MEM (REG ...)) or (MEM (MEM ...)),
2273 in which case we use a value of zero. */
2274 if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2275 || GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
2276 current_sym_value = 0;
2278 current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
2279 current_sym_addr = 0;
2282 if (DECL_NAME (parms))
2284 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2286 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2287 IDENTIFIER_POINTER (DECL_NAME (parms)),
2288 DBX_MEMPARM_STABS_LETTER);
2292 current_sym_nchars = 8;
2293 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2294 DBX_MEMPARM_STABS_LETTER);
2298 = DEBUGGER_ARG_OFFSET (current_sym_value,
2299 XEXP (DECL_RTL (parms), 0));
2300 dbxout_type (TREE_TYPE (parms), 0, 0);
2301 dbxout_finish_symbol (parms);
2306 /* Output definitions for the places where parms live during the function,
2307 when different from where they were passed, when the parms were passed
2310 It is not useful to do this for parms passed in registers
2311 that live during the function in different registers, because it is
2312 impossible to look in the passed register for the passed value,
2313 so we use the within-the-function register to begin with.
2315 PARMS is a chain of PARM_DECL nodes. */
2318 dbxout_reg_parms (parms)
2321 for (; parms; parms = TREE_CHAIN (parms))
2322 if (DECL_NAME (parms))
2324 dbxout_prepare_symbol (parms);
2326 /* Report parms that live in registers during the function
2327 but were passed in memory. */
2328 if (GET_CODE (DECL_RTL (parms)) == REG
2329 && REGNO (DECL_RTL (parms)) >= 0
2330 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER
2331 && PARM_PASSED_IN_MEMORY (parms))
2332 dbxout_symbol_location (parms, TREE_TYPE (parms),
2333 0, DECL_RTL (parms));
2334 else if (GET_CODE (DECL_RTL (parms)) == CONCAT
2335 && PARM_PASSED_IN_MEMORY (parms))
2336 dbxout_symbol_location (parms, TREE_TYPE (parms),
2337 0, DECL_RTL (parms));
2338 /* Report parms that live in memory but not where they were passed. */
2339 else if (GET_CODE (DECL_RTL (parms)) == MEM
2340 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
2341 && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
2342 && PARM_PASSED_IN_MEMORY (parms)
2343 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
2345 #if 0 /* ??? It is not clear yet what should replace this. */
2346 int offset = DECL_OFFSET (parms) / BITS_PER_UNIT;
2347 /* A parm declared char is really passed as an int,
2348 so it occupies the least significant bytes.
2349 On a big-endian machine those are not the low-numbered ones. */
2350 if (BYTES_BIG_ENDIAN
2352 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
2353 offset += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
2354 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
2355 if (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) != offset) {...}
2357 dbxout_symbol_location (parms, TREE_TYPE (parms),
2358 0, DECL_RTL (parms));
2361 else if (GET_CODE (DECL_RTL (parms)) == MEM
2362 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG)
2364 /* Parm was passed via invisible reference.
2365 That is, its address was passed in a register.
2366 Output it as if it lived in that register.
2367 The debugger will know from the type
2368 that it was actually passed by invisible reference. */
2370 current_sym_code = N_RSYM;
2372 /* DECL_RTL looks like (MEM (REG...). Get the register number. */
2373 current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2374 current_sym_addr = 0;
2377 if (DECL_NAME (parms))
2379 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2381 fprintf (asmfile, "%s \"%s:r", ASM_STABS_OP,
2382 IDENTIFIER_POINTER (DECL_NAME (parms)));
2386 current_sym_nchars = 8;
2387 fprintf (asmfile, "%s \"(anon):r", ASM_STABS_OP);
2390 dbxout_type (TREE_TYPE (parms), 0, 0);
2391 dbxout_finish_symbol (parms);
2397 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2398 output definitions of those names, in raw form */
2406 putc (',', asmfile);
2407 dbxout_type (TREE_VALUE (args), 0, 0);
2409 args = TREE_CHAIN (args);
2413 /* Given a chain of ..._TYPE nodes,
2414 find those which have typedef names and output those names.
2415 This is to ensure those types get output. */
2418 dbxout_types (types)
2419 register tree types;
2423 if (TYPE_NAME (types)
2424 && TREE_CODE (TYPE_NAME (types)) == TYPE_DECL
2425 && ! TREE_ASM_WRITTEN (TYPE_NAME (types)))
2426 dbxout_symbol (TYPE_NAME (types), 1);
2427 types = TREE_CHAIN (types);
2431 /* Output everything about a symbol block (a BLOCK node
2432 that represents a scope level),
2433 including recursive output of contained blocks.
2435 BLOCK is the BLOCK node.
2436 DEPTH is its depth within containing symbol blocks.
2437 ARGS is usually zero; but for the outermost block of the
2438 body of a function, it is a chain of PARM_DECLs for the function parameters.
2439 We output definitions of all the register parms
2440 as if they were local variables of that block.
2442 If -g1 was used, we count blocks just the same, but output nothing
2443 except for the outermost block.
2445 Actually, BLOCK may be several blocks chained together.
2446 We handle them all in sequence. */
2449 dbxout_block (block, depth, args)
2450 register tree block;
2458 /* Ignore blocks never expanded or otherwise marked as real. */
2459 if (TREE_USED (block))
2461 #ifndef DBX_LBRAC_FIRST
2462 /* In dbx format, the syms of a block come before the N_LBRAC. */
2463 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2464 dbxout_syms (BLOCK_VARS (block));
2466 dbxout_reg_parms (args);
2469 /* Now output an N_LBRAC symbol to represent the beginning of
2470 the block. Use the block's tree-walk order to generate
2471 the assembler symbols LBBn and LBEn
2472 that final will define around the code in this block. */
2473 if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE)
2476 blocknum = next_block_number++;
2477 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
2479 if (BLOCK_HANDLER_BLOCK (block))
2481 /* A catch block. Must precede N_LBRAC. */
2482 tree decl = BLOCK_VARS (block);
2485 #ifdef DBX_OUTPUT_CATCH
2486 DBX_OUTPUT_CATCH (asmfile, decl, buf);
2488 fprintf (asmfile, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP,
2489 IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
2490 assemble_name (asmfile, buf);
2491 fprintf (asmfile, "\n");
2493 decl = TREE_CHAIN (decl);
2497 #ifdef DBX_OUTPUT_LBRAC
2498 DBX_OUTPUT_LBRAC (asmfile, buf);
2500 fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_LBRAC);
2501 assemble_name (asmfile, buf);
2502 #if DBX_BLOCKS_FUNCTION_RELATIVE
2503 fputc ('-', asmfile);
2504 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
2506 fprintf (asmfile, "\n");
2510 /* Count blocks the same way regardless of debug_info_level. */
2511 next_block_number++;
2513 #ifdef DBX_LBRAC_FIRST
2514 /* On some weird machines, the syms of a block
2515 come after the N_LBRAC. */
2516 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2517 dbxout_syms (BLOCK_VARS (block));
2519 dbxout_reg_parms (args);
2522 /* Output the subblocks. */
2523 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
2525 /* Refer to the marker for the end of the block. */
2526 if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE)
2529 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
2530 #ifdef DBX_OUTPUT_RBRAC
2531 DBX_OUTPUT_RBRAC (asmfile, buf);
2533 fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_RBRAC);
2534 assemble_name (asmfile, buf);
2535 #if DBX_BLOCKS_FUNCTION_RELATIVE
2536 fputc ('-', asmfile);
2537 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
2539 fprintf (asmfile, "\n");
2543 block = BLOCK_CHAIN (block);
2547 /* Output the information about a function and its arguments and result.
2548 Usually this follows the function's code,
2549 but on some systems, it comes before. */
2552 dbxout_really_begin_function (decl)
2555 dbxout_symbol (decl, 0);
2556 dbxout_parms (DECL_ARGUMENTS (decl));
2557 if (DECL_NAME (DECL_RESULT (decl)) != 0)
2558 dbxout_symbol (DECL_RESULT (decl), 1);
2561 /* Called at beginning of output of function definition. */
2564 dbxout_begin_function (decl)
2567 #ifdef DBX_FUNCTION_FIRST
2568 dbxout_really_begin_function (decl);
2572 /* Output dbx data for a function definition.
2573 This includes a definition of the function name itself (a symbol),
2574 definitions of the parameters (locating them in the parameter list)
2575 and then output the block that makes up the function's body
2576 (including all the auto variables of the function). */
2579 dbxout_function (decl)
2582 #ifndef DBX_FUNCTION_FIRST
2583 dbxout_really_begin_function (decl);
2585 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
2586 #ifdef DBX_OUTPUT_FUNCTION_END
2587 DBX_OUTPUT_FUNCTION_END (asmfile, decl);
2590 #endif /* DBX_DEBUGGING_INFO */