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) || defined (CROSS_COMPILE)
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 /* Structure recording information about a C data type.
209 The status element says whether we have yet output
210 the definition of the type. TYPE_XREF says we have
211 output it as a cross-reference only.
212 The file_number and type_number elements are used if DBX_USE_BINCL
217 enum typestatus status;
224 /* Vector recording information about C data types.
225 When we first notice a data type (a tree node),
226 we assign it a number using next_type_number.
227 That is its index in this vector. */
229 struct typeinfo *typevec;
231 /* Number of elements of space allocated in `typevec'. */
233 static int typevec_len;
235 /* In dbx output, each type gets a unique number.
236 This is the number for the next type output.
237 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
239 static int next_type_number;
243 /* When using N_BINCL in dbx output, each type number is actually a
244 pair of the file number and the type number within the file.
245 This is a stack of input files. */
249 struct dbx_file *next;
251 int next_type_number;
254 /* This is the top of the stack. */
256 static struct dbx_file *current_file;
258 /* This is the next file number to use. */
260 static int next_file_number;
262 #endif /* DBX_USE_BINCL */
264 /* In dbx output, we must assign symbol-blocks id numbers
265 in the order in which their beginnings are encountered.
266 We output debugging info that refers to the beginning and
267 end of the ranges of code in each block
268 with assembler labels LBBn and LBEn, where n is the block number.
269 The labels are generated in final, which assigns numbers to the
270 blocks in the same way. */
272 static int next_block_number;
274 /* These variables are for dbxout_symbol to communicate to
275 dbxout_finish_symbol.
276 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
277 current_sym_value and current_sym_addr are two ways to address the
278 value to store in the symtab entry.
279 current_sym_addr if nonzero represents the value as an rtx.
280 If that is zero, current_sym_value is used. This is used
281 when the value is an offset (such as for auto variables,
282 register variables and parms). */
284 static STAB_CODE_TYPE current_sym_code;
285 static int current_sym_value;
286 static rtx current_sym_addr;
288 /* Number of chars of symbol-description generated so far for the
289 current symbol. Used by CHARS and CONTIN. */
291 static int current_sym_nchars;
293 /* Report having output N chars of the current symbol-description. */
295 #define CHARS(N) (current_sym_nchars += (N))
297 /* Break the current symbol-description, generating a continuation,
298 if it has become long. */
300 #ifndef DBX_CONTIN_LENGTH
301 #define DBX_CONTIN_LENGTH 80
304 #if DBX_CONTIN_LENGTH > 0
306 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
311 void dbxout_types ();
313 void dbxout_symbol ();
314 static void dbxout_type_name ();
315 static void dbxout_type ();
316 static void dbxout_typedefs ();
317 static void dbxout_symbol_name ();
318 static void dbxout_symbol_location ();
319 static void dbxout_prepare_symbol ();
320 static void dbxout_finish_symbol ();
321 static void dbxout_type_index ();
322 static void dbxout_continue ();
323 static void print_int_cst_octal ();
324 static void print_octal ();
326 #if 0 /* Not clear we will actually need this. */
328 /* Return the absolutized filename for the given relative
329 filename. Note that if that filename is already absolute, it may
330 still be returned in a modified form because this routine also
331 eliminates redundant slashes and single dots and eliminates double
332 dots to get a shortest possible filename from the given input
333 filename. The absolutization of relative filenames is made by
334 assuming that the given filename is to be taken as relative to
335 the first argument (cwd) or to the current directory if cwd is
339 abspath (rel_filename)
342 /* Setup the current working directory as needed. */
344 = (char *) alloca (strlen (cwd) + strlen (rel_filename) + 1);
345 char *endp = abs_buffer;
349 /* Copy the filename (possibly preceded by the current working
350 directory name) into the absolutization buffer. */
355 if (rel_filename[0] != '/')
358 while (*endp++ = *src_p++)
360 *(endp-1) = '/'; /* overwrite null */
362 src_p = rel_filename;
363 while (*endp++ = *src_p++)
368 /* Now make a copy of abs_buffer into abs_buffer, shortening the
369 filename (by taking out slashes and dots) as we go. */
371 outp = inp = abs_buffer;
372 *outp++ = *inp++; /* copy first slash */
377 else if (inp[0] == '/' && outp[-1] == '/')
382 else if (inp[0] == '.' && outp[-1] == '/')
386 else if (inp[1] == '/')
391 else if ((inp[1] == '.') && (inp[2] == 0 || inp[2] == '/'))
393 inp += (inp[2] == '/') ? 3 : 2;
395 while (outp >= abs_buffer && *outp != '/')
397 if (outp < abs_buffer)
399 /* Catch cases like /.. where we try to backup to a
400 point above the absolute root of the logical file
403 fprintf (stderr, "%s: invalid file name: %s\n",
404 pname, rel_filename);
414 /* On exit, make sure that there is a trailing null, and make sure that
415 the last character of the returned string is *not* a slash. */
421 /* Make a copy (in the heap) of the stuff left in the absolutization
422 buffer and return a pointer to the copy. */
424 value = (char *) oballoc (strlen (abs_buffer) + 1);
425 strcpy (value, abs_buffer);
430 /* At the beginning of compilation, start writing the symbol table.
431 Initialize `typevec' and output the standard data types of C. */
434 dbxout_init (asm_file, input_file_name, syms)
436 char *input_file_name;
439 char ltext_label_name[100];
444 typevec = (struct typeinfo *) xmalloc (typevec_len * sizeof typevec[0]);
445 bzero ((char *) typevec, typevec_len * sizeof typevec[0]);
447 /* Convert Ltext into the appropriate format for local labels in case
448 the system doesn't insert underscores in front of user generated
450 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
452 /* Put the current working directory in an N_SO symbol. */
453 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
454 but GDB always does. */
455 if (use_gnu_debug_info_extensions)
458 if (!cwd && (cwd = getpwd ()) && (!*cwd || cwd[strlen (cwd) - 1] != '/'))
460 char *wdslash = xmalloc (strlen (cwd) + sizeof (FILE_NAME_JOINER));
461 sprintf (wdslash, "%s%s", cwd, FILE_NAME_JOINER);
466 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
467 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd);
468 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
469 fprintf (asmfile, "%s ", ASM_STABS_OP);
470 output_quoted_string (asmfile, cwd);
471 fprintf (asmfile, ",%d,0,0,%s\n", N_SO, <ext_label_name[1]);
472 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
476 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
477 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
478 would give us an N_SOL, and we want an N_SO. */
479 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile, input_file_name);
480 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
481 /* We include outputting `Ltext:' here,
482 because that gives you a way to override it. */
483 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
484 fprintf (asmfile, "%s ", ASM_STABS_OP);
485 output_quoted_string (asmfile, input_file_name);
486 fprintf (asmfile, ",%d,0,0,%s\n",
487 N_SO, <ext_label_name[1]);
489 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Ltext", 0);
490 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
492 /* Possibly output something to inform GDB that this compilation was by
493 GCC. It's easier for GDB to parse it when after the N_SO's. This
494 is used in Solaris 2. */
495 #ifdef ASM_IDENTIFY_GCC_AFTER_SOURCE
496 ASM_IDENTIFY_GCC_AFTER_SOURCE (asmfile);
499 lastfile = input_file_name;
501 next_type_number = 1;
502 next_block_number = 2;
505 current_file = (struct dbx_file *) xmalloc (sizeof *current_file);
506 current_file->next = NULL;
507 current_file->file_number = 0;
508 current_file->next_type_number = 1;
509 next_file_number = 1;
512 /* Make sure that types `int' and `char' have numbers 1 and 2.
513 Definitions of other integer types will refer to those numbers.
514 (Actually it should no longer matter what their numbers are.
515 Also, if any types with tags have been defined, dbxout_symbol
516 will output them first, so the numbers won't be 1 and 2. That
517 happens in C++. So it's a good thing it should no longer matter). */
519 #ifdef DBX_OUTPUT_STANDARD_TYPES
520 DBX_OUTPUT_STANDARD_TYPES (syms);
522 dbxout_symbol (TYPE_NAME (integer_type_node), 0);
523 dbxout_symbol (TYPE_NAME (char_type_node), 0);
526 /* Get all permanent types that have typedef names,
527 and output them all, except for those already output. */
529 dbxout_typedefs (syms);
532 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
533 in the reverse order from that which is found in SYMS. */
536 dbxout_typedefs (syms)
541 dbxout_typedefs (TREE_CHAIN (syms));
542 if (TREE_CODE (syms) == TYPE_DECL)
544 tree type = TREE_TYPE (syms);
546 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
547 && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
548 dbxout_symbol (TYPE_NAME (type), 0);
553 /* Change to reading from a new source file. Generate a N_BINCL stab. */
556 dbxout_start_new_source_file (filename)
560 struct dbx_file *n = (struct dbx_file *) xmalloc (sizeof *n);
562 n->next = current_file;
563 n->file_number = next_file_number++;
564 n->next_type_number = 1;
566 fprintf (asmfile, "%s \"%s\",%d,0,0,0\n", ASM_STABS_OP, filename, N_BINCL);
570 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
573 dbxout_resume_previous_source_file ()
576 struct dbx_file *next;
578 fprintf (asmfile, "%s %d,0,0,0\n", ASM_STABN_OP, N_EINCL);
579 next = current_file->next;
585 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
588 dbxout_source_file (file, filename)
592 char ltext_label_name[100];
594 if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
596 #ifdef DBX_OUTPUT_SOURCE_FILENAME
597 DBX_OUTPUT_SOURCE_FILENAME (file, filename);
599 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext",
600 source_label_number);
601 fprintf (file, "%s ", ASM_STABS_OP);
602 output_quoted_string (file, filename);
603 fprintf (file, ",%d,0,0,%s\n", N_SOL, <ext_label_name[1]);
604 if (current_function_decl != NULL_TREE
605 && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
606 ; /* Don't change section amid function. */
609 ASM_OUTPUT_INTERNAL_LABEL (file, "Ltext", source_label_number);
610 source_label_number++;
616 /* Output a line number symbol entry into output stream FILE,
617 for source file FILENAME and line number LINENO. */
620 dbxout_source_line (file, filename, lineno)
625 dbxout_source_file (file, filename);
627 #ifdef ASM_OUTPUT_SOURCE_LINE
628 ASM_OUTPUT_SOURCE_LINE (file, lineno);
630 fprintf (file, "\t%s %d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno);
634 /* At the end of compilation, finish writing the symbol table.
635 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
639 dbxout_finish (file, filename)
643 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
644 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file, filename);
645 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
648 /* Output the index of a type. */
651 dbxout_type_index (type)
654 #ifndef DBX_USE_BINCL
655 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
658 struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
659 fprintf (asmfile, "(%d,%d)", t->file_number, t->type_number);
664 /* Continue a symbol-description that gets too big.
665 End one symbol table entry with a double-backslash
666 and start a new one, eventually producing something like
667 .stabs "start......\\",code,0,value
668 .stabs "...rest",code,0,value */
673 #ifdef DBX_CONTIN_CHAR
674 fprintf (asmfile, "%c", DBX_CONTIN_CHAR);
676 fprintf (asmfile, "\\\\");
678 dbxout_finish_symbol (NULL_TREE);
679 fprintf (asmfile, "%s \"", ASM_STABS_OP);
680 current_sym_nchars = 0;
683 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
684 This must be a separate function because anonymous unions require
688 dbxout_type_fields (type)
692 /* Output the name, type, position (in bits), size (in bits) of each
694 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
696 /* Omit here local type decls until we know how to support them. */
697 if (TREE_CODE (tem) == TYPE_DECL)
699 /* Omit fields whose position or size are variable. */
700 else if (TREE_CODE (tem) == FIELD_DECL
701 && (TREE_CODE (DECL_FIELD_BITPOS (tem)) != INTEGER_CST
702 || TREE_CODE (DECL_SIZE (tem)) != INTEGER_CST))
704 /* Omit here the nameless fields that are used to skip bits. */
705 else if (TREE_CODE (tem) != CONST_DECL)
707 /* Continue the line if necessary,
708 but not before the first field. */
709 if (tem != TYPE_FIELDS (type))
712 if (use_gnu_debug_info_extensions
713 && flag_minimal_debug
714 && TREE_CODE (tem) == FIELD_DECL
715 && DECL_VIRTUAL_P (tem)
716 && DECL_ASSEMBLER_NAME (tem))
718 have_used_extensions = 1;
719 CHARS (3 + IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (tem)));
720 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem)), asmfile);
721 dbxout_type (DECL_FCONTEXT (tem), 0, 0);
722 fprintf (asmfile, ":");
723 dbxout_type (TREE_TYPE (tem), 0, 0);
724 fprintf (asmfile, ",%d;",
725 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)));
731 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
732 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem)));
736 fprintf (asmfile, ":");
740 if (use_gnu_debug_info_extensions
741 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
742 || TREE_CODE (tem) != FIELD_DECL))
744 have_used_extensions = 1;
746 putc ((TREE_PRIVATE (tem) ? '0'
747 : TREE_PROTECTED (tem) ? '1' : '2'),
752 dbxout_type ((TREE_CODE (tem) == FIELD_DECL
753 && DECL_BIT_FIELD_TYPE (tem))
754 ? DECL_BIT_FIELD_TYPE (tem)
755 : TREE_TYPE (tem), 0, 0);
757 if (TREE_CODE (tem) == VAR_DECL)
759 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
761 char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem));
762 have_used_extensions = 1;
763 fprintf (asmfile, ":%s;", name);
764 CHARS (strlen (name));
768 /* If TEM is non-static, GDB won't understand it. */
769 fprintf (asmfile, ",0,0;");
772 else if (TREE_CODE (DECL_FIELD_BITPOS (tem)) == INTEGER_CST)
774 fprintf (asmfile, ",%d,%d;",
775 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)),
776 TREE_INT_CST_LOW (DECL_SIZE (tem)));
783 /* Subroutine of `dbxout_type_methods'. Output debug info about the
784 method described DECL. DEBUG_NAME is an encoding of the method's
785 type signature. ??? We may be able to do without DEBUG_NAME altogether
789 dbxout_type_method_1 (decl, debug_name)
795 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
797 else /* it's a METHOD_TYPE. */
799 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
800 /* A for normal functions.
801 B for `const' member functions.
802 C for `volatile' member functions.
803 D for `const volatile' member functions. */
804 if (TYPE_READONLY (TREE_TYPE (firstarg)))
806 if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
809 if (DECL_VINDEX (decl))
815 fprintf (asmfile, ":%s;%c%c%c", debug_name,
816 TREE_PRIVATE (decl) ? '0' : TREE_PROTECTED (decl) ? '1' : '2', c1, c2);
817 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)) + 6
818 - (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
819 if (DECL_VINDEX (decl))
821 fprintf (asmfile, "%d;",
822 TREE_INT_CST_LOW (DECL_VINDEX (decl)));
823 dbxout_type (DECL_CONTEXT (decl), 0, 0);
824 fprintf (asmfile, ";");
829 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
833 dbxout_type_methods (type)
836 /* C++: put out the method names and their parameter lists */
837 tree methods = TYPE_METHODS (type);
839 register tree fndecl;
841 char formatted_type_identifier_length[16];
842 register int type_identifier_length;
844 if (methods == NULL_TREE)
847 type_encoding = DECL_NAME (TYPE_NAME (type));
850 /* C++: Template classes break some assumptions made by this code about
851 the class names, constructor names, and encodings for assembler
852 label names. For now, disable output of dbx info for them. */
854 char *ptr = IDENTIFIER_POINTER (type_encoding);
855 /* This should use index. (mrs) */
856 while (*ptr && *ptr != '<') ptr++;
863 #ifdef HAVE_TEMPLATES
864 if (warn_template_debugging)
865 warning ("dbx info for template class methods not yet supported");
873 type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
875 sprintf(formatted_type_identifier_length, "%d", type_identifier_length);
877 if (TREE_CODE (methods) == FUNCTION_DECL)
879 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
880 fndecl = TREE_VEC_ELT (methods, 0);
882 fndecl = TREE_VEC_ELT (methods, 1);
886 tree name = DECL_NAME (fndecl);
889 /* Group together all the methods for the same operation.
890 These differ in the types of the arguments. */
891 for (last = NULL_TREE;
892 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
893 fndecl = TREE_CHAIN (fndecl))
894 /* Output the name of the field (after overloading), as
895 well as the name of the field before overloading, along
896 with its parameter list */
898 /* This is the "mangled" name of the method.
899 It encodes the argument types. */
900 char *debug_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
907 if (DECL_IGNORED_P (fndecl))
910 if (flag_minimal_debug)
912 /* Detect ordinary methods because their mangled names
913 start with the operation name. */
914 if (!strncmp (IDENTIFIER_POINTER (name), debug_name,
915 IDENTIFIER_LENGTH (name)))
917 debug_name += IDENTIFIER_LENGTH (name);
918 if (debug_name[0] == '_' && debug_name[1] == '_')
920 char *method_name = debug_name + 2;
921 char *length_ptr = formatted_type_identifier_length;
922 /* Get past const and volatile qualifiers. */
923 while (*method_name == 'C' || *method_name == 'V')
925 /* Skip digits for length of type_encoding. */
926 while (*method_name == *length_ptr && *length_ptr)
927 length_ptr++, method_name++;
928 if (! strncmp (method_name,
929 IDENTIFIER_POINTER (type_encoding),
930 type_identifier_length))
931 method_name += type_identifier_length;
932 debug_name = method_name;
935 /* Detect constructors by their style of name mangling. */
936 else if (debug_name[0] == '_' && debug_name[1] == '_')
938 char *ctor_name = debug_name + 2;
939 char *length_ptr = formatted_type_identifier_length;
940 while (*ctor_name == 'C' || *ctor_name == 'V')
942 /* Skip digits for length of type_encoding. */
943 while (*ctor_name == *length_ptr && *length_ptr)
944 length_ptr++, ctor_name++;
945 if (!strncmp (IDENTIFIER_POINTER (type_encoding), ctor_name,
946 type_identifier_length))
947 debug_name = ctor_name + type_identifier_length;
949 /* The other alternative is a destructor. */
953 /* Output the operation name just once, for the first method
957 fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
958 CHARS (IDENTIFIER_LENGTH (name) + 2);
963 dbxout_type (TREE_TYPE (fndecl), 0, destructor);
965 dbxout_type_method_1 (fndecl, debug_name);
975 /* Emit a "range" type specification, which has the form:
976 "r<index type>;<lower bound>;<upper bound>;".
977 TYPE is an INTEGER_TYPE. */
980 dbxout_range_type (type)
983 fprintf (asmfile, "r");
984 if (TREE_TYPE (type))
985 dbxout_type (TREE_TYPE (type), 0, 0);
986 else if (TREE_CODE (type) != INTEGER_TYPE)
987 dbxout_type (type, 0, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
990 /* This used to say `r1' and we used to take care
991 to make sure that `int' was type number 1. */
992 dbxout_type_index (integer_type_node);
994 if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
995 fprintf (asmfile, ";%d",
996 TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)));
998 fprintf (asmfile, ";0");
999 if (TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
1000 fprintf (asmfile, ";%d;",
1001 TREE_INT_CST_LOW (TYPE_MAX_VALUE (type)));
1003 fprintf (asmfile, ";-1;");
1006 /* Output a reference to a type. If the type has not yet been
1007 described in the dbx output, output its definition now.
1008 For a type already defined, just refer to its definition
1009 using the type number.
1011 If FULL is nonzero, and the type has been described only with
1012 a forward-reference, output the definition now.
1013 If FULL is zero in this case, just refer to the forward-reference
1014 using the number previously allocated.
1016 If SHOW_ARG_TYPES is nonzero, we output a description of the argument
1017 types for a METHOD_TYPE. */
1020 dbxout_type (type, full, show_arg_types)
1026 static int anonymous_type_number = 0;
1028 /* If there was an input error and we don't really have a type,
1029 avoid crashing and write something that is at least valid
1030 by assuming `int'. */
1031 if (type == error_mark_node)
1032 type = integer_type_node;
1035 type = TYPE_MAIN_VARIANT (type);
1036 if (TYPE_NAME (type)
1037 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1038 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
1042 if (TYPE_SYMTAB_ADDRESS (type) == 0)
1044 /* Type has no dbx number assigned. Assign next available number. */
1045 TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
1047 /* Make sure type vector is long enough to record about this type. */
1049 if (next_type_number == typevec_len)
1052 (struct typeinfo *) xrealloc (typevec,
1053 typevec_len * 2 * sizeof typevec[0]);
1054 bzero ((char *) (typevec + typevec_len),
1055 typevec_len * sizeof typevec[0]);
1059 #ifdef DBX_USE_BINCL
1060 typevec[TYPE_SYMTAB_ADDRESS (type)].file_number =
1061 current_file->file_number;
1062 typevec[TYPE_SYMTAB_ADDRESS (type)].type_number =
1063 current_file->next_type_number++;
1067 /* Output the number of this type, to refer to it. */
1068 dbxout_type_index (type);
1070 #ifdef DBX_TYPE_DEFINED
1071 if (DBX_TYPE_DEFINED (type))
1075 /* If this type's definition has been output or is now being output,
1078 switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
1083 /* If we have already had a cross reference,
1084 and either that's all we want or that's the best we could do,
1085 don't repeat the cross reference.
1086 Sun dbx crashes if we do. */
1087 if (! full || TYPE_SIZE (type) == 0
1088 /* No way in DBX fmt to describe a variable size. */
1089 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1097 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1098 leave the type-number completely undefined rather than output
1099 a cross-reference. If we have already used GNU debug info extensions,
1100 then it is OK to output a cross reference. This is necessary to get
1101 proper C++ debug output. */
1102 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
1103 || TREE_CODE (type) == QUAL_UNION_TYPE
1104 || TREE_CODE (type) == ENUMERAL_TYPE)
1105 && ! use_gnu_debug_info_extensions)
1106 /* We must use the same test here as we use twice below when deciding
1107 whether to emit a cross-reference. */
1108 if ((TYPE_NAME (type) != 0
1109 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1110 && DECL_IGNORED_P (TYPE_NAME (type)))
1112 || TYPE_SIZE (type) == 0
1113 /* No way in DBX fmt to describe a variable size. */
1114 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1116 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1121 /* Output a definition now. */
1123 fprintf (asmfile, "=");
1126 /* Mark it as defined, so that if it is self-referent
1127 we will not get into an infinite recursion of definitions. */
1129 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
1131 switch (TREE_CODE (type))
1135 /* For a void type, just define it as itself; ie, "5=5".
1136 This makes us consider it defined
1137 without saying what it is. The debugger will make it
1138 a void type when the reference is seen, and nothing will
1139 ever override that default. */
1140 dbxout_type_index (type);
1144 if (type == char_type_node && ! TREE_UNSIGNED (type))
1146 /* Output the type `char' as a subrange of itself!
1147 I don't understand this definition, just copied it
1148 from the output of pcc.
1149 This used to use `r2' explicitly and we used to
1150 take care to make sure that `char' was type number 2. */
1151 fprintf (asmfile, "r");
1152 dbxout_type_index (type);
1153 fprintf (asmfile, ";0;127;");
1155 else if (use_gnu_debug_info_extensions
1156 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
1157 || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT))
1159 /* This used to say `r1' and we used to take care
1160 to make sure that `int' was type number 1. */
1161 fprintf (asmfile, "r");
1162 dbxout_type_index (integer_type_node);
1163 fprintf (asmfile, ";");
1164 print_int_cst_octal (TYPE_MIN_VALUE (type));
1165 fprintf (asmfile, ";");
1166 print_int_cst_octal (TYPE_MAX_VALUE (type));
1167 fprintf (asmfile, ";");
1169 else /* Output other integer types as subranges of `int'. */
1170 dbxout_range_type (type);
1175 /* This used to say `r1' and we used to take care
1176 to make sure that `int' was type number 1. */
1177 fprintf (asmfile, "r");
1178 dbxout_type_index (integer_type_node);
1179 fprintf (asmfile, ";%d;0;", int_size_in_bytes (type));
1184 if (use_gnu_debug_info_extensions)
1185 fprintf (asmfile, "@s%d;-20;",
1186 BITS_PER_UNIT * int_size_in_bytes (type));
1189 /* Output the type `char' as a subrange of itself.
1190 That is what pcc seems to do. */
1191 fprintf (asmfile, "r");
1192 dbxout_type_index (char_type_node);
1193 fprintf (asmfile, ";0;%d;", TREE_UNSIGNED (type) ? 255 : 127);
1199 if (use_gnu_debug_info_extensions)
1200 fprintf (asmfile, "@s%d;-16;",
1201 BITS_PER_UNIT * int_size_in_bytes (type));
1202 else /* Define as enumeral type (False, True) */
1203 fprintf (asmfile, "eFalse:0,True:1,;");
1208 putc ('d', asmfile);
1210 dbxout_type (TREE_TYPE (type), 0, 0);
1214 /* Differs from the REAL_TYPE by its new data type number */
1216 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1218 fprintf (asmfile, "r");
1219 dbxout_type_index (type);
1220 fprintf (asmfile, ";%d;0;",
1221 int_size_in_bytes (TREE_TYPE (type)));
1222 CHARS (12); /* The number is probably incorrect here. */
1226 /* Output a complex integer type as a structure,
1227 pending some other way to do it. */
1228 fprintf (asmfile, "s%d", int_size_in_bytes (type));
1230 fprintf (asmfile, "real:");
1232 dbxout_type (TREE_TYPE (type), 0, 0);
1233 fprintf (asmfile, ",%d,%d;",
1234 0, TYPE_PRECISION (TREE_TYPE (type)));
1236 fprintf (asmfile, "imag:");
1238 dbxout_type (TREE_TYPE (type), 0, 0);
1239 fprintf (asmfile, ",%d,%d;;",
1240 TYPE_PRECISION (TREE_TYPE (type)),
1241 TYPE_PRECISION (TREE_TYPE (type)));
1247 if (use_gnu_debug_info_extensions)
1249 have_used_extensions = 1;
1250 fprintf (asmfile, "@s%d;",
1251 BITS_PER_UNIT * int_size_in_bytes (type));
1252 /* Check if a bitstring type, which in Chill is
1253 different from a [power]set. */
1254 if (TYPE_STRING_FLAG (type))
1255 fprintf (asmfile, "@S;");
1257 putc ('S', asmfile);
1259 dbxout_type (TYPE_DOMAIN (type), 0, 0);
1263 /* Output "a" followed by a range type definition
1264 for the index type of the array
1265 followed by a reference to the target-type.
1266 ar1;0;N;M for a C array of type M and size N+1. */
1267 /* Check if a character string type, which in Chill is
1268 different from an array of characters. */
1269 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
1271 have_used_extensions = 1;
1272 fprintf (asmfile, "@S;");
1274 tem = TYPE_DOMAIN (type);
1277 fprintf (asmfile, "ar");
1278 dbxout_type_index (integer_type_node);
1279 fprintf (asmfile, ";0;-1;");
1283 fprintf (asmfile, "a");
1284 dbxout_range_type (tem);
1287 dbxout_type (TREE_TYPE (type), 0, 0);
1292 case QUAL_UNION_TYPE:
1294 int i, n_baseclasses = 0;
1296 if (TYPE_BINFO (type) != 0 && TYPE_BINFO_BASETYPES (type) != 0)
1297 n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
1299 /* Output a structure type. We must use the same test here as we
1300 use in the DBX_NO_XREFS case above. */
1301 if ((TYPE_NAME (type) != 0
1302 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1303 && DECL_IGNORED_P (TYPE_NAME (type)))
1305 || TYPE_SIZE (type) == 0
1306 /* No way in DBX fmt to describe a variable size. */
1307 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1309 /* If the type is just a cross reference, output one
1310 and mark the type as partially described.
1311 If it later becomes defined, we will output
1312 its real definition.
1313 If the type has a name, don't nest its definition within
1314 another type's definition; instead, output an xref
1315 and let the definition come when the name is defined. */
1316 fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
1318 #if 0 /* This assertion is legitimately false in C++. */
1319 /* We shouldn't be outputting a reference to a type before its
1320 definition unless the type has a tag name.
1321 A typedef name without a tag name should be impossible. */
1322 if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
1325 if (TYPE_NAME (type) != 0)
1326 dbxout_type_name (type);
1328 fprintf (asmfile, "$$%d", anonymous_type_number++);
1329 fprintf (asmfile, ":");
1330 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1334 /* Identify record or union, and print its size. */
1335 fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "s%d" : "u%d",
1336 int_size_in_bytes (type));
1338 if (use_gnu_debug_info_extensions)
1342 have_used_extensions = 1;
1343 fprintf (asmfile, "!%d,", n_baseclasses);
1347 for (i = 0; i < n_baseclasses; i++)
1349 tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i);
1350 if (use_gnu_debug_info_extensions)
1352 have_used_extensions = 1;
1353 putc (TREE_VIA_VIRTUAL (child) ? '1'
1356 putc (TREE_VIA_PUBLIC (child) ? '2'
1359 fprintf (asmfile, "%d,",
1360 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT);
1362 dbxout_type (BINFO_TYPE (child), 0, 0);
1363 putc (';', asmfile);
1367 /* Print out the base class information with fields
1368 which have the same names at the types they hold. */
1369 dbxout_type_name (BINFO_TYPE (child));
1370 putc (':', asmfile);
1371 dbxout_type (BINFO_TYPE (child), full, 0);
1372 fprintf (asmfile, ",%d,%d;",
1373 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT,
1374 TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child)))) * BITS_PER_UNIT);
1382 /* Write out the field declarations. */
1383 dbxout_type_fields (type);
1384 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
1386 have_used_extensions = 1;
1387 dbxout_type_methods (type);
1389 putc (';', asmfile);
1391 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
1392 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1393 && TYPE_VFIELD (type))
1395 have_used_extensions = 1;
1397 /* Tell GDB+ that it may keep reading. */
1398 putc ('~', asmfile);
1400 /* We need to write out info about what field this class
1401 uses as its "main" vtable pointer field, because if this
1402 field is inherited from a base class, GDB cannot necessarily
1403 figure out which field it's using in time. */
1404 if (TYPE_VFIELD (type))
1406 putc ('%', asmfile);
1407 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0, 0);
1409 putc (';', asmfile);
1415 /* We must use the same test here as we use in the DBX_NO_XREFS case
1416 above. We simplify it a bit since an enum will never have a variable
1418 if ((TYPE_NAME (type) != 0
1419 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1420 && DECL_IGNORED_P (TYPE_NAME (type)))
1422 || TYPE_SIZE (type) == 0)
1424 fprintf (asmfile, "xe");
1426 dbxout_type_name (type);
1427 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1428 fprintf (asmfile, ":");
1431 #ifdef DBX_OUTPUT_ENUM
1432 DBX_OUTPUT_ENUM (asmfile, type);
1434 if (use_gnu_debug_info_extensions
1435 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1436 fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1437 putc ('e', asmfile);
1439 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
1441 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1442 if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
1443 fprintf (asmfile, "%lu",
1444 (unsigned long) TREE_INT_CST_LOW (TREE_VALUE (tem)));
1445 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
1446 && TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
1447 fprintf (asmfile, "%ld",
1448 (long) TREE_INT_CST_LOW (TREE_VALUE (tem)));
1450 print_int_cst_octal (TREE_VALUE (tem));
1451 fprintf (asmfile, ",");
1452 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem)));
1453 if (TREE_CHAIN (tem) != 0)
1456 putc (';', asmfile);
1462 putc ('*', asmfile);
1464 dbxout_type (TREE_TYPE (type), 0, 0);
1468 if (use_gnu_debug_info_extensions)
1470 have_used_extensions = 1;
1471 putc ('#', asmfile);
1473 if (flag_minimal_debug && !show_arg_types)
1475 /* Normally, just output the return type.
1476 The argument types are encoded in the method name. */
1477 putc ('#', asmfile);
1478 dbxout_type (TREE_TYPE (type), 0, 0);
1479 putc (';', asmfile);
1484 /* When outputting destructors, we need to write
1485 the argument types out longhand. */
1486 dbxout_type (TYPE_METHOD_BASETYPE (type), 0, 0);
1487 putc (',', asmfile);
1489 dbxout_type (TREE_TYPE (type), 0, 0);
1490 dbxout_args (TYPE_ARG_TYPES (type));
1491 putc (';', asmfile);
1497 /* Treat it as a function type. */
1498 dbxout_type (TREE_TYPE (type), 0, 0);
1503 if (use_gnu_debug_info_extensions)
1505 have_used_extensions = 1;
1506 putc ('@', asmfile);
1508 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0, 0);
1509 putc (',', asmfile);
1511 dbxout_type (TREE_TYPE (type), 0, 0);
1515 /* Should print as an int, because it is really
1517 dbxout_type (integer_type_node, 0, 0);
1521 case REFERENCE_TYPE:
1522 if (use_gnu_debug_info_extensions)
1523 have_used_extensions = 1;
1524 putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
1526 dbxout_type (TREE_TYPE (type), 0, 0);
1530 putc ('f', asmfile);
1532 dbxout_type (TREE_TYPE (type), 0, 0);
1540 /* Print the value of integer constant C, in octal,
1541 handling double precision. */
1544 print_int_cst_octal (c)
1547 unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
1548 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
1549 int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
1550 int width = TYPE_PRECISION (TREE_TYPE (c));
1552 /* GDB wants constants with no extra leading "1" bits, so
1553 we need to remove any sign-extension that might be
1555 if (width == HOST_BITS_PER_WIDE_INT * 2)
1557 else if (width > HOST_BITS_PER_WIDE_INT)
1558 high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
1559 else if (width == HOST_BITS_PER_WIDE_INT)
1562 high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
1564 fprintf (asmfile, "0");
1568 print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
1569 print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
1573 unsigned HOST_WIDE_INT beg = high >> excess;
1574 unsigned HOST_WIDE_INT middle
1575 = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
1576 | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
1577 unsigned HOST_WIDE_INT end
1578 = low & (((unsigned HOST_WIDE_INT) 1
1579 << (HOST_BITS_PER_WIDE_INT / 3 * 3))
1582 fprintf (asmfile, "%o%01o", beg, middle);
1583 print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
1588 print_octal (value, digits)
1589 unsigned HOST_WIDE_INT value;
1594 for (i = digits - 1; i >= 0; i--)
1595 fprintf (asmfile, "%01o", ((value >> (3 * i)) & 7));
1598 /* Output the name of type TYPE, with no punctuation.
1599 Such names can be set up either by typedef declarations
1600 or by struct, enum and union tags. */
1603 dbxout_type_name (type)
1607 if (TYPE_NAME (type) == 0)
1609 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
1611 t = TYPE_NAME (type);
1613 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1615 t = DECL_NAME (TYPE_NAME (type));
1620 fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
1621 CHARS (IDENTIFIER_LENGTH (t));
1624 /* Output a .stabs for the symbol defined by DECL,
1625 which must be a ..._DECL node in the normal namespace.
1626 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1627 LOCAL is nonzero if the scope is less than the entire file. */
1630 dbxout_symbol (decl, local)
1634 tree type = TREE_TYPE (decl);
1635 tree context = NULL_TREE;
1637 /* Cast avoids warning in old compilers. */
1638 current_sym_code = (STAB_CODE_TYPE) 0;
1639 current_sym_value = 0;
1640 current_sym_addr = 0;
1642 /* Ignore nameless syms, but don't ignore type tags. */
1644 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
1645 || DECL_IGNORED_P (decl))
1648 dbxout_prepare_symbol (decl);
1650 /* The output will always start with the symbol name,
1651 so always count that in the length-output-so-far. */
1653 if (DECL_NAME (decl) != 0)
1654 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
1656 switch (TREE_CODE (decl))
1659 /* Enum values are defined by defining the enum type. */
1663 if (DECL_RTL (decl) == 0)
1665 if (DECL_EXTERNAL (decl))
1667 /* Don't mention a nested function under its parent. */
1668 context = decl_function_context (decl);
1669 if (context == current_function_decl)
1671 if (GET_CODE (DECL_RTL (decl)) != MEM
1672 || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
1676 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
1677 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1678 TREE_PUBLIC (decl) ? 'F' : 'f');
1680 current_sym_code = N_FUN;
1681 current_sym_addr = XEXP (DECL_RTL (decl), 0);
1683 if (TREE_TYPE (type))
1684 dbxout_type (TREE_TYPE (type), 0, 0);
1686 dbxout_type (void_type_node, 0, 0);
1688 /* For a nested function, when that function is compiled,
1689 mention the containing function name
1690 as well as (since dbx wants it) our own assembler-name. */
1692 fprintf (asmfile, ",%s,%s",
1693 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1694 IDENTIFIER_POINTER (DECL_NAME (context)));
1696 dbxout_finish_symbol (decl);
1701 /* This seems all wrong. Outputting most kinds of types gives no name
1702 at all. A true definition gives no name; a cross-ref for a
1703 structure can give the tag name, but not a type name.
1704 It seems that no typedef name is defined by outputting a type. */
1706 /* If this typedef name was defined by outputting the type,
1707 don't duplicate it. */
1708 if (typevec[TYPE_SYMTAB_ADDRESS (type)].status == TYPE_DEFINED
1709 && TYPE_NAME (TREE_TYPE (decl)) == decl)
1712 /* Don't output the same typedef twice.
1713 And don't output what language-specific stuff doesn't want output. */
1714 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
1723 if (DECL_NAME (decl))
1725 /* Nonzero means we must output a tag as well as a typedef. */
1728 /* Handle the case of a C++ structure or union
1729 where the TYPE_NAME is a TYPE_DECL
1730 which gives both a typedef name and a tag. */
1731 /* dbx requires the tag first and the typedef second. */
1732 if ((TREE_CODE (type) == RECORD_TYPE
1733 || TREE_CODE (type) == UNION_TYPE
1734 || TREE_CODE (type) == QUAL_UNION_TYPE)
1735 && TYPE_NAME (type) == decl
1736 && !(use_gnu_debug_info_extensions && have_used_extensions)
1737 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
1738 /* Distinguish the implicit typedefs of C++
1739 from explicit ones that might be found in C. */
1740 && (!strcmp (lang_identify (), "cplusplus")
1741 /* The following line maybe unnecessary;
1742 in 2.6, try removing it. */
1743 || DECL_SOURCE_LINE (decl) == 0))
1745 tree name = TYPE_NAME (type);
1746 if (TREE_CODE (name) == TYPE_DECL)
1747 name = DECL_NAME (name);
1749 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1750 current_sym_value = 0;
1751 current_sym_addr = 0;
1752 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1754 fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP,
1755 IDENTIFIER_POINTER (name));
1756 dbxout_type (type, 1, 0);
1757 dbxout_finish_symbol (NULL_TREE);
1760 /* Output typedef name. */
1761 fprintf (asmfile, "%s \"%s:", ASM_STABS_OP,
1762 IDENTIFIER_POINTER (DECL_NAME (decl)));
1764 /* Short cut way to output a tag also. */
1765 if ((TREE_CODE (type) == RECORD_TYPE
1766 || TREE_CODE (type) == UNION_TYPE
1767 || TREE_CODE (type) == QUAL_UNION_TYPE)
1768 && TYPE_NAME (type) == decl)
1770 if (use_gnu_debug_info_extensions && have_used_extensions)
1772 putc ('T', asmfile);
1773 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
1775 #if 0 /* Now we generate the tag for this case up above. */
1781 putc ('t', asmfile);
1782 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1784 dbxout_type (type, 1, 0);
1785 dbxout_finish_symbol (decl);
1789 /* Don't output a tag if this is an incomplete type (TYPE_SIZE is
1790 zero). This prevents the sun4 Sun OS 4.x dbx from crashing. */
1792 if (tag_needed && TYPE_NAME (type) != 0
1793 && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
1794 || (DECL_NAME (TYPE_NAME (type)) != 0))
1795 && TYPE_SIZE (type) != 0
1796 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
1798 /* For a TYPE_DECL with no name, but the type has a name,
1800 This is what represents `struct foo' with no typedef. */
1801 /* In C++, the name of a type is the corresponding typedef.
1802 In C, it is an IDENTIFIER_NODE. */
1803 tree name = TYPE_NAME (type);
1804 if (TREE_CODE (name) == TYPE_DECL)
1805 name = DECL_NAME (name);
1807 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1808 current_sym_value = 0;
1809 current_sym_addr = 0;
1810 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1812 fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP,
1813 IDENTIFIER_POINTER (name));
1814 dbxout_type (type, 1, 0);
1815 dbxout_finish_symbol (NULL_TREE);
1819 /* If an enum type has no name, it cannot be referred to,
1820 but we must output it anyway, since the enumeration constants
1821 can be referred to. */
1822 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
1824 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1825 current_sym_value = 0;
1826 current_sym_addr = 0;
1827 current_sym_nchars = 2;
1829 /* Some debuggers fail when given NULL names, so give this a
1830 harmless name of ` '. */
1831 fprintf (asmfile, "%s \" :T", ASM_STABS_OP);
1832 dbxout_type (type, 1, 0);
1833 dbxout_finish_symbol (NULL_TREE);
1836 /* Prevent duplicate output of a typedef. */
1837 TREE_ASM_WRITTEN (decl) = 1;
1842 /* Parm decls go in their own separate chains
1843 and are output by dbxout_reg_parms and dbxout_parms. */
1847 /* Named return value, treat like a VAR_DECL. */
1849 if (DECL_RTL (decl) == 0)
1851 /* Don't mention a variable that is external.
1852 Let the file that defines it describe it. */
1853 if (DECL_EXTERNAL (decl))
1856 /* If the variable is really a constant
1857 and not written in memory, inform the debugger. */
1858 if (TREE_STATIC (decl) && TREE_READONLY (decl)
1859 && DECL_INITIAL (decl) != 0
1860 && ! TREE_ASM_WRITTEN (decl)
1861 && (DECL_FIELD_CONTEXT (decl) == NULL_TREE
1862 || TREE_CODE (DECL_FIELD_CONTEXT (decl)) == BLOCK))
1864 if (TREE_PUBLIC (decl) == 0)
1866 /* The sun4 assembler does not grok this. */
1867 char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1868 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
1869 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
1871 HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl));
1872 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1873 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile, name, ival);
1875 fprintf (asmfile, "%s \"%s:c=i%d\",0x%x,0,0,0\n",
1876 ASM_STABS_OP, name, ival, N_LSYM);
1880 else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
1882 /* don't know how to do this yet. */
1886 /* else it is something we handle like a normal variable. */
1889 DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, NULL_RTX);
1890 #ifdef LEAF_REG_REMAP
1892 leaf_renumber_regs_insn (DECL_RTL (decl));
1895 dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
1899 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1900 Add SUFFIX to its name, if SUFFIX is not 0.
1901 Describe the variable as residing in HOME
1902 (usually HOME is DECL_RTL (DECL), but not always). */
1905 dbxout_symbol_location (decl, type, suffix, home)
1913 /* Don't mention a variable at all
1914 if it was completely optimized into nothingness.
1916 If the decl was from an inline function, then it's rtl
1917 is not identically the rtl that was used in this
1918 particular compilation. */
1919 if (GET_CODE (home) == REG)
1921 regno = REGNO (home);
1922 if (regno >= FIRST_PSEUDO_REGISTER)
1925 else if (GET_CODE (home) == SUBREG)
1929 while (GET_CODE (value) == SUBREG)
1931 offset += SUBREG_WORD (value);
1932 value = SUBREG_REG (value);
1934 if (GET_CODE (value) == REG)
1936 regno = REGNO (value);
1937 if (regno >= FIRST_PSEUDO_REGISTER)
1941 alter_subreg (home);
1944 /* The kind-of-variable letter depends on where
1945 the variable is and on the scope of its name:
1946 G and N_GSYM for static storage and global scope,
1947 S for static storage and file scope,
1948 V for static storage and local scope,
1949 for those two, use N_LCSYM if data is in bss segment,
1950 N_STSYM if in data segment, N_FUN otherwise.
1951 (We used N_FUN originally, then changed to N_STSYM
1952 to please GDB. However, it seems that confused ld.
1953 Now GDB has been fixed to like N_FUN, says Kingdon.)
1954 no letter at all, and N_LSYM, for auto variable,
1955 r and N_RSYM for register variable. */
1957 if (GET_CODE (home) == MEM
1958 && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
1960 if (TREE_PUBLIC (decl))
1963 current_sym_code = N_GSYM;
1967 current_sym_addr = XEXP (home, 0);
1969 letter = decl_function_context (decl) ? 'V' : 'S';
1971 /* This should be the same condition as in assemble_variable, but
1972 we don't have access to dont_output_data here. So, instead,
1973 we rely on the fact that error_mark_node initializers always
1974 end up in bss for C++ and never end up in bss for C. */
1975 if (DECL_INITIAL (decl) == 0
1976 || (!strcmp (lang_identify (), "cplusplus")
1977 && DECL_INITIAL (decl) == error_mark_node))
1978 current_sym_code = N_LCSYM;
1979 else if (DECL_IN_TEXT_SECTION (decl))
1980 /* This is not quite right, but it's the closest
1981 of all the codes that Unix defines. */
1982 current_sym_code = DBX_STATIC_CONST_VAR_CODE;
1985 /* Ultrix `as' seems to need this. */
1986 #ifdef DBX_STATIC_STAB_DATA_SECTION
1989 current_sym_code = N_STSYM;
1993 else if (regno >= 0)
1996 current_sym_code = N_RSYM;
1997 current_sym_value = DBX_REGISTER_NUMBER (regno);
1999 else if (GET_CODE (home) == MEM
2000 && (GET_CODE (XEXP (home, 0)) == MEM
2001 || (GET_CODE (XEXP (home, 0)) == REG
2002 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM)))
2003 /* If the value is indirect by memory or by a register
2004 that isn't the frame pointer
2005 then it means the object is variable-sized and address through
2006 that register or stack slot. DBX has no way to represent this
2007 so all we can do is output the variable as a pointer.
2008 If it's not a parameter, ignore it.
2009 (VAR_DECLs like this can be made by integrate.c.) */
2011 if (GET_CODE (XEXP (home, 0)) == REG)
2014 current_sym_code = N_RSYM;
2015 current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
2019 current_sym_code = N_LSYM;
2020 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2021 We want the value of that CONST_INT. */
2023 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
2026 /* Effectively do build_pointer_type, but don't cache this type,
2027 since it might be temporary whereas the type it points to
2028 might have been saved for inlining. */
2029 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2030 type = make_node (POINTER_TYPE);
2031 TREE_TYPE (type) = TREE_TYPE (decl);
2033 else if (GET_CODE (home) == MEM
2034 && GET_CODE (XEXP (home, 0)) == REG)
2036 current_sym_code = N_LSYM;
2037 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2039 else if (GET_CODE (home) == MEM
2040 && GET_CODE (XEXP (home, 0)) == PLUS
2041 && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
2043 current_sym_code = N_LSYM;
2044 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2045 We want the value of that CONST_INT. */
2046 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2048 else if (GET_CODE (home) == MEM
2049 && GET_CODE (XEXP (home, 0)) == CONST)
2051 /* Handle an obscure case which can arise when optimizing and
2052 when there are few available registers. (This is *always*
2053 the case for i386/i486 targets). The RTL looks like
2054 (MEM (CONST ...)) even though this variable is a local `auto'
2055 or a local `register' variable. In effect, what has happened
2056 is that the reload pass has seen that all assignments and
2057 references for one such a local variable can be replaced by
2058 equivalent assignments and references to some static storage
2059 variable, thereby avoiding the need for a register. In such
2060 cases we're forced to lie to debuggers and tell them that
2061 this variable was itself `static'. */
2062 current_sym_code = N_LCSYM;
2064 current_sym_addr = XEXP (XEXP (home, 0), 0);
2066 else if (GET_CODE (home) == CONCAT)
2068 tree subtype = TREE_TYPE (type);
2070 /* If the variable's storage is in two parts,
2071 output each as a separate stab with a modified name. */
2072 if (WORDS_BIG_ENDIAN)
2073 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
2075 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
2077 /* Cast avoids warning in old compilers. */
2078 current_sym_code = (STAB_CODE_TYPE) 0;
2079 current_sym_value = 0;
2080 current_sym_addr = 0;
2081 dbxout_prepare_symbol (decl);
2083 if (WORDS_BIG_ENDIAN)
2084 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
2086 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
2090 /* Address might be a MEM, when DECL is a variable-sized object.
2091 Or it might be const0_rtx, meaning previous passes
2092 want us to ignore this variable. */
2095 /* Ok, start a symtab entry and output the variable name. */
2098 #ifdef DBX_STATIC_BLOCK_START
2099 DBX_STATIC_BLOCK_START (asmfile, current_sym_code);
2102 dbxout_symbol_name (decl, suffix, letter);
2103 dbxout_type (type, 0, 0);
2104 dbxout_finish_symbol (decl);
2106 #ifdef DBX_STATIC_BLOCK_END
2107 DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
2111 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2112 Then output LETTER to indicate the kind of location the symbol has. */
2115 dbxout_symbol_name (decl, suffix, letter)
2120 /* One slight hitch: if this is a VAR_DECL which is a static
2121 class member, we must put out the mangled name instead of the
2122 DECL_NAME. Note also that static member (variable) names DO NOT begin
2123 with underscores in .stabs directives. */
2124 char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2127 fprintf (asmfile, "%s \"%s%s:", ASM_STABS_OP, name,
2128 (suffix ? suffix : ""));
2130 if (letter) putc (letter, asmfile);
2134 dbxout_prepare_symbol (decl)
2138 char *filename = DECL_SOURCE_FILE (decl);
2140 dbxout_source_file (asmfile, filename);
2145 dbxout_finish_symbol (sym)
2148 #ifdef DBX_FINISH_SYMBOL
2149 DBX_FINISH_SYMBOL (sym);
2152 if (use_gnu_debug_info_extensions && sym != 0)
2153 line = DECL_SOURCE_LINE (sym);
2155 fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line);
2156 if (current_sym_addr)
2157 output_addr_const (asmfile, current_sym_addr);
2159 fprintf (asmfile, "%d", current_sym_value);
2160 putc ('\n', asmfile);
2164 /* Output definitions of all the decls in a chain. */
2172 dbxout_symbol (syms, 1);
2173 syms = TREE_CHAIN (syms);
2177 /* The following two functions output definitions of function parameters.
2178 Each parameter gets a definition locating it in the parameter list.
2179 Each parameter that is a register variable gets a second definition
2180 locating it in the register.
2182 Printing or argument lists in gdb uses the definitions that
2183 locate in the parameter list. But reference to the variable in
2184 expressions uses preferentially the definition as a register. */
2186 /* Output definitions, referring to storage in the parmlist,
2187 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2190 dbxout_parms (parms)
2193 for (; parms; parms = TREE_CHAIN (parms))
2194 if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node)
2196 dbxout_prepare_symbol (parms);
2198 /* Perform any necessary register eliminations on the parameter's rtl,
2199 so that the debugging output will be accurate. */
2200 DECL_INCOMING_RTL (parms)
2201 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
2202 DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX);
2203 #ifdef LEAF_REG_REMAP
2206 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
2207 leaf_renumber_regs_insn (DECL_RTL (parms));
2211 if (PARM_PASSED_IN_MEMORY (parms))
2213 rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
2215 /* ??? Here we assume that the parm address is indexed
2216 off the frame pointer or arg pointer.
2217 If that is not true, we produce meaningless results,
2218 but do not crash. */
2219 if (GET_CODE (addr) == PLUS
2220 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
2221 current_sym_value = INTVAL (XEXP (addr, 1));
2223 current_sym_value = 0;
2225 current_sym_code = N_PSYM;
2226 current_sym_addr = 0;
2229 if (DECL_NAME (parms))
2231 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2233 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2234 IDENTIFIER_POINTER (DECL_NAME (parms)),
2235 DBX_MEMPARM_STABS_LETTER);
2239 current_sym_nchars = 8;
2240 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2241 DBX_MEMPARM_STABS_LETTER);
2244 dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
2245 current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
2246 dbxout_finish_symbol (parms);
2248 else if (GET_CODE (DECL_RTL (parms)) == REG)
2251 char regparm_letter;
2253 /* Parm passed in registers and lives in registers or nowhere. */
2255 current_sym_code = DBX_REGPARM_STABS_CODE;
2256 regparm_letter = DBX_REGPARM_STABS_LETTER;
2257 current_sym_addr = 0;
2259 /* If parm lives in a register, use that register;
2260 pretend the parm was passed there. It would be more consistent
2261 to describe the register where the parm was passed,
2262 but in practice that register usually holds something else.
2264 If we use DECL_RTL, then we must use the declared type of
2265 the variable, not the type that it arrived in. */
2266 if (REGNO (DECL_RTL (parms)) >= 0
2267 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2269 best_rtl = DECL_RTL (parms);
2270 parm_type = TREE_TYPE (parms);
2272 /* If the parm lives nowhere, use the register where it was
2273 passed. It is also better to use the declared type here. */
2276 best_rtl = DECL_INCOMING_RTL (parms);
2277 parm_type = TREE_TYPE (parms);
2279 current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
2282 if (DECL_NAME (parms))
2284 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2285 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2286 IDENTIFIER_POINTER (DECL_NAME (parms)),
2291 current_sym_nchars = 8;
2292 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2296 dbxout_type (parm_type, 0, 0);
2297 dbxout_finish_symbol (parms);
2299 else if (GET_CODE (DECL_RTL (parms)) == MEM
2300 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2301 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
2302 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
2303 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2304 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
2308 /* Parm was passed via invisible reference.
2309 That is, its address was passed in a register.
2310 Output it as if it lived in that register.
2311 The debugger will know from the type
2312 that it was actually passed by invisible reference. */
2314 char regparm_letter;
2315 /* Parm passed in registers and lives in registers or nowhere. */
2317 current_sym_code = DBX_REGPARM_STABS_CODE;
2318 if (use_gnu_debug_info_extensions)
2319 regparm_letter = GDB_INV_REF_REGPARM_STABS_LETTER;
2321 regparm_letter = DBX_REGPARM_STABS_LETTER;
2323 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2324 If it is an unallocated pseudo-reg, then use the register where
2325 it was passed instead. */
2326 if (REGNO (XEXP (DECL_RTL (parms), 0)) >= 0
2327 && REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
2328 current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2330 current_sym_value = REGNO (DECL_INCOMING_RTL (parms));
2332 current_sym_addr = 0;
2335 if (DECL_NAME (parms))
2337 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2339 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2340 IDENTIFIER_POINTER (DECL_NAME (parms)),
2345 current_sym_nchars = 8;
2346 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2350 dbxout_type (TREE_TYPE (parms), 0, 0);
2351 dbxout_finish_symbol (parms);
2353 else if (GET_CODE (DECL_RTL (parms)) == MEM
2354 && XEXP (DECL_RTL (parms), 0) != const0_rtx
2355 /* ??? A constant address for a parm can happen
2356 when the reg it lives in is equiv to a constant in memory.
2357 Should make this not happen, after 2.4. */
2358 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
2360 /* Parm was passed in registers but lives on the stack. */
2362 current_sym_code = N_PSYM;
2363 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2364 in which case we want the value of that CONST_INT,
2365 or (MEM (REG ...)) or (MEM (MEM ...)),
2366 in which case we use a value of zero. */
2367 if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2368 || GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
2369 current_sym_value = 0;
2371 current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
2372 current_sym_addr = 0;
2375 if (DECL_NAME (parms))
2377 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2379 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2380 IDENTIFIER_POINTER (DECL_NAME (parms)),
2381 DBX_MEMPARM_STABS_LETTER);
2385 current_sym_nchars = 8;
2386 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2387 DBX_MEMPARM_STABS_LETTER);
2391 = DEBUGGER_ARG_OFFSET (current_sym_value,
2392 XEXP (DECL_RTL (parms), 0));
2393 dbxout_type (TREE_TYPE (parms), 0, 0);
2394 dbxout_finish_symbol (parms);
2399 /* Output definitions for the places where parms live during the function,
2400 when different from where they were passed, when the parms were passed
2403 It is not useful to do this for parms passed in registers
2404 that live during the function in different registers, because it is
2405 impossible to look in the passed register for the passed value,
2406 so we use the within-the-function register to begin with.
2408 PARMS is a chain of PARM_DECL nodes. */
2411 dbxout_reg_parms (parms)
2414 for (; parms; parms = TREE_CHAIN (parms))
2415 if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
2417 dbxout_prepare_symbol (parms);
2419 /* Report parms that live in registers during the function
2420 but were passed in memory. */
2421 if (GET_CODE (DECL_RTL (parms)) == REG
2422 && REGNO (DECL_RTL (parms)) >= 0
2423 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2424 dbxout_symbol_location (parms, TREE_TYPE (parms),
2425 0, DECL_RTL (parms));
2426 else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
2427 dbxout_symbol_location (parms, TREE_TYPE (parms),
2428 0, DECL_RTL (parms));
2429 /* Report parms that live in memory but not where they were passed. */
2430 else if (GET_CODE (DECL_RTL (parms)) == MEM
2431 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
2432 dbxout_symbol_location (parms, TREE_TYPE (parms),
2433 0, DECL_RTL (parms));
2437 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2438 output definitions of those names, in raw form */
2446 putc (',', asmfile);
2447 dbxout_type (TREE_VALUE (args), 0, 0);
2449 args = TREE_CHAIN (args);
2453 /* Given a chain of ..._TYPE nodes,
2454 find those which have typedef names and output those names.
2455 This is to ensure those types get output. */
2458 dbxout_types (types)
2459 register tree types;
2463 if (TYPE_NAME (types)
2464 && TREE_CODE (TYPE_NAME (types)) == TYPE_DECL
2465 && ! TREE_ASM_WRITTEN (TYPE_NAME (types)))
2466 dbxout_symbol (TYPE_NAME (types), 1);
2467 types = TREE_CHAIN (types);
2471 /* Output everything about a symbol block (a BLOCK node
2472 that represents a scope level),
2473 including recursive output of contained blocks.
2475 BLOCK is the BLOCK node.
2476 DEPTH is its depth within containing symbol blocks.
2477 ARGS is usually zero; but for the outermost block of the
2478 body of a function, it is a chain of PARM_DECLs for the function parameters.
2479 We output definitions of all the register parms
2480 as if they were local variables of that block.
2482 If -g1 was used, we count blocks just the same, but output nothing
2483 except for the outermost block.
2485 Actually, BLOCK may be several blocks chained together.
2486 We handle them all in sequence. */
2489 dbxout_block (block, depth, args)
2490 register tree block;
2498 /* Ignore blocks never expanded or otherwise marked as real. */
2499 if (TREE_USED (block))
2501 #ifndef DBX_LBRAC_FIRST
2502 /* In dbx format, the syms of a block come before the N_LBRAC. */
2503 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2504 dbxout_syms (BLOCK_VARS (block));
2506 dbxout_reg_parms (args);
2509 /* Now output an N_LBRAC symbol to represent the beginning of
2510 the block. Use the block's tree-walk order to generate
2511 the assembler symbols LBBn and LBEn
2512 that final will define around the code in this block. */
2513 if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE)
2516 blocknum = next_block_number++;
2517 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
2519 if (BLOCK_HANDLER_BLOCK (block))
2521 /* A catch block. Must precede N_LBRAC. */
2522 tree decl = BLOCK_VARS (block);
2525 #ifdef DBX_OUTPUT_CATCH
2526 DBX_OUTPUT_CATCH (asmfile, decl, buf);
2528 fprintf (asmfile, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP,
2529 IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
2530 assemble_name (asmfile, buf);
2531 fprintf (asmfile, "\n");
2533 decl = TREE_CHAIN (decl);
2537 #ifdef DBX_OUTPUT_LBRAC
2538 DBX_OUTPUT_LBRAC (asmfile, buf);
2540 fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_LBRAC);
2541 assemble_name (asmfile, buf);
2542 #if DBX_BLOCKS_FUNCTION_RELATIVE
2543 fputc ('-', asmfile);
2544 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
2546 fprintf (asmfile, "\n");
2550 /* Count blocks the same way regardless of debug_info_level. */
2551 next_block_number++;
2553 #ifdef DBX_LBRAC_FIRST
2554 /* On some weird machines, the syms of a block
2555 come after the N_LBRAC. */
2556 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2557 dbxout_syms (BLOCK_VARS (block));
2559 dbxout_reg_parms (args);
2562 /* Output the subblocks. */
2563 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
2565 /* Refer to the marker for the end of the block. */
2566 if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE)
2569 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
2570 #ifdef DBX_OUTPUT_RBRAC
2571 DBX_OUTPUT_RBRAC (asmfile, buf);
2573 fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_RBRAC);
2574 assemble_name (asmfile, buf);
2575 #if DBX_BLOCKS_FUNCTION_RELATIVE
2576 fputc ('-', asmfile);
2577 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
2579 fprintf (asmfile, "\n");
2583 block = BLOCK_CHAIN (block);
2587 /* Output the information about a function and its arguments and result.
2588 Usually this follows the function's code,
2589 but on some systems, it comes before. */
2592 dbxout_really_begin_function (decl)
2595 dbxout_symbol (decl, 0);
2596 dbxout_parms (DECL_ARGUMENTS (decl));
2597 if (DECL_NAME (DECL_RESULT (decl)) != 0)
2598 dbxout_symbol (DECL_RESULT (decl), 1);
2601 /* Called at beginning of output of function definition. */
2604 dbxout_begin_function (decl)
2607 #ifdef DBX_FUNCTION_FIRST
2608 dbxout_really_begin_function (decl);
2612 /* Output dbx data for a function definition.
2613 This includes a definition of the function name itself (a symbol),
2614 definitions of the parameters (locating them in the parameter list)
2615 and then output the block that makes up the function's body
2616 (including all the auto variables of the function). */
2619 dbxout_function (decl)
2622 #ifndef DBX_FUNCTION_FIRST
2623 dbxout_really_begin_function (decl);
2625 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
2626 #ifdef DBX_OUTPUT_FUNCTION_END
2627 DBX_OUTPUT_FUNCTION_END (asmfile, decl);
2630 #endif /* DBX_DEBUGGING_INFO */