1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987, 88, 92, 93, 94, 1995 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, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
22 /* Output dbx-format symbol table data.
23 This consists of many symbol table entries, each of them
24 a .stabs assembler pseudo-op with four operands:
25 a "name" which is really a description of one symbol and its type,
26 a "code", which is a symbol defined in stab.h whose name starts with N_,
27 an unused operand always 0,
28 and a "value" which is an address or an offset.
29 The name is enclosed in doublequote characters.
31 Each function, variable, typedef, and structure tag
32 has a symbol table entry to define it.
33 The beginning and end of each level of name scoping within
34 a function are also marked by special symbol table entries.
36 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
37 and a data type number. The data type number may be followed by
38 "=" and a type definition; normally this will happen the first time
39 the type number is mentioned. The type definition may refer to
40 other types by number, and those type numbers may be followed
41 by "=" and nested definitions.
43 This can make the "name" quite long.
44 When a name is more than 80 characters, we split the .stabs pseudo-op
45 into two .stabs pseudo-ops, both sharing the same "code" and "value".
46 The first one is marked as continued with a double-backslash at the
49 The kind-of-symbol letter distinguished function names from global
50 variables from file-scope variables from parameters from auto
51 variables in memory from typedef names from register variables.
54 The "code" is mostly redundant with the kind-of-symbol letter
55 that goes in the "name", but not entirely: for symbols located
56 in static storage, the "code" says which segment the address is in,
57 which controls how it is relocated.
59 The "value" for a symbol in static storage
60 is the core address of the symbol (actually, the assembler
61 label for the symbol). For a symbol located in a stack slot
62 it is the stack offset; for one in a register, the register number.
63 For a typedef symbol, it is zero.
65 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
66 output while in the text section.
68 For more on data type definitions, see `dbxout_type'. */
70 /* Include these first, because they may define MIN and MAX. */
79 #include "insn-config.h"
82 #include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions. */
88 #ifdef XCOFF_DEBUGGING_INFO
93 #define ASM_STABS_OP ".stabs"
97 #define ASM_STABN_OP ".stabn"
100 #ifndef DBX_TYPE_DECL_STABS_CODE
101 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
104 #ifndef DBX_STATIC_CONST_VAR_CODE
105 #define DBX_STATIC_CONST_VAR_CODE N_FUN
108 #ifndef DBX_REGPARM_STABS_CODE
109 #define DBX_REGPARM_STABS_CODE N_RSYM
112 #ifndef DBX_REGPARM_STABS_LETTER
113 #define DBX_REGPARM_STABS_LETTER 'P'
116 /* This is used for parameters passed by invisible reference in a register. */
117 #ifndef GDB_INV_REF_REGPARM_STABS_LETTER
118 #define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
121 #ifndef DBX_MEMPARM_STABS_LETTER
122 #define DBX_MEMPARM_STABS_LETTER 'p'
125 #ifndef FILE_NAME_JOINER
126 #define FILE_NAME_JOINER "/"
129 /* Nonzero means if the type has methods, only output debugging
130 information if methods are actually written to the asm file. */
132 static int flag_minimal_debug = 1;
134 /* Nonzero if we have actually used any of the GDB extensions
135 to the debugging format. The idea is that we use them for the
136 first time only if there's a strong reason, but once we have done that,
137 we use them whenever convenient. */
139 static int have_used_extensions = 0;
141 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
142 for the N_SO filename stabs label. */
144 static int source_label_number = 1;
148 /* Typical USG systems don't have stab.h, and they also have
149 no use for DBX-format debugging info. */
151 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
153 #ifdef DEBUG_SYMS_TEXT
154 #define FORCE_TEXT text_section ();
159 #if defined (USG) || defined (NO_STAB_H)
160 #include "gstab.h" /* If doing DBX on sysV, use our own stab.h. */
162 #include <stab.h> /* On BSD, use the system's stab.h. */
164 /* This is a GNU extension we need to reference in this file. */
171 #define STAB_CODE_TYPE enum __stab_debug_code
173 #define STAB_CODE_TYPE int
176 /* 1 if PARM is passed to this function in memory. */
178 #define PARM_PASSED_IN_MEMORY(PARM) \
179 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
181 /* A C expression for the integer offset value of an automatic variable
182 (N_LSYM) having address X (an RTX). */
183 #ifndef DEBUGGER_AUTO_OFFSET
184 #define DEBUGGER_AUTO_OFFSET(X) \
185 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
188 /* A C expression for the integer offset value of an argument (N_PSYM)
189 having address X (an RTX). The nominal offset is OFFSET. */
190 #ifndef DEBUGGER_ARG_OFFSET
191 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
194 /* Stream for writing to assembler file. */
196 static FILE *asmfile;
198 /* Last source file name mentioned in a NOTE insn. */
200 static char *lastfile;
202 /* Current working directory. */
206 enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
208 /* Vector recording the status of describing C data types.
209 When we first notice a data type (a tree node),
210 we assign it a number using next_type_number.
211 That is its index in this vector.
212 The vector element says whether we have yet output
213 the definition of the type. TYPE_XREF says we have
214 output it as a cross-reference only. */
216 enum typestatus *typevec;
218 /* Number of elements of space allocated in `typevec'. */
220 static int typevec_len;
222 /* In dbx output, each type gets a unique number.
223 This is the number for the next type output.
224 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
226 static int next_type_number;
228 /* In dbx output, we must assign symbol-blocks id numbers
229 in the order in which their beginnings are encountered.
230 We output debugging info that refers to the beginning and
231 end of the ranges of code in each block
232 with assembler labels LBBn and LBEn, where n is the block number.
233 The labels are generated in final, which assigns numbers to the
234 blocks in the same way. */
236 static int next_block_number;
238 /* These variables are for dbxout_symbol to communicate to
239 dbxout_finish_symbol.
240 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
241 current_sym_value and current_sym_addr are two ways to address the
242 value to store in the symtab entry.
243 current_sym_addr if nonzero represents the value as an rtx.
244 If that is zero, current_sym_value is used. This is used
245 when the value is an offset (such as for auto variables,
246 register variables and parms). */
248 static STAB_CODE_TYPE current_sym_code;
249 static int current_sym_value;
250 static rtx current_sym_addr;
252 /* Number of chars of symbol-description generated so far for the
253 current symbol. Used by CHARS and CONTIN. */
255 static int current_sym_nchars;
257 /* Report having output N chars of the current symbol-description. */
259 #define CHARS(N) (current_sym_nchars += (N))
261 /* Break the current symbol-description, generating a continuation,
262 if it has become long. */
264 #ifndef DBX_CONTIN_LENGTH
265 #define DBX_CONTIN_LENGTH 80
268 #if DBX_CONTIN_LENGTH > 0
270 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
275 void dbxout_types ();
277 void dbxout_symbol ();
278 static void dbxout_type_name ();
279 static void dbxout_type ();
280 static void dbxout_typedefs ();
281 static void dbxout_symbol_name ();
282 static void dbxout_symbol_location ();
283 static void dbxout_prepare_symbol ();
284 static void dbxout_finish_symbol ();
285 static void dbxout_continue ();
286 static void print_int_cst_octal ();
287 static void print_octal ();
289 #if 0 /* Not clear we will actually need this. */
291 /* Return the absolutized filename for the given relative
292 filename. Note that if that filename is already absolute, it may
293 still be returned in a modified form because this routine also
294 eliminates redundant slashes and single dots and eliminates double
295 dots to get a shortest possible filename from the given input
296 filename. The absolutization of relative filenames is made by
297 assuming that the given filename is to be taken as relative to
298 the first argument (cwd) or to the current directory if cwd is
302 abspath (rel_filename)
305 /* Setup the current working directory as needed. */
307 = (char *) alloca (strlen (cwd) + strlen (rel_filename) + 1);
308 char *endp = abs_buffer;
312 /* Copy the filename (possibly preceded by the current working
313 directory name) into the absolutization buffer. */
318 if (rel_filename[0] != '/')
321 while (*endp++ = *src_p++)
323 *(endp-1) = '/'; /* overwrite null */
325 src_p = rel_filename;
326 while (*endp++ = *src_p++)
331 /* Now make a copy of abs_buffer into abs_buffer, shortening the
332 filename (by taking out slashes and dots) as we go. */
334 outp = inp = abs_buffer;
335 *outp++ = *inp++; /* copy first slash */
340 else if (inp[0] == '/' && outp[-1] == '/')
345 else if (inp[0] == '.' && outp[-1] == '/')
349 else if (inp[1] == '/')
354 else if ((inp[1] == '.') && (inp[2] == 0 || inp[2] == '/'))
356 inp += (inp[2] == '/') ? 3 : 2;
358 while (outp >= abs_buffer && *outp != '/')
360 if (outp < abs_buffer)
362 /* Catch cases like /.. where we try to backup to a
363 point above the absolute root of the logical file
366 fprintf (stderr, "%s: invalid file name: %s\n",
367 pname, rel_filename);
377 /* On exit, make sure that there is a trailing null, and make sure that
378 the last character of the returned string is *not* a slash. */
384 /* Make a copy (in the heap) of the stuff left in the absolutization
385 buffer and return a pointer to the copy. */
387 value = (char *) oballoc (strlen (abs_buffer) + 1);
388 strcpy (value, abs_buffer);
393 /* At the beginning of compilation, start writing the symbol table.
394 Initialize `typevec' and output the standard data types of C. */
397 dbxout_init (asm_file, input_file_name, syms)
399 char *input_file_name;
402 char ltext_label_name[100];
407 typevec = (enum typestatus *) xmalloc (typevec_len * sizeof typevec[0]);
408 bzero ((char *) typevec, typevec_len * sizeof typevec[0]);
410 /* Convert Ltext into the appropriate format for local labels in case
411 the system doesn't insert underscores in front of user generated
413 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
415 /* Put the current working directory in an N_SO symbol. */
416 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
417 but GDB always does. */
418 if (use_gnu_debug_info_extensions)
421 if (!cwd && (cwd = getpwd ()) && (!*cwd || cwd[strlen (cwd) - 1] != '/'))
423 char *wdslash = xmalloc (strlen (cwd) + sizeof (FILE_NAME_JOINER));
424 sprintf (wdslash, "%s%s", cwd, FILE_NAME_JOINER);
429 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
430 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd);
431 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
432 fprintf (asmfile, "%s ", ASM_STABS_OP);
433 output_quoted_string (asmfile, cwd);
434 fprintf (asmfile, ",%d,0,0,%s\n", N_SO, <ext_label_name[1]);
435 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
439 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
440 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
441 would give us an N_SOL, and we want an N_SO. */
442 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile, input_file_name);
443 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
444 /* We include outputting `Ltext:' here,
445 because that gives you a way to override it. */
446 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
447 fprintf (asmfile, "%s ", ASM_STABS_OP);
448 output_quoted_string (asmfile, input_file_name);
449 fprintf (asmfile, ",%d,0,0,%s\n",
450 N_SO, <ext_label_name[1]);
452 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Ltext", 0);
453 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
455 /* Possibly output something to inform GDB that this compilation was by
456 GCC. It's easier for GDB to parse it when after the N_SO's. This
457 is used in Solaris 2. */
458 #ifdef ASM_IDENTIFY_GCC_AFTER_SOURCE
459 ASM_IDENTIFY_GCC_AFTER_SOURCE (asmfile);
462 lastfile = input_file_name;
464 next_type_number = 1;
465 next_block_number = 2;
467 /* Make sure that types `int' and `char' have numbers 1 and 2.
468 Definitions of other integer types will refer to those numbers.
469 (Actually it should no longer matter what their numbers are.
470 Also, if any types with tags have been defined, dbxout_symbol
471 will output them first, so the numbers won't be 1 and 2. That
472 happens in C++. So it's a good thing it should no longer matter). */
474 #ifdef DBX_OUTPUT_STANDARD_TYPES
475 DBX_OUTPUT_STANDARD_TYPES (syms);
477 dbxout_symbol (TYPE_NAME (integer_type_node), 0);
478 dbxout_symbol (TYPE_NAME (char_type_node), 0);
481 /* Get all permanent types that have typedef names,
482 and output them all, except for those already output. */
484 dbxout_typedefs (syms);
487 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
488 in the reverse order from that which is found in SYMS. */
491 dbxout_typedefs (syms)
496 dbxout_typedefs (TREE_CHAIN (syms));
497 if (TREE_CODE (syms) == TYPE_DECL)
499 tree type = TREE_TYPE (syms);
501 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
502 && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
503 dbxout_symbol (TYPE_NAME (type), 0);
508 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
511 dbxout_source_file (file, filename)
515 char ltext_label_name[100];
517 if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
519 #ifdef DBX_OUTPUT_SOURCE_FILENAME
520 DBX_OUTPUT_SOURCE_FILENAME (file, filename);
522 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext",
523 source_label_number);
524 fprintf (file, "%s ", ASM_STABS_OP);
525 output_quoted_string (file, filename);
526 fprintf (file, ",%d,0,0,%s\n", N_SOL, <ext_label_name[1]);
527 if (current_function_decl != NULL_TREE
528 && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
529 ; /* Don't change section amid function. */
532 ASM_OUTPUT_INTERNAL_LABEL (file, "Ltext", source_label_number);
533 source_label_number++;
539 /* Output a line number symbol entry into output stream FILE,
540 for source file FILENAME and line number LINENO. */
543 dbxout_source_line (file, filename, lineno)
548 dbxout_source_file (file, filename);
550 #ifdef ASM_OUTPUT_SOURCE_LINE
551 ASM_OUTPUT_SOURCE_LINE (file, lineno);
553 fprintf (file, "\t%s %d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno);
557 /* At the end of compilation, finish writing the symbol table.
558 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
562 dbxout_finish (file, filename)
566 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
567 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file, filename);
568 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
571 /* Continue a symbol-description that gets too big.
572 End one symbol table entry with a double-backslash
573 and start a new one, eventually producing something like
574 .stabs "start......\\",code,0,value
575 .stabs "...rest",code,0,value */
580 #ifdef DBX_CONTIN_CHAR
581 fprintf (asmfile, "%c", DBX_CONTIN_CHAR);
583 fprintf (asmfile, "\\\\");
585 dbxout_finish_symbol (NULL_TREE);
586 fprintf (asmfile, "%s \"", ASM_STABS_OP);
587 current_sym_nchars = 0;
590 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
591 This must be a separate function because anonymous unions require
595 dbxout_type_fields (type)
599 /* Output the name, type, position (in bits), size (in bits) of each
601 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
603 /* Omit here local type decls until we know how to support them. */
604 if (TREE_CODE (tem) == TYPE_DECL)
606 /* Omit fields whose position or size are variable. */
607 else if (TREE_CODE (tem) == FIELD_DECL
608 && (TREE_CODE (DECL_FIELD_BITPOS (tem)) != INTEGER_CST
609 || TREE_CODE (DECL_SIZE (tem)) != INTEGER_CST))
611 /* Omit here the nameless fields that are used to skip bits. */
612 else if (TREE_CODE (tem) != CONST_DECL)
614 /* Continue the line if necessary,
615 but not before the first field. */
616 if (tem != TYPE_FIELDS (type))
619 if (use_gnu_debug_info_extensions
620 && flag_minimal_debug
621 && TREE_CODE (tem) == FIELD_DECL
622 && DECL_VIRTUAL_P (tem)
623 && DECL_ASSEMBLER_NAME (tem))
625 have_used_extensions = 1;
626 CHARS (3 + IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (tem)));
627 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem)), asmfile);
628 dbxout_type (DECL_FCONTEXT (tem), 0, 0);
629 fprintf (asmfile, ":");
630 dbxout_type (TREE_TYPE (tem), 0, 0);
631 fprintf (asmfile, ",%d;",
632 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)));
638 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
639 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem)));
643 fprintf (asmfile, ":");
647 if (use_gnu_debug_info_extensions
648 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
649 || TREE_CODE (tem) != FIELD_DECL))
651 have_used_extensions = 1;
653 putc ((TREE_PRIVATE (tem) ? '0'
654 : TREE_PROTECTED (tem) ? '1' : '2'),
659 dbxout_type ((TREE_CODE (tem) == FIELD_DECL
660 && DECL_BIT_FIELD_TYPE (tem))
661 ? DECL_BIT_FIELD_TYPE (tem)
662 : TREE_TYPE (tem), 0, 0);
664 if (TREE_CODE (tem) == VAR_DECL)
666 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
668 char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem));
669 have_used_extensions = 1;
670 fprintf (asmfile, ":%s;", name);
671 CHARS (strlen (name));
675 /* If TEM is non-static, GDB won't understand it. */
676 fprintf (asmfile, ",0,0;");
679 else if (TREE_CODE (DECL_FIELD_BITPOS (tem)) == INTEGER_CST)
681 fprintf (asmfile, ",%d,%d;",
682 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)),
683 TREE_INT_CST_LOW (DECL_SIZE (tem)));
690 /* Subroutine of `dbxout_type_methods'. Output debug info about the
691 method described DECL. DEBUG_NAME is an encoding of the method's
692 type signature. ??? We may be able to do without DEBUG_NAME altogether
696 dbxout_type_method_1 (decl, debug_name)
702 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
704 else /* it's a METHOD_TYPE. */
706 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
707 /* A for normal functions.
708 B for `const' member functions.
709 C for `volatile' member functions.
710 D for `const volatile' member functions. */
711 if (TYPE_READONLY (TREE_TYPE (firstarg)))
713 if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
716 if (DECL_VINDEX (decl))
722 fprintf (asmfile, ":%s;%c%c%c", debug_name,
723 TREE_PRIVATE (decl) ? '0' : TREE_PROTECTED (decl) ? '1' : '2', c1, c2);
724 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)) + 6
725 - (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
726 if (DECL_VINDEX (decl))
728 fprintf (asmfile, "%d;",
729 TREE_INT_CST_LOW (DECL_VINDEX (decl)));
730 dbxout_type (DECL_CONTEXT (decl), 0, 0);
731 fprintf (asmfile, ";");
736 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
740 dbxout_type_methods (type)
743 /* C++: put out the method names and their parameter lists */
744 tree methods = TYPE_METHODS (type);
746 register tree fndecl;
748 char formatted_type_identifier_length[16];
749 register int type_identifier_length;
751 if (methods == NULL_TREE)
754 type_encoding = DECL_NAME (TYPE_NAME (type));
757 /* C++: Template classes break some assumptions made by this code about
758 the class names, constructor names, and encodings for assembler
759 label names. For now, disable output of dbx info for them. */
761 char *ptr = IDENTIFIER_POINTER (type_encoding);
762 /* This should use index. (mrs) */
763 while (*ptr && *ptr != '<') ptr++;
770 #ifdef HAVE_TEMPLATES
771 if (warn_template_debugging)
772 warning ("dbx info for template class methods not yet supported");
780 type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
782 sprintf(formatted_type_identifier_length, "%d", type_identifier_length);
784 if (TREE_CODE (methods) == FUNCTION_DECL)
786 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
787 fndecl = TREE_VEC_ELT (methods, 0);
789 fndecl = TREE_VEC_ELT (methods, 1);
793 tree name = DECL_NAME (fndecl);
796 /* Group together all the methods for the same operation.
797 These differ in the types of the arguments. */
798 for (last = NULL_TREE;
799 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
800 fndecl = TREE_CHAIN (fndecl))
801 /* Output the name of the field (after overloading), as
802 well as the name of the field before overloading, along
803 with its parameter list */
805 /* This is the "mangled" name of the method.
806 It encodes the argument types. */
807 char *debug_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
814 if (DECL_IGNORED_P (fndecl))
817 if (flag_minimal_debug)
819 /* Detect ordinary methods because their mangled names
820 start with the operation name. */
821 if (!strncmp (IDENTIFIER_POINTER (name), debug_name,
822 IDENTIFIER_LENGTH (name)))
824 debug_name += IDENTIFIER_LENGTH (name);
825 if (debug_name[0] == '_' && debug_name[1] == '_')
827 char *method_name = debug_name + 2;
828 char *length_ptr = formatted_type_identifier_length;
829 /* Get past const and volatile qualifiers. */
830 while (*method_name == 'C' || *method_name == 'V')
832 /* Skip digits for length of type_encoding. */
833 while (*method_name == *length_ptr && *length_ptr)
834 length_ptr++, method_name++;
835 if (! strncmp (method_name,
836 IDENTIFIER_POINTER (type_encoding),
837 type_identifier_length))
838 method_name += type_identifier_length;
839 debug_name = method_name;
842 /* Detect constructors by their style of name mangling. */
843 else if (debug_name[0] == '_' && debug_name[1] == '_')
845 char *ctor_name = debug_name + 2;
846 char *length_ptr = formatted_type_identifier_length;
847 while (*ctor_name == 'C' || *ctor_name == 'V')
849 /* Skip digits for length of type_encoding. */
850 while (*ctor_name == *length_ptr && *length_ptr)
851 length_ptr++, ctor_name++;
852 if (!strncmp (IDENTIFIER_POINTER (type_encoding), ctor_name,
853 type_identifier_length))
854 debug_name = ctor_name + type_identifier_length;
856 /* The other alternative is a destructor. */
860 /* Output the operation name just once, for the first method
864 fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
865 CHARS (IDENTIFIER_LENGTH (name) + 2);
870 dbxout_type (TREE_TYPE (fndecl), 0, destructor);
872 dbxout_type_method_1 (fndecl, debug_name);
882 /* Emit a "range" type specification, which has the form:
883 "r<index type>;<lower bound>;<upper bound>;".
884 TYPE is an INTEGER_TYPE. */
887 dbxout_range_type (type)
890 fprintf (asmfile, "r");
891 if (TREE_TYPE (type))
892 dbxout_type (TREE_TYPE (type), 0, 0);
893 else if (TREE_CODE (type) != INTEGER_TYPE)
894 dbxout_type (type, 0, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
897 /* This used to say `r1' and we used to take care
898 to make sure that `int' was type number 1. */
899 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (integer_type_node));
901 if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
902 fprintf (asmfile, ";%d",
903 TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)));
905 fprintf (asmfile, ";0");
906 if (TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
907 fprintf (asmfile, ";%d;",
908 TREE_INT_CST_LOW (TYPE_MAX_VALUE (type)));
910 fprintf (asmfile, ";-1;");
913 /* Output a reference to a type. If the type has not yet been
914 described in the dbx output, output its definition now.
915 For a type already defined, just refer to its definition
916 using the type number.
918 If FULL is nonzero, and the type has been described only with
919 a forward-reference, output the definition now.
920 If FULL is zero in this case, just refer to the forward-reference
921 using the number previously allocated.
923 If SHOW_ARG_TYPES is nonzero, we output a description of the argument
924 types for a METHOD_TYPE. */
927 dbxout_type (type, full, show_arg_types)
933 static int anonymous_type_number = 0;
935 /* If there was an input error and we don't really have a type,
936 avoid crashing and write something that is at least valid
937 by assuming `int'. */
938 if (type == error_mark_node)
939 type = integer_type_node;
942 type = TYPE_MAIN_VARIANT (type);
944 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
945 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
949 if (TYPE_SYMTAB_ADDRESS (type) == 0)
951 /* Type has no dbx number assigned. Assign next available number. */
952 TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
954 /* Make sure type vector is long enough to record about this type. */
956 if (next_type_number == typevec_len)
959 (enum typestatus *) xrealloc (typevec,
960 typevec_len * 2 * sizeof typevec[0]);
961 bzero ((char *) (typevec + typevec_len),
962 typevec_len * sizeof typevec[0]);
967 /* Output the number of this type, to refer to it. */
968 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
971 #ifdef DBX_TYPE_DEFINED
972 if (DBX_TYPE_DEFINED (type))
976 /* If this type's definition has been output or is now being output,
979 switch (typevec[TYPE_SYMTAB_ADDRESS (type)])
984 /* If we have already had a cross reference,
985 and either that's all we want or that's the best we could do,
986 don't repeat the cross reference.
987 Sun dbx crashes if we do. */
988 if (! full || TYPE_SIZE (type) == 0
989 /* No way in DBX fmt to describe a variable size. */
990 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
998 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
999 leave the type-number completely undefined rather than output
1000 a cross-reference. If we have already used GNU debug info extensions,
1001 then it is OK to output a cross reference. This is necessary to get
1002 proper C++ debug output. */
1003 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
1004 || TREE_CODE (type) == QUAL_UNION_TYPE
1005 || TREE_CODE (type) == ENUMERAL_TYPE)
1006 && ! use_gnu_debug_info_extensions)
1007 /* We must use the same test here as we use twice below when deciding
1008 whether to emit a cross-reference. */
1009 if ((TYPE_NAME (type) != 0
1010 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1011 && DECL_IGNORED_P (TYPE_NAME (type)))
1013 || TYPE_SIZE (type) == 0
1014 /* No way in DBX fmt to describe a variable size. */
1015 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1017 typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_XREF;
1022 /* Output a definition now. */
1024 fprintf (asmfile, "=");
1027 /* Mark it as defined, so that if it is self-referent
1028 we will not get into an infinite recursion of definitions. */
1030 typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_DEFINED;
1032 switch (TREE_CODE (type))
1036 /* For a void type, just define it as itself; ie, "5=5".
1037 This makes us consider it defined
1038 without saying what it is. The debugger will make it
1039 a void type when the reference is seen, and nothing will
1040 ever override that default. */
1041 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
1046 if (type == char_type_node && ! TREE_UNSIGNED (type))
1047 /* Output the type `char' as a subrange of itself!
1048 I don't understand this definition, just copied it
1049 from the output of pcc.
1050 This used to use `r2' explicitly and we used to
1051 take care to make sure that `char' was type number 2. */
1052 fprintf (asmfile, "r%d;0;127;", TYPE_SYMTAB_ADDRESS (type));
1053 else if (use_gnu_debug_info_extensions
1054 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
1055 || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT))
1057 /* This used to say `r1' and we used to take care
1058 to make sure that `int' was type number 1. */
1059 fprintf (asmfile, "r%d;", TYPE_SYMTAB_ADDRESS (integer_type_node));
1060 print_int_cst_octal (TYPE_MIN_VALUE (type));
1061 fprintf (asmfile, ";");
1062 print_int_cst_octal (TYPE_MAX_VALUE (type));
1063 fprintf (asmfile, ";");
1065 else /* Output other integer types as subranges of `int'. */
1066 dbxout_range_type (type);
1071 /* This used to say `r1' and we used to take care
1072 to make sure that `int' was type number 1. */
1073 fprintf (asmfile, "r%d;%d;0;", TYPE_SYMTAB_ADDRESS (integer_type_node),
1074 int_size_in_bytes (type));
1079 if (use_gnu_debug_info_extensions)
1080 fprintf (asmfile, "@s%d;-20;",
1081 BITS_PER_UNIT * int_size_in_bytes (type));
1083 /* Output the type `char' as a subrange of itself.
1084 That is what pcc seems to do. */
1085 fprintf (asmfile, "r%d;0;%d;", TYPE_SYMTAB_ADDRESS (char_type_node),
1086 TREE_UNSIGNED (type) ? 255 : 127);
1091 if (use_gnu_debug_info_extensions)
1092 fprintf (asmfile, "@s%d;-16;",
1093 BITS_PER_UNIT * int_size_in_bytes (type));
1094 else /* Define as enumeral type (False, True) */
1095 fprintf (asmfile, "eFalse:0,True:1,;");
1100 putc ('d', asmfile);
1102 dbxout_type (TREE_TYPE (type), 0, 0);
1106 /* Differs from the REAL_TYPE by its new data type number */
1108 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1110 fprintf (asmfile, "r%d;%d;0;",
1111 TYPE_SYMTAB_ADDRESS (type),
1112 int_size_in_bytes (TREE_TYPE (type)));
1113 CHARS (15); /* The number is probably incorrect here. */
1117 /* Output a complex integer type as a structure,
1118 pending some other way to do it. */
1119 fprintf (asmfile, "s%d", int_size_in_bytes (type));
1121 fprintf (asmfile, "real:");
1123 dbxout_type (TREE_TYPE (type), 0, 0);
1124 fprintf (asmfile, ",%d,%d;",
1125 0, TYPE_PRECISION (TREE_TYPE (type)));
1127 fprintf (asmfile, "imag:");
1129 dbxout_type (TREE_TYPE (type), 0, 0);
1130 fprintf (asmfile, ",%d,%d;;",
1131 TYPE_PRECISION (TREE_TYPE (type)),
1132 TYPE_PRECISION (TREE_TYPE (type)));
1138 if (use_gnu_debug_info_extensions)
1140 have_used_extensions = 1;
1141 fprintf (asmfile, "@s%d;",
1142 BITS_PER_UNIT * int_size_in_bytes (type));
1143 /* Check if a bitstring type, which in Chill is
1144 different from a [power]set. */
1145 if (TYPE_STRING_FLAG (type))
1146 fprintf (asmfile, "@S;");
1148 putc ('S', asmfile);
1150 dbxout_type (TYPE_DOMAIN (type), 0, 0);
1154 /* Output "a" followed by a range type definition
1155 for the index type of the array
1156 followed by a reference to the target-type.
1157 ar1;0;N;M for a C array of type M and size N+1. */
1158 /* Check if a character string type, which in Chill is
1159 different from an array of characters. */
1160 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
1162 have_used_extensions = 1;
1163 fprintf (asmfile, "@S;");
1165 tem = TYPE_DOMAIN (type);
1167 fprintf (asmfile, "ar%d;0;-1;",
1168 TYPE_SYMTAB_ADDRESS (integer_type_node));
1171 fprintf (asmfile, "a");
1172 dbxout_range_type (tem);
1175 dbxout_type (TREE_TYPE (type), 0, 0);
1180 case QUAL_UNION_TYPE:
1182 int i, n_baseclasses = 0;
1184 if (TYPE_BINFO (type) != 0 && TYPE_BINFO_BASETYPES (type) != 0)
1185 n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
1187 /* Output a structure type. We must use the same test here as we
1188 use in the DBX_NO_XREFS case above. */
1189 if ((TYPE_NAME (type) != 0
1190 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1191 && DECL_IGNORED_P (TYPE_NAME (type)))
1193 || TYPE_SIZE (type) == 0
1194 /* No way in DBX fmt to describe a variable size. */
1195 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1197 /* If the type is just a cross reference, output one
1198 and mark the type as partially described.
1199 If it later becomes defined, we will output
1200 its real definition.
1201 If the type has a name, don't nest its definition within
1202 another type's definition; instead, output an xref
1203 and let the definition come when the name is defined. */
1204 fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
1206 #if 0 /* This assertion is legitimately false in C++. */
1207 /* We shouldn't be outputting a reference to a type before its
1208 definition unless the type has a tag name.
1209 A typedef name without a tag name should be impossible. */
1210 if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
1213 if (TYPE_NAME (type) != 0)
1214 dbxout_type_name (type);
1216 fprintf (asmfile, "$$%d", anonymous_type_number++);
1217 fprintf (asmfile, ":");
1218 typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_XREF;
1222 /* Identify record or union, and print its size. */
1223 fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "s%d" : "u%d",
1224 int_size_in_bytes (type));
1226 if (use_gnu_debug_info_extensions)
1230 have_used_extensions = 1;
1231 fprintf (asmfile, "!%d,", n_baseclasses);
1235 for (i = 0; i < n_baseclasses; i++)
1237 tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i);
1238 if (use_gnu_debug_info_extensions)
1240 have_used_extensions = 1;
1241 putc (TREE_VIA_VIRTUAL (child) ? '1'
1244 putc (TREE_VIA_PUBLIC (child) ? '2'
1247 fprintf (asmfile, "%d,",
1248 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT);
1250 dbxout_type (BINFO_TYPE (child), 0, 0);
1251 putc (';', asmfile);
1255 /* Print out the base class information with fields
1256 which have the same names at the types they hold. */
1257 dbxout_type_name (BINFO_TYPE (child));
1258 putc (':', asmfile);
1259 dbxout_type (BINFO_TYPE (child), full, 0);
1260 fprintf (asmfile, ",%d,%d;",
1261 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT,
1262 TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child)))) * BITS_PER_UNIT);
1270 /* Write out the field declarations. */
1271 dbxout_type_fields (type);
1272 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
1274 have_used_extensions = 1;
1275 dbxout_type_methods (type);
1277 putc (';', asmfile);
1279 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
1280 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1281 && TYPE_VFIELD (type))
1283 have_used_extensions = 1;
1285 /* Tell GDB+ that it may keep reading. */
1286 putc ('~', asmfile);
1288 /* We need to write out info about what field this class
1289 uses as its "main" vtable pointer field, because if this
1290 field is inherited from a base class, GDB cannot necessarily
1291 figure out which field it's using in time. */
1292 if (TYPE_VFIELD (type))
1294 putc ('%', asmfile);
1295 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0, 0);
1297 putc (';', asmfile);
1303 /* We must use the same test here as we use in the DBX_NO_XREFS case
1304 above. We simplify it a bit since an enum will never have a variable
1306 if ((TYPE_NAME (type) != 0
1307 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1308 && DECL_IGNORED_P (TYPE_NAME (type)))
1310 || TYPE_SIZE (type) == 0)
1312 fprintf (asmfile, "xe");
1314 dbxout_type_name (type);
1315 typevec[TYPE_SYMTAB_ADDRESS (type)] = TYPE_XREF;
1316 fprintf (asmfile, ":");
1319 #ifdef DBX_OUTPUT_ENUM
1320 DBX_OUTPUT_ENUM (asmfile, type);
1322 if (use_gnu_debug_info_extensions
1323 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1324 fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1325 putc ('e', asmfile);
1327 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
1329 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1330 if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
1331 fprintf (asmfile, "%lu",
1332 (unsigned long) TREE_INT_CST_LOW (TREE_VALUE (tem)));
1333 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
1334 && TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
1335 fprintf (asmfile, "%ld",
1336 (long) TREE_INT_CST_LOW (TREE_VALUE (tem)));
1338 print_int_cst_octal (TREE_VALUE (tem));
1339 fprintf (asmfile, ",");
1340 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem)));
1341 if (TREE_CHAIN (tem) != 0)
1344 putc (';', asmfile);
1350 putc ('*', asmfile);
1352 dbxout_type (TREE_TYPE (type), 0, 0);
1356 if (use_gnu_debug_info_extensions)
1358 have_used_extensions = 1;
1359 putc ('#', asmfile);
1361 if (flag_minimal_debug && !show_arg_types)
1363 /* Normally, just output the return type.
1364 The argument types are encoded in the method name. */
1365 putc ('#', asmfile);
1366 dbxout_type (TREE_TYPE (type), 0, 0);
1367 putc (';', asmfile);
1372 /* When outputting destructors, we need to write
1373 the argument types out longhand. */
1374 dbxout_type (TYPE_METHOD_BASETYPE (type), 0, 0);
1375 putc (',', asmfile);
1377 dbxout_type (TREE_TYPE (type), 0, 0);
1378 dbxout_args (TYPE_ARG_TYPES (type));
1379 putc (';', asmfile);
1385 /* Treat it as a function type. */
1386 dbxout_type (TREE_TYPE (type), 0, 0);
1391 if (use_gnu_debug_info_extensions)
1393 have_used_extensions = 1;
1394 putc ('@', asmfile);
1396 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0, 0);
1397 putc (',', asmfile);
1399 dbxout_type (TREE_TYPE (type), 0, 0);
1403 /* Should print as an int, because it is really
1405 dbxout_type (integer_type_node, 0, 0);
1409 case REFERENCE_TYPE:
1410 if (use_gnu_debug_info_extensions)
1411 have_used_extensions = 1;
1412 putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
1414 dbxout_type (TREE_TYPE (type), 0, 0);
1418 putc ('f', asmfile);
1420 dbxout_type (TREE_TYPE (type), 0, 0);
1428 /* Print the value of integer constant C, in octal,
1429 handling double precision. */
1432 print_int_cst_octal (c)
1435 unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
1436 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
1437 int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
1438 int width = TYPE_PRECISION (TREE_TYPE (c));
1440 /* GDB wants constants with no extra leading "1" bits, so
1441 we need to remove any sign-extension that might be
1443 if (width == HOST_BITS_PER_WIDE_INT * 2)
1445 else if (width > HOST_BITS_PER_WIDE_INT)
1446 high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
1447 else if (width == HOST_BITS_PER_WIDE_INT)
1450 high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
1452 fprintf (asmfile, "0");
1456 print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
1457 print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
1461 unsigned HOST_WIDE_INT beg = high >> excess;
1462 unsigned HOST_WIDE_INT middle
1463 = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
1464 | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
1465 unsigned HOST_WIDE_INT end
1466 = low & (((unsigned HOST_WIDE_INT) 1
1467 << (HOST_BITS_PER_WIDE_INT / 3 * 3))
1470 fprintf (asmfile, "%o%01o", beg, middle);
1471 print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
1476 print_octal (value, digits)
1477 unsigned HOST_WIDE_INT value;
1482 for (i = digits - 1; i >= 0; i--)
1483 fprintf (asmfile, "%01o", ((value >> (3 * i)) & 7));
1486 /* Output the name of type TYPE, with no punctuation.
1487 Such names can be set up either by typedef declarations
1488 or by struct, enum and union tags. */
1491 dbxout_type_name (type)
1495 if (TYPE_NAME (type) == 0)
1497 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
1499 t = TYPE_NAME (type);
1501 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1503 t = DECL_NAME (TYPE_NAME (type));
1508 fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
1509 CHARS (IDENTIFIER_LENGTH (t));
1512 /* Output a .stabs for the symbol defined by DECL,
1513 which must be a ..._DECL node in the normal namespace.
1514 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1515 LOCAL is nonzero if the scope is less than the entire file. */
1518 dbxout_symbol (decl, local)
1522 tree type = TREE_TYPE (decl);
1523 tree context = NULL_TREE;
1525 /* Cast avoids warning in old compilers. */
1526 current_sym_code = (STAB_CODE_TYPE) 0;
1527 current_sym_value = 0;
1528 current_sym_addr = 0;
1530 /* Ignore nameless syms, but don't ignore type tags. */
1532 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
1533 || DECL_IGNORED_P (decl))
1536 dbxout_prepare_symbol (decl);
1538 /* The output will always start with the symbol name,
1539 so always count that in the length-output-so-far. */
1541 if (DECL_NAME (decl) != 0)
1542 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
1544 switch (TREE_CODE (decl))
1547 /* Enum values are defined by defining the enum type. */
1551 if (DECL_RTL (decl) == 0)
1553 if (DECL_EXTERNAL (decl))
1555 /* Don't mention a nested function under its parent. */
1556 context = decl_function_context (decl);
1557 if (context == current_function_decl)
1559 if (GET_CODE (DECL_RTL (decl)) != MEM
1560 || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
1564 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
1565 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1566 TREE_PUBLIC (decl) ? 'F' : 'f');
1568 current_sym_code = N_FUN;
1569 current_sym_addr = XEXP (DECL_RTL (decl), 0);
1571 if (TREE_TYPE (type))
1572 dbxout_type (TREE_TYPE (type), 0, 0);
1574 dbxout_type (void_type_node, 0, 0);
1576 /* For a nested function, when that function is compiled,
1577 mention the containing function name
1578 as well as (since dbx wants it) our own assembler-name. */
1580 fprintf (asmfile, ",%s,%s",
1581 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1582 IDENTIFIER_POINTER (DECL_NAME (context)));
1584 dbxout_finish_symbol (decl);
1589 /* This seems all wrong. Outputting most kinds of types gives no name
1590 at all. A true definition gives no name; a cross-ref for a
1591 structure can give the tag name, but not a type name.
1592 It seems that no typedef name is defined by outputting a type. */
1594 /* If this typedef name was defined by outputting the type,
1595 don't duplicate it. */
1596 if (typevec[TYPE_SYMTAB_ADDRESS (type)] == TYPE_DEFINED
1597 && TYPE_NAME (TREE_TYPE (decl)) == decl)
1600 /* Don't output the same typedef twice.
1601 And don't output what language-specific stuff doesn't want output. */
1602 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
1611 if (DECL_NAME (decl))
1613 /* Nonzero means we must output a tag as well as a typedef. */
1616 /* Handle the case of a C++ structure or union
1617 where the TYPE_NAME is a TYPE_DECL
1618 which gives both a typedef name and a tag. */
1619 /* dbx requires the tag first and the typedef second. */
1620 if ((TREE_CODE (type) == RECORD_TYPE
1621 || TREE_CODE (type) == UNION_TYPE
1622 || TREE_CODE (type) == QUAL_UNION_TYPE)
1623 && TYPE_NAME (type) == decl
1624 && !(use_gnu_debug_info_extensions && have_used_extensions)
1625 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
1626 /* Distinguish the implicit typedefs of C++
1627 from explicit ones that might be found in C. */
1628 && (!strcmp (lang_identify (), "cplusplus")
1629 /* The following line maybe unnecessary;
1630 in 2.6, try removing it. */
1631 || DECL_SOURCE_LINE (decl) == 0))
1633 tree name = TYPE_NAME (type);
1634 if (TREE_CODE (name) == TYPE_DECL)
1635 name = DECL_NAME (name);
1637 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1638 current_sym_value = 0;
1639 current_sym_addr = 0;
1640 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1642 fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP,
1643 IDENTIFIER_POINTER (name));
1644 dbxout_type (type, 1, 0);
1645 dbxout_finish_symbol (NULL_TREE);
1648 /* Output typedef name. */
1649 fprintf (asmfile, "%s \"%s:", ASM_STABS_OP,
1650 IDENTIFIER_POINTER (DECL_NAME (decl)));
1652 /* Short cut way to output a tag also. */
1653 if ((TREE_CODE (type) == RECORD_TYPE
1654 || TREE_CODE (type) == UNION_TYPE
1655 || TREE_CODE (type) == QUAL_UNION_TYPE)
1656 && TYPE_NAME (type) == decl)
1658 if (use_gnu_debug_info_extensions && have_used_extensions)
1660 putc ('T', asmfile);
1661 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
1663 #if 0 /* Now we generate the tag for this case up above. */
1669 putc ('t', asmfile);
1670 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1672 dbxout_type (type, 1, 0);
1673 dbxout_finish_symbol (decl);
1677 /* Don't output a tag if this is an incomplete type (TYPE_SIZE is
1678 zero). This prevents the sun4 Sun OS 4.x dbx from crashing. */
1680 if (tag_needed && TYPE_NAME (type) != 0
1681 && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
1682 || (DECL_NAME (TYPE_NAME (type)) != 0))
1683 && TYPE_SIZE (type) != 0
1684 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
1686 /* For a TYPE_DECL with no name, but the type has a name,
1688 This is what represents `struct foo' with no typedef. */
1689 /* In C++, the name of a type is the corresponding typedef.
1690 In C, it is an IDENTIFIER_NODE. */
1691 tree name = TYPE_NAME (type);
1692 if (TREE_CODE (name) == TYPE_DECL)
1693 name = DECL_NAME (name);
1695 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1696 current_sym_value = 0;
1697 current_sym_addr = 0;
1698 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1700 fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP,
1701 IDENTIFIER_POINTER (name));
1702 dbxout_type (type, 1, 0);
1703 dbxout_finish_symbol (NULL_TREE);
1707 /* If an enum type has no name, it cannot be referred to,
1708 but we must output it anyway, since the enumeration constants
1709 can be referred to. */
1710 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
1712 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1713 current_sym_value = 0;
1714 current_sym_addr = 0;
1715 current_sym_nchars = 2;
1717 /* Some debuggers fail when given NULL names, so give this a
1718 harmless name of ` '. */
1719 fprintf (asmfile, "%s \" :T", ASM_STABS_OP);
1720 dbxout_type (type, 1, 0);
1721 dbxout_finish_symbol (NULL_TREE);
1724 /* Prevent duplicate output of a typedef. */
1725 TREE_ASM_WRITTEN (decl) = 1;
1730 /* Parm decls go in their own separate chains
1731 and are output by dbxout_reg_parms and dbxout_parms. */
1735 /* Named return value, treat like a VAR_DECL. */
1737 if (DECL_RTL (decl) == 0)
1739 /* Don't mention a variable that is external.
1740 Let the file that defines it describe it. */
1741 if (DECL_EXTERNAL (decl))
1744 /* If the variable is really a constant
1745 and not written in memory, inform the debugger. */
1746 if (TREE_STATIC (decl) && TREE_READONLY (decl)
1747 && DECL_INITIAL (decl) != 0
1748 && ! TREE_ASM_WRITTEN (decl)
1749 && (DECL_FIELD_CONTEXT (decl) == NULL_TREE
1750 || TREE_CODE (DECL_FIELD_CONTEXT (decl)) == BLOCK))
1752 if (TREE_PUBLIC (decl) == 0)
1754 /* The sun4 assembler does not grok this. */
1755 char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1756 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
1757 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
1759 HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl));
1760 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1761 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile, name, ival);
1763 fprintf (asmfile, "%s \"%s:c=i%d\",0x%x,0,0,0\n",
1764 ASM_STABS_OP, name, ival, N_LSYM);
1768 else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
1770 /* don't know how to do this yet. */
1774 /* else it is something we handle like a normal variable. */
1777 DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, NULL_RTX);
1778 #ifdef LEAF_REG_REMAP
1780 leaf_renumber_regs_insn (DECL_RTL (decl));
1783 dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
1787 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1788 Add SUFFIX to its name, if SUFFIX is not 0.
1789 Describe the variable as residing in HOME
1790 (usually HOME is DECL_RTL (DECL), but not always). */
1793 dbxout_symbol_location (decl, type, suffix, home)
1801 /* Don't mention a variable at all
1802 if it was completely optimized into nothingness.
1804 If the decl was from an inline function, then it's rtl
1805 is not identically the rtl that was used in this
1806 particular compilation. */
1807 if (GET_CODE (home) == REG)
1809 regno = REGNO (home);
1810 if (regno >= FIRST_PSEUDO_REGISTER)
1813 else if (GET_CODE (home) == SUBREG)
1817 while (GET_CODE (value) == SUBREG)
1819 offset += SUBREG_WORD (value);
1820 value = SUBREG_REG (value);
1822 if (GET_CODE (value) == REG)
1824 regno = REGNO (value);
1825 if (regno >= FIRST_PSEUDO_REGISTER)
1829 alter_subreg (home);
1832 /* The kind-of-variable letter depends on where
1833 the variable is and on the scope of its name:
1834 G and N_GSYM for static storage and global scope,
1835 S for static storage and file scope,
1836 V for static storage and local scope,
1837 for those two, use N_LCSYM if data is in bss segment,
1838 N_STSYM if in data segment, N_FUN otherwise.
1839 (We used N_FUN originally, then changed to N_STSYM
1840 to please GDB. However, it seems that confused ld.
1841 Now GDB has been fixed to like N_FUN, says Kingdon.)
1842 no letter at all, and N_LSYM, for auto variable,
1843 r and N_RSYM for register variable. */
1845 if (GET_CODE (home) == MEM
1846 && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
1848 if (TREE_PUBLIC (decl))
1851 current_sym_code = N_GSYM;
1855 current_sym_addr = XEXP (home, 0);
1857 letter = decl_function_context (decl) ? 'V' : 'S';
1859 /* This should be the same condition as in assemble_variable, but
1860 we don't have access to dont_output_data here. So, instead,
1861 we rely on the fact that error_mark_node initializers always
1862 end up in bss for C++ and never end up in bss for C. */
1863 if (DECL_INITIAL (decl) == 0
1864 || (!strcmp (lang_identify (), "cplusplus")
1865 && DECL_INITIAL (decl) == error_mark_node))
1866 current_sym_code = N_LCSYM;
1867 else if (DECL_IN_TEXT_SECTION (decl))
1868 /* This is not quite right, but it's the closest
1869 of all the codes that Unix defines. */
1870 current_sym_code = DBX_STATIC_CONST_VAR_CODE;
1873 /* Ultrix `as' seems to need this. */
1874 #ifdef DBX_STATIC_STAB_DATA_SECTION
1877 current_sym_code = N_STSYM;
1881 else if (regno >= 0)
1884 current_sym_code = N_RSYM;
1885 current_sym_value = DBX_REGISTER_NUMBER (regno);
1887 else if (GET_CODE (home) == MEM
1888 && (GET_CODE (XEXP (home, 0)) == MEM
1889 || (GET_CODE (XEXP (home, 0)) == REG
1890 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM)))
1891 /* If the value is indirect by memory or by a register
1892 that isn't the frame pointer
1893 then it means the object is variable-sized and address through
1894 that register or stack slot. DBX has no way to represent this
1895 so all we can do is output the variable as a pointer.
1896 If it's not a parameter, ignore it.
1897 (VAR_DECLs like this can be made by integrate.c.) */
1899 if (GET_CODE (XEXP (home, 0)) == REG)
1902 current_sym_code = N_RSYM;
1903 current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
1907 current_sym_code = N_LSYM;
1908 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
1909 We want the value of that CONST_INT. */
1911 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
1914 /* Effectively do build_pointer_type, but don't cache this type,
1915 since it might be temporary whereas the type it points to
1916 might have been saved for inlining. */
1917 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
1918 type = make_node (POINTER_TYPE);
1919 TREE_TYPE (type) = TREE_TYPE (decl);
1921 else if (GET_CODE (home) == MEM
1922 && GET_CODE (XEXP (home, 0)) == REG)
1924 current_sym_code = N_LSYM;
1925 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
1927 else if (GET_CODE (home) == MEM
1928 && GET_CODE (XEXP (home, 0)) == PLUS
1929 && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
1931 current_sym_code = N_LSYM;
1932 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
1933 We want the value of that CONST_INT. */
1934 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
1936 else if (GET_CODE (home) == MEM
1937 && GET_CODE (XEXP (home, 0)) == CONST)
1939 /* Handle an obscure case which can arise when optimizing and
1940 when there are few available registers. (This is *always*
1941 the case for i386/i486 targets). The RTL looks like
1942 (MEM (CONST ...)) even though this variable is a local `auto'
1943 or a local `register' variable. In effect, what has happened
1944 is that the reload pass has seen that all assignments and
1945 references for one such a local variable can be replaced by
1946 equivalent assignments and references to some static storage
1947 variable, thereby avoiding the need for a register. In such
1948 cases we're forced to lie to debuggers and tell them that
1949 this variable was itself `static'. */
1950 current_sym_code = N_LCSYM;
1952 current_sym_addr = XEXP (XEXP (home, 0), 0);
1954 else if (GET_CODE (home) == CONCAT)
1956 tree subtype = TREE_TYPE (type);
1958 /* If the variable's storage is in two parts,
1959 output each as a separate stab with a modified name. */
1960 if (WORDS_BIG_ENDIAN)
1961 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
1963 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
1965 /* Cast avoids warning in old compilers. */
1966 current_sym_code = (STAB_CODE_TYPE) 0;
1967 current_sym_value = 0;
1968 current_sym_addr = 0;
1969 dbxout_prepare_symbol (decl);
1971 if (WORDS_BIG_ENDIAN)
1972 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
1974 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
1978 /* Address might be a MEM, when DECL is a variable-sized object.
1979 Or it might be const0_rtx, meaning previous passes
1980 want us to ignore this variable. */
1983 /* Ok, start a symtab entry and output the variable name. */
1986 #ifdef DBX_STATIC_BLOCK_START
1987 DBX_STATIC_BLOCK_START (asmfile, current_sym_code);
1990 dbxout_symbol_name (decl, suffix, letter);
1991 dbxout_type (type, 0, 0);
1992 dbxout_finish_symbol (decl);
1994 #ifdef DBX_STATIC_BLOCK_END
1995 DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
1999 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2000 Then output LETTER to indicate the kind of location the symbol has. */
2003 dbxout_symbol_name (decl, suffix, letter)
2008 /* One slight hitch: if this is a VAR_DECL which is a static
2009 class member, we must put out the mangled name instead of the
2010 DECL_NAME. Note also that static member (variable) names DO NOT begin
2011 with underscores in .stabs directives. */
2012 char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2015 fprintf (asmfile, "%s \"%s%s:", ASM_STABS_OP, name,
2016 (suffix ? suffix : ""));
2018 if (letter) putc (letter, asmfile);
2022 dbxout_prepare_symbol (decl)
2026 char *filename = DECL_SOURCE_FILE (decl);
2028 dbxout_source_file (asmfile, filename);
2033 dbxout_finish_symbol (sym)
2036 #ifdef DBX_FINISH_SYMBOL
2037 DBX_FINISH_SYMBOL (sym);
2040 if (use_gnu_debug_info_extensions && sym != 0)
2041 line = DECL_SOURCE_LINE (sym);
2043 fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line);
2044 if (current_sym_addr)
2045 output_addr_const (asmfile, current_sym_addr);
2047 fprintf (asmfile, "%d", current_sym_value);
2048 putc ('\n', asmfile);
2052 /* Output definitions of all the decls in a chain. */
2060 dbxout_symbol (syms, 1);
2061 syms = TREE_CHAIN (syms);
2065 /* The following two functions output definitions of function parameters.
2066 Each parameter gets a definition locating it in the parameter list.
2067 Each parameter that is a register variable gets a second definition
2068 locating it in the register.
2070 Printing or argument lists in gdb uses the definitions that
2071 locate in the parameter list. But reference to the variable in
2072 expressions uses preferentially the definition as a register. */
2074 /* Output definitions, referring to storage in the parmlist,
2075 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2078 dbxout_parms (parms)
2081 for (; parms; parms = TREE_CHAIN (parms))
2082 if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node)
2084 dbxout_prepare_symbol (parms);
2086 /* Perform any necessary register eliminations on the parameter's rtl,
2087 so that the debugging output will be accurate. */
2088 DECL_INCOMING_RTL (parms)
2089 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
2090 DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX);
2091 #ifdef LEAF_REG_REMAP
2094 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
2095 leaf_renumber_regs_insn (DECL_RTL (parms));
2099 if (PARM_PASSED_IN_MEMORY (parms))
2101 rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
2103 /* ??? Here we assume that the parm address is indexed
2104 off the frame pointer or arg pointer.
2105 If that is not true, we produce meaningless results,
2106 but do not crash. */
2107 if (GET_CODE (addr) == PLUS
2108 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
2109 current_sym_value = INTVAL (XEXP (addr, 1));
2111 current_sym_value = 0;
2113 current_sym_code = N_PSYM;
2114 current_sym_addr = 0;
2117 if (DECL_NAME (parms))
2119 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2121 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2122 IDENTIFIER_POINTER (DECL_NAME (parms)),
2123 DBX_MEMPARM_STABS_LETTER);
2127 current_sym_nchars = 8;
2128 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2129 DBX_MEMPARM_STABS_LETTER);
2132 dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
2133 current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
2134 dbxout_finish_symbol (parms);
2136 else if (GET_CODE (DECL_RTL (parms)) == REG)
2139 char regparm_letter;
2141 /* Parm passed in registers and lives in registers or nowhere. */
2143 current_sym_code = DBX_REGPARM_STABS_CODE;
2144 regparm_letter = DBX_REGPARM_STABS_LETTER;
2145 current_sym_addr = 0;
2147 /* If parm lives in a register, use that register;
2148 pretend the parm was passed there. It would be more consistent
2149 to describe the register where the parm was passed,
2150 but in practice that register usually holds something else.
2152 If we use DECL_RTL, then we must use the declared type of
2153 the variable, not the type that it arrived in. */
2154 if (REGNO (DECL_RTL (parms)) >= 0
2155 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2157 best_rtl = DECL_RTL (parms);
2158 parm_type = TREE_TYPE (parms);
2160 /* If the parm lives nowhere, use the register where it was
2161 passed. It is also better to use the declared type here. */
2164 best_rtl = DECL_INCOMING_RTL (parms);
2165 parm_type = TREE_TYPE (parms);
2167 current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
2170 if (DECL_NAME (parms))
2172 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2173 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2174 IDENTIFIER_POINTER (DECL_NAME (parms)),
2179 current_sym_nchars = 8;
2180 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2184 dbxout_type (parm_type, 0, 0);
2185 dbxout_finish_symbol (parms);
2187 else if (GET_CODE (DECL_RTL (parms)) == MEM
2188 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2189 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
2190 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
2191 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2192 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
2196 /* Parm was passed via invisible reference.
2197 That is, its address was passed in a register.
2198 Output it as if it lived in that register.
2199 The debugger will know from the type
2200 that it was actually passed by invisible reference. */
2202 char regparm_letter;
2203 /* Parm passed in registers and lives in registers or nowhere. */
2205 current_sym_code = DBX_REGPARM_STABS_CODE;
2206 if (use_gnu_debug_info_extensions)
2207 regparm_letter = GDB_INV_REF_REGPARM_STABS_LETTER;
2209 regparm_letter = DBX_REGPARM_STABS_LETTER;
2211 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2212 If it is an unallocated pseudo-reg, then use the register where
2213 it was passed instead. */
2214 if (REGNO (XEXP (DECL_RTL (parms), 0)) >= 0
2215 && REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
2216 current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2218 current_sym_value = REGNO (DECL_INCOMING_RTL (parms));
2220 current_sym_addr = 0;
2223 if (DECL_NAME (parms))
2225 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2227 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2228 IDENTIFIER_POINTER (DECL_NAME (parms)),
2233 current_sym_nchars = 8;
2234 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2238 dbxout_type (TREE_TYPE (parms), 0, 0);
2239 dbxout_finish_symbol (parms);
2241 else if (GET_CODE (DECL_RTL (parms)) == MEM
2242 && XEXP (DECL_RTL (parms), 0) != const0_rtx
2243 /* ??? A constant address for a parm can happen
2244 when the reg it lives in is equiv to a constant in memory.
2245 Should make this not happen, after 2.4. */
2246 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
2248 /* Parm was passed in registers but lives on the stack. */
2250 current_sym_code = N_PSYM;
2251 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2252 in which case we want the value of that CONST_INT,
2253 or (MEM (REG ...)) or (MEM (MEM ...)),
2254 in which case we use a value of zero. */
2255 if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2256 || GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
2257 current_sym_value = 0;
2259 current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
2260 current_sym_addr = 0;
2263 if (DECL_NAME (parms))
2265 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2267 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2268 IDENTIFIER_POINTER (DECL_NAME (parms)),
2269 DBX_MEMPARM_STABS_LETTER);
2273 current_sym_nchars = 8;
2274 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2275 DBX_MEMPARM_STABS_LETTER);
2279 = DEBUGGER_ARG_OFFSET (current_sym_value,
2280 XEXP (DECL_RTL (parms), 0));
2281 dbxout_type (TREE_TYPE (parms), 0, 0);
2282 dbxout_finish_symbol (parms);
2287 /* Output definitions for the places where parms live during the function,
2288 when different from where they were passed, when the parms were passed
2291 It is not useful to do this for parms passed in registers
2292 that live during the function in different registers, because it is
2293 impossible to look in the passed register for the passed value,
2294 so we use the within-the-function register to begin with.
2296 PARMS is a chain of PARM_DECL nodes. */
2299 dbxout_reg_parms (parms)
2302 for (; parms; parms = TREE_CHAIN (parms))
2303 if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
2305 dbxout_prepare_symbol (parms);
2307 /* Report parms that live in registers during the function
2308 but were passed in memory. */
2309 if (GET_CODE (DECL_RTL (parms)) == REG
2310 && REGNO (DECL_RTL (parms)) >= 0
2311 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2312 dbxout_symbol_location (parms, TREE_TYPE (parms),
2313 0, DECL_RTL (parms));
2314 else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
2315 dbxout_symbol_location (parms, TREE_TYPE (parms),
2316 0, DECL_RTL (parms));
2317 /* Report parms that live in memory but not where they were passed. */
2318 else if (GET_CODE (DECL_RTL (parms)) == MEM
2319 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
2320 dbxout_symbol_location (parms, TREE_TYPE (parms),
2321 0, DECL_RTL (parms));
2325 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2326 output definitions of those names, in raw form */
2334 putc (',', asmfile);
2335 dbxout_type (TREE_VALUE (args), 0, 0);
2337 args = TREE_CHAIN (args);
2341 /* Given a chain of ..._TYPE nodes,
2342 find those which have typedef names and output those names.
2343 This is to ensure those types get output. */
2346 dbxout_types (types)
2347 register tree types;
2351 if (TYPE_NAME (types)
2352 && TREE_CODE (TYPE_NAME (types)) == TYPE_DECL
2353 && ! TREE_ASM_WRITTEN (TYPE_NAME (types)))
2354 dbxout_symbol (TYPE_NAME (types), 1);
2355 types = TREE_CHAIN (types);
2359 /* Output everything about a symbol block (a BLOCK node
2360 that represents a scope level),
2361 including recursive output of contained blocks.
2363 BLOCK is the BLOCK node.
2364 DEPTH is its depth within containing symbol blocks.
2365 ARGS is usually zero; but for the outermost block of the
2366 body of a function, it is a chain of PARM_DECLs for the function parameters.
2367 We output definitions of all the register parms
2368 as if they were local variables of that block.
2370 If -g1 was used, we count blocks just the same, but output nothing
2371 except for the outermost block.
2373 Actually, BLOCK may be several blocks chained together.
2374 We handle them all in sequence. */
2377 dbxout_block (block, depth, args)
2378 register tree block;
2386 /* Ignore blocks never expanded or otherwise marked as real. */
2387 if (TREE_USED (block))
2389 #ifndef DBX_LBRAC_FIRST
2390 /* In dbx format, the syms of a block come before the N_LBRAC. */
2391 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2392 dbxout_syms (BLOCK_VARS (block));
2394 dbxout_reg_parms (args);
2397 /* Now output an N_LBRAC symbol to represent the beginning of
2398 the block. Use the block's tree-walk order to generate
2399 the assembler symbols LBBn and LBEn
2400 that final will define around the code in this block. */
2401 if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE)
2404 blocknum = next_block_number++;
2405 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
2407 if (BLOCK_HANDLER_BLOCK (block))
2409 /* A catch block. Must precede N_LBRAC. */
2410 tree decl = BLOCK_VARS (block);
2413 #ifdef DBX_OUTPUT_CATCH
2414 DBX_OUTPUT_CATCH (asmfile, decl, buf);
2416 fprintf (asmfile, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP,
2417 IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
2418 assemble_name (asmfile, buf);
2419 fprintf (asmfile, "\n");
2421 decl = TREE_CHAIN (decl);
2425 #ifdef DBX_OUTPUT_LBRAC
2426 DBX_OUTPUT_LBRAC (asmfile, buf);
2428 fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_LBRAC);
2429 assemble_name (asmfile, buf);
2430 #if DBX_BLOCKS_FUNCTION_RELATIVE
2431 fputc ('-', asmfile);
2432 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
2434 fprintf (asmfile, "\n");
2438 /* Count blocks the same way regardless of debug_info_level. */
2439 next_block_number++;
2441 #ifdef DBX_LBRAC_FIRST
2442 /* On some weird machines, the syms of a block
2443 come after the N_LBRAC. */
2444 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2445 dbxout_syms (BLOCK_VARS (block));
2447 dbxout_reg_parms (args);
2450 /* Output the subblocks. */
2451 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
2453 /* Refer to the marker for the end of the block. */
2454 if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE)
2457 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
2458 #ifdef DBX_OUTPUT_RBRAC
2459 DBX_OUTPUT_RBRAC (asmfile, buf);
2461 fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_RBRAC);
2462 assemble_name (asmfile, buf);
2463 #if DBX_BLOCKS_FUNCTION_RELATIVE
2464 fputc ('-', asmfile);
2465 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
2467 fprintf (asmfile, "\n");
2471 block = BLOCK_CHAIN (block);
2475 /* Output the information about a function and its arguments and result.
2476 Usually this follows the function's code,
2477 but on some systems, it comes before. */
2480 dbxout_really_begin_function (decl)
2483 dbxout_symbol (decl, 0);
2484 dbxout_parms (DECL_ARGUMENTS (decl));
2485 if (DECL_NAME (DECL_RESULT (decl)) != 0)
2486 dbxout_symbol (DECL_RESULT (decl), 1);
2489 /* Called at beginning of output of function definition. */
2492 dbxout_begin_function (decl)
2495 #ifdef DBX_FUNCTION_FIRST
2496 dbxout_really_begin_function (decl);
2500 /* Output dbx data for a function definition.
2501 This includes a definition of the function name itself (a symbol),
2502 definitions of the parameters (locating them in the parameter list)
2503 and then output the block that makes up the function's body
2504 (including all the auto variables of the function). */
2507 dbxout_function (decl)
2510 #ifndef DBX_FUNCTION_FIRST
2511 dbxout_really_begin_function (decl);
2513 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
2514 #ifdef DBX_OUTPUT_FUNCTION_END
2515 DBX_OUTPUT_FUNCTION_END (asmfile, decl);
2518 #endif /* DBX_DEBUGGING_INFO */