1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987, 88, 92-97, 1998 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'. */
77 #include "insn-config.h"
80 #include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions. */
82 #ifdef XCOFF_DEBUGGING_INFO
87 #define ASM_STABS_OP ".stabs"
91 #define ASM_STABN_OP ".stabn"
94 #ifndef DBX_TYPE_DECL_STABS_CODE
95 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
98 #ifndef DBX_STATIC_CONST_VAR_CODE
99 #define DBX_STATIC_CONST_VAR_CODE N_FUN
102 #ifndef DBX_REGPARM_STABS_CODE
103 #define DBX_REGPARM_STABS_CODE N_RSYM
106 #ifndef DBX_REGPARM_STABS_LETTER
107 #define DBX_REGPARM_STABS_LETTER 'P'
110 /* This is used for parameters passed by invisible reference in a register. */
111 #ifndef GDB_INV_REF_REGPARM_STABS_LETTER
112 #define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
115 #ifndef DBX_MEMPARM_STABS_LETTER
116 #define DBX_MEMPARM_STABS_LETTER 'p'
119 #ifndef FILE_NAME_JOINER
120 #define FILE_NAME_JOINER "/"
123 /* Nonzero means if the type has methods, only output debugging
124 information if methods are actually written to the asm file. This
125 optimization only works if the debugger can detect the special C++
128 #define MINIMAL_DEBUG 1
130 #ifdef NO_DOLLAR_IN_LABEL
131 #ifdef NO_DOT_IN_LABEL
133 #define MINIMAL_DEBUG 0
137 static int flag_minimal_debug = MINIMAL_DEBUG;
139 /* Nonzero if we have actually used any of the GDB extensions
140 to the debugging format. The idea is that we use them for the
141 first time only if there's a strong reason, but once we have done that,
142 we use them whenever convenient. */
144 static int have_used_extensions = 0;
146 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
147 for the N_SO filename stabs label. */
149 static int source_label_number = 1;
153 /* Typical USG systems don't have stab.h, and they also have
154 no use for DBX-format debugging info. */
156 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
158 #ifdef DEBUG_SYMS_TEXT
159 #define FORCE_TEXT text_section ();
164 #if defined (USG) || defined (NO_STAB_H) || defined (CROSS_COMPILE)
165 #include "gstab.h" /* If doing DBX on sysV, use our own stab.h. */
167 #include <stab.h> /* On BSD, use the system's stab.h. */
169 /* This is a GNU extension we need to reference in this file. */
176 #define STAB_CODE_TYPE enum __stab_debug_code
178 #define STAB_CODE_TYPE int
181 /* 1 if PARM is passed to this function in memory. */
183 #define PARM_PASSED_IN_MEMORY(PARM) \
184 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
186 /* A C expression for the integer offset value of an automatic variable
187 (N_LSYM) having address X (an RTX). */
188 #ifndef DEBUGGER_AUTO_OFFSET
189 #define DEBUGGER_AUTO_OFFSET(X) \
190 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
193 /* A C expression for the integer offset value of an argument (N_PSYM)
194 having address X (an RTX). The nominal offset is OFFSET. */
195 #ifndef DEBUGGER_ARG_OFFSET
196 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
199 /* Stream for writing to assembler file. */
201 static FILE *asmfile;
203 /* Last source file name mentioned in a NOTE insn. */
205 static char *lastfile;
207 /* Current working directory. */
211 enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
213 /* Structure recording information about a C data type.
214 The status element says whether we have yet output
215 the definition of the type. TYPE_XREF says we have
216 output it as a cross-reference only.
217 The file_number and type_number elements are used if DBX_USE_BINCL
222 enum typestatus status;
229 /* Vector recording information about C data types.
230 When we first notice a data type (a tree node),
231 we assign it a number using next_type_number.
232 That is its index in this vector. */
234 struct typeinfo *typevec;
236 /* Number of elements of space allocated in `typevec'. */
238 static int typevec_len;
240 /* In dbx output, each type gets a unique number.
241 This is the number for the next type output.
242 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
244 static int next_type_number;
248 /* When using N_BINCL in dbx output, each type number is actually a
249 pair of the file number and the type number within the file.
250 This is a stack of input files. */
254 struct dbx_file *next;
256 int next_type_number;
259 /* This is the top of the stack. */
261 static struct dbx_file *current_file;
263 /* This is the next file number to use. */
265 static int next_file_number;
267 #endif /* DBX_USE_BINCL */
269 /* In dbx output, we must assign symbol-blocks id numbers
270 in the order in which their beginnings are encountered.
271 We output debugging info that refers to the beginning and
272 end of the ranges of code in each block
273 with assembler labels LBBn and LBEn, where n is the block number.
274 The labels are generated in final, which assigns numbers to the
275 blocks in the same way. */
277 static int next_block_number;
279 /* These variables are for dbxout_symbol to communicate to
280 dbxout_finish_symbol.
281 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
282 current_sym_value and current_sym_addr are two ways to address the
283 value to store in the symtab entry.
284 current_sym_addr if nonzero represents the value as an rtx.
285 If that is zero, current_sym_value is used. This is used
286 when the value is an offset (such as for auto variables,
287 register variables and parms). */
289 static STAB_CODE_TYPE current_sym_code;
290 static int current_sym_value;
291 static rtx current_sym_addr;
293 /* Number of chars of symbol-description generated so far for the
294 current symbol. Used by CHARS and CONTIN. */
296 static int current_sym_nchars;
298 /* Report having output N chars of the current symbol-description. */
300 #define CHARS(N) (current_sym_nchars += (N))
302 /* Break the current symbol-description, generating a continuation,
303 if it has become long. */
305 #ifndef DBX_CONTIN_LENGTH
306 #define DBX_CONTIN_LENGTH 80
309 #if DBX_CONTIN_LENGTH > 0
311 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
316 void dbxout_types ();
318 void dbxout_symbol ();
320 #if defined(ASM_OUTPUT_SECTION_NAME)
321 static void dbxout_function_end PROTO((void));
323 static void dbxout_typedefs PROTO((tree));
324 static void dbxout_type_index PROTO((tree));
325 static void dbxout_continue PROTO((void));
326 static void dbxout_type_fields PROTO((tree));
327 static void dbxout_type_method_1 PROTO((tree, char *));
328 static void dbxout_type_methods PROTO((tree));
329 static void dbxout_range_type PROTO((tree));
330 static void dbxout_type PROTO((tree, int, int));
331 static void print_int_cst_octal PROTO((tree));
332 static void print_octal PROTO((unsigned HOST_WIDE_INT, int));
333 static void dbxout_type_name PROTO((tree));
334 static void dbxout_symbol_location PROTO((tree, tree, char *, rtx));
335 static void dbxout_symbol_name PROTO((tree, char *, int));
336 static void dbxout_prepare_symbol PROTO((tree));
337 static void dbxout_finish_symbol PROTO((tree));
338 static void dbxout_block PROTO((tree, int, tree));
339 static void dbxout_really_begin_function PROTO((tree));
341 #if defined(ASM_OUTPUT_SECTION_NAME)
343 dbxout_function_end ()
345 static int scope_labelno = 0;
346 char lscope_label_name[100];
347 /* Convert Ltext into the appropriate format for local labels in case
348 the system doesn't insert underscores in front of user generated
350 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
351 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Lscope", scope_labelno);
354 /* By convention, GCC will mark the end of a function with an N_FUN
355 symbol and an empty string. */
356 fprintf (asmfile, "%s \"\",%d,0,0,", ASM_STABS_OP, N_FUN);
357 assemble_name (asmfile, lscope_label_name);
358 fputc ('-', asmfile);
359 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
360 fprintf (asmfile, "\n");
362 #endif /* ! NO_DBX_FUNCTION_END */
364 /* At the beginning of compilation, start writing the symbol table.
365 Initialize `typevec' and output the standard data types of C. */
368 dbxout_init (asm_file, input_file_name, syms)
370 char *input_file_name;
373 char ltext_label_name[100];
378 typevec = (struct typeinfo *) xmalloc (typevec_len * sizeof typevec[0]);
379 bzero ((char *) typevec, typevec_len * sizeof typevec[0]);
381 /* Convert Ltext into the appropriate format for local labels in case
382 the system doesn't insert underscores in front of user generated
384 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
386 /* Put the current working directory in an N_SO symbol. */
387 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
388 but GDB always does. */
389 if (use_gnu_debug_info_extensions)
392 if (!cwd && (cwd = getpwd ()) && (!*cwd || cwd[strlen (cwd) - 1] != '/'))
394 char *wdslash = xmalloc (strlen (cwd) + sizeof (FILE_NAME_JOINER));
395 sprintf (wdslash, "%s%s", cwd, FILE_NAME_JOINER);
400 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
401 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd);
402 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
403 fprintf (asmfile, "%s ", ASM_STABS_OP);
404 output_quoted_string (asmfile, cwd);
405 fprintf (asmfile, ",%d,0,0,%s\n", N_SO, <ext_label_name[1]);
406 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
410 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
411 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
412 would give us an N_SOL, and we want an N_SO. */
413 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile, input_file_name);
414 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
415 /* We include outputting `Ltext:' here,
416 because that gives you a way to override it. */
417 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
418 fprintf (asmfile, "%s ", ASM_STABS_OP);
419 output_quoted_string (asmfile, input_file_name);
420 fprintf (asmfile, ",%d,0,0,%s\n",
421 N_SO, <ext_label_name[1]);
423 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Ltext", 0);
424 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
426 /* Possibly output something to inform GDB that this compilation was by
427 GCC. It's easier for GDB to parse it when after the N_SO's. This
428 is used in Solaris 2. */
429 #ifdef ASM_IDENTIFY_GCC_AFTER_SOURCE
430 ASM_IDENTIFY_GCC_AFTER_SOURCE (asmfile);
433 lastfile = input_file_name;
435 next_type_number = 1;
436 next_block_number = 2;
439 current_file = (struct dbx_file *) xmalloc (sizeof *current_file);
440 current_file->next = NULL;
441 current_file->file_number = 0;
442 current_file->next_type_number = 1;
443 next_file_number = 1;
446 /* Make sure that types `int' and `char' have numbers 1 and 2.
447 Definitions of other integer types will refer to those numbers.
448 (Actually it should no longer matter what their numbers are.
449 Also, if any types with tags have been defined, dbxout_symbol
450 will output them first, so the numbers won't be 1 and 2. That
451 happens in C++. So it's a good thing it should no longer matter). */
453 #ifdef DBX_OUTPUT_STANDARD_TYPES
454 DBX_OUTPUT_STANDARD_TYPES (syms);
456 dbxout_symbol (TYPE_NAME (integer_type_node), 0);
457 dbxout_symbol (TYPE_NAME (char_type_node), 0);
460 /* Get all permanent types that have typedef names,
461 and output them all, except for those already output. */
463 dbxout_typedefs (syms);
466 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
467 in the reverse order from that which is found in SYMS. */
470 dbxout_typedefs (syms)
475 dbxout_typedefs (TREE_CHAIN (syms));
476 if (TREE_CODE (syms) == TYPE_DECL)
478 tree type = TREE_TYPE (syms);
480 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
481 && TYPE_SIZE (type) != NULL_TREE
482 && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
483 dbxout_symbol (TYPE_NAME (type), 0);
488 /* Change to reading from a new source file. Generate a N_BINCL stab. */
491 dbxout_start_new_source_file (filename)
495 struct dbx_file *n = (struct dbx_file *) xmalloc (sizeof *n);
497 n->next = current_file;
498 n->file_number = next_file_number++;
499 n->next_type_number = 1;
501 fprintf (asmfile, "%s ", ASM_STABS_OP);
502 output_quoted_string (asmfile, filename);
503 fprintf (asmfile, ",%d,0,0,0\n", N_BINCL);
507 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
510 dbxout_resume_previous_source_file ()
513 struct dbx_file *next;
515 fprintf (asmfile, "%s %d,0,0,0\n", ASM_STABN_OP, N_EINCL);
516 next = current_file->next;
522 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
525 dbxout_source_file (file, filename)
529 char ltext_label_name[100];
531 if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
533 #ifdef DBX_OUTPUT_SOURCE_FILENAME
534 DBX_OUTPUT_SOURCE_FILENAME (file, filename);
536 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext",
537 source_label_number);
538 fprintf (file, "%s ", ASM_STABS_OP);
539 output_quoted_string (file, filename);
540 fprintf (file, ",%d,0,0,%s\n", N_SOL, <ext_label_name[1]);
541 if (current_function_decl != NULL_TREE
542 && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
543 ; /* Don't change section amid function. */
546 ASM_OUTPUT_INTERNAL_LABEL (file, "Ltext", source_label_number);
547 source_label_number++;
553 /* Output a line number symbol entry into output stream FILE,
554 for source file FILENAME and line number LINENO. */
557 dbxout_source_line (file, filename, lineno)
562 dbxout_source_file (file, filename);
564 #ifdef ASM_OUTPUT_SOURCE_LINE
565 ASM_OUTPUT_SOURCE_LINE (file, lineno);
567 fprintf (file, "\t%s %d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno);
571 /* At the end of compilation, finish writing the symbol table.
572 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
576 dbxout_finish (file, filename)
580 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
581 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file, filename);
582 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
585 /* Output the index of a type. */
588 dbxout_type_index (type)
591 #ifndef DBX_USE_BINCL
592 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
595 struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
596 fprintf (asmfile, "(%d,%d)", t->file_number, t->type_number);
601 /* Continue a symbol-description that gets too big.
602 End one symbol table entry with a double-backslash
603 and start a new one, eventually producing something like
604 .stabs "start......\\",code,0,value
605 .stabs "...rest",code,0,value */
610 #ifdef DBX_CONTIN_CHAR
611 fprintf (asmfile, "%c", DBX_CONTIN_CHAR);
613 fprintf (asmfile, "\\\\");
615 dbxout_finish_symbol (NULL_TREE);
616 fprintf (asmfile, "%s \"", ASM_STABS_OP);
617 current_sym_nchars = 0;
620 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
621 This must be a separate function because anonymous unions require
625 dbxout_type_fields (type)
629 /* Output the name, type, position (in bits), size (in bits) of each
631 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
633 /* Omit here local type decls until we know how to support them. */
634 if (TREE_CODE (tem) == TYPE_DECL)
636 /* Omit fields whose position or size are variable. */
637 else if (TREE_CODE (tem) == FIELD_DECL
638 && (TREE_CODE (DECL_FIELD_BITPOS (tem)) != INTEGER_CST
639 || TREE_CODE (DECL_SIZE (tem)) != INTEGER_CST))
641 /* Omit here the nameless fields that are used to skip bits. */
642 else if (DECL_IGNORED_P (tem))
644 else if (TREE_CODE (tem) != CONST_DECL)
646 /* Continue the line if necessary,
647 but not before the first field. */
648 if (tem != TYPE_FIELDS (type))
653 if (use_gnu_debug_info_extensions
654 && flag_minimal_debug
655 && TREE_CODE (tem) == FIELD_DECL
656 && DECL_VIRTUAL_P (tem)
657 && DECL_ASSEMBLER_NAME (tem))
659 have_used_extensions = 1;
660 CHARS (3 + IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (tem)));
661 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem)), asmfile);
662 dbxout_type (DECL_FCONTEXT (tem), 0, 0);
663 fprintf (asmfile, ":");
664 dbxout_type (TREE_TYPE (tem), 0, 0);
665 fprintf (asmfile, ",%d;",
666 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)));
672 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
673 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem)));
677 fprintf (asmfile, ":");
681 if (use_gnu_debug_info_extensions
682 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
683 || TREE_CODE (tem) != FIELD_DECL))
685 have_used_extensions = 1;
687 putc ((TREE_PRIVATE (tem) ? '0'
688 : TREE_PROTECTED (tem) ? '1' : '2'),
693 dbxout_type ((TREE_CODE (tem) == FIELD_DECL
694 && DECL_BIT_FIELD_TYPE (tem))
695 ? DECL_BIT_FIELD_TYPE (tem)
696 : TREE_TYPE (tem), 0, 0);
698 if (TREE_CODE (tem) == VAR_DECL)
700 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
702 char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem));
703 have_used_extensions = 1;
704 fprintf (asmfile, ":%s;", name);
705 CHARS (strlen (name));
709 /* If TEM is non-static, GDB won't understand it. */
710 fprintf (asmfile, ",0,0;");
713 else if (TREE_CODE (DECL_FIELD_BITPOS (tem)) == INTEGER_CST)
715 fprintf (asmfile, ",%d,%d;",
716 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)),
717 TREE_INT_CST_LOW (DECL_SIZE (tem)));
724 /* Subroutine of `dbxout_type_methods'. Output debug info about the
725 method described DECL. DEBUG_NAME is an encoding of the method's
726 type signature. ??? We may be able to do without DEBUG_NAME altogether
730 dbxout_type_method_1 (decl, debug_name)
736 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
738 else /* it's a METHOD_TYPE. */
740 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
741 /* A for normal functions.
742 B for `const' member functions.
743 C for `volatile' member functions.
744 D for `const volatile' member functions. */
745 if (TYPE_READONLY (TREE_TYPE (firstarg)))
747 if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
750 if (DECL_VINDEX (decl))
756 fprintf (asmfile, ":%s;%c%c%c", debug_name,
757 TREE_PRIVATE (decl) ? '0' : TREE_PROTECTED (decl) ? '1' : '2', c1, c2);
758 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)) + 6
759 - (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
760 if (DECL_VINDEX (decl))
762 fprintf (asmfile, "%d;",
763 TREE_INT_CST_LOW (DECL_VINDEX (decl)));
764 dbxout_type (DECL_CONTEXT (decl), 0, 0);
765 fprintf (asmfile, ";");
770 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
774 dbxout_type_methods (type)
777 /* C++: put out the method names and their parameter lists */
778 tree methods = TYPE_METHODS (type);
780 register tree fndecl;
782 char formatted_type_identifier_length[16];
783 register int type_identifier_length;
785 if (methods == NULL_TREE)
788 type_encoding = DECL_NAME (TYPE_NAME (type));
791 /* C++: Template classes break some assumptions made by this code about
792 the class names, constructor names, and encodings for assembler
793 label names. For now, disable output of dbx info for them. */
795 char *ptr = IDENTIFIER_POINTER (type_encoding);
796 /* This should use index. (mrs) */
797 while (*ptr && *ptr != '<') ptr++;
804 #ifdef HAVE_TEMPLATES
805 if (warn_template_debugging)
806 warning ("dbx info for template class methods not yet supported");
814 type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
816 sprintf(formatted_type_identifier_length, "%d", type_identifier_length);
818 if (TREE_CODE (methods) != TREE_VEC)
820 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
821 fndecl = TREE_VEC_ELT (methods, 0);
823 fndecl = TREE_VEC_ELT (methods, 1);
827 tree name = DECL_NAME (fndecl);
830 /* Group together all the methods for the same operation.
831 These differ in the types of the arguments. */
832 for (last = NULL_TREE;
833 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
834 fndecl = TREE_CHAIN (fndecl))
835 /* Output the name of the field (after overloading), as
836 well as the name of the field before overloading, along
837 with its parameter list */
839 /* This is the "mangled" name of the method.
840 It encodes the argument types. */
841 char *debug_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
842 int show_arg_types = 0;
848 if (DECL_IGNORED_P (fndecl))
851 if (flag_minimal_debug)
855 /* We can't optimize a method which uses an anonymous
856 class, because the debugger will not be able to
857 associate the arbitrary class name with the actual
859 #ifndef NO_DOLLAR_IN_LABEL
864 if (strchr (debug_name, marker))
866 /* Detect ordinary methods because their mangled names
867 start with the operation name. */
868 else if (!strncmp (IDENTIFIER_POINTER (name), debug_name,
869 IDENTIFIER_LENGTH (name)))
871 debug_name += IDENTIFIER_LENGTH (name);
872 if (debug_name[0] == '_' && debug_name[1] == '_')
874 char *method_name = debug_name + 2;
875 char *length_ptr = formatted_type_identifier_length;
876 /* Get past const and volatile qualifiers. */
877 while (*method_name == 'C' || *method_name == 'V')
879 /* Skip digits for length of type_encoding. */
880 while (*method_name == *length_ptr && *length_ptr)
881 length_ptr++, method_name++;
882 if (! strncmp (method_name,
883 IDENTIFIER_POINTER (type_encoding),
884 type_identifier_length))
885 method_name += type_identifier_length;
886 debug_name = method_name;
889 /* Detect constructors by their style of name mangling. */
890 else if (debug_name[0] == '_' && debug_name[1] == '_')
892 char *ctor_name = debug_name + 2;
893 char *length_ptr = formatted_type_identifier_length;
894 while (*ctor_name == 'C' || *ctor_name == 'V')
896 /* Skip digits for length of type_encoding. */
897 while (*ctor_name == *length_ptr && *length_ptr)
898 length_ptr++, ctor_name++;
899 if (!strncmp (IDENTIFIER_POINTER (type_encoding), ctor_name,
900 type_identifier_length))
901 debug_name = ctor_name + type_identifier_length;
903 /* The other alternative is a destructor. */
907 /* Output the operation name just once, for the first method
911 fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
912 CHARS (IDENTIFIER_LENGTH (name) + 2);
917 dbxout_type (TREE_TYPE (fndecl), 0, show_arg_types);
919 dbxout_type_method_1 (fndecl, debug_name);
929 /* Emit a "range" type specification, which has the form:
930 "r<index type>;<lower bound>;<upper bound>;".
931 TYPE is an INTEGER_TYPE. */
934 dbxout_range_type (type)
937 fprintf (asmfile, "r");
938 if (TREE_TYPE (type))
939 dbxout_type (TREE_TYPE (type), 0, 0);
940 else if (TREE_CODE (type) != INTEGER_TYPE)
941 dbxout_type (type, 0, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
944 /* Traditionally, we made sure 'int' was type 1, and builtin types
945 were defined to be sub-ranges of int. Unfortunately, this
946 does not allow us to distinguish true sub-ranges from integer
947 types. So, instead we define integer (non-sub-range) types as
948 sub-ranges of themselves. */
949 dbxout_type_index (type);
951 if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
952 fprintf (asmfile, ";%d",
953 TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)));
955 fprintf (asmfile, ";0");
956 if (TYPE_MAX_VALUE (type)
957 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
958 fprintf (asmfile, ";%d;",
959 TREE_INT_CST_LOW (TYPE_MAX_VALUE (type)));
961 fprintf (asmfile, ";-1;");
964 /* Output a reference to a type. If the type has not yet been
965 described in the dbx output, output its definition now.
966 For a type already defined, just refer to its definition
967 using the type number.
969 If FULL is nonzero, and the type has been described only with
970 a forward-reference, output the definition now.
971 If FULL is zero in this case, just refer to the forward-reference
972 using the number previously allocated.
974 If SHOW_ARG_TYPES is nonzero, we output a description of the argument
975 types for a METHOD_TYPE. */
978 dbxout_type (type, full, show_arg_types)
984 static int anonymous_type_number = 0;
986 /* If there was an input error and we don't really have a type,
987 avoid crashing and write something that is at least valid
988 by assuming `int'. */
989 if (type == error_mark_node)
990 type = integer_type_node;
993 /* Try to find the "main variant" with the same name but not const
994 or volatile. (Since stabs does not distinguish const and volatile,
995 there is no need to make them separate types. But types with
996 different names are usefully distinguished.) */
998 for (tem = TYPE_MAIN_VARIANT (type); tem; tem = TYPE_NEXT_VARIANT (tem))
999 if (!TYPE_READONLY (tem) && !TYPE_VOLATILE (tem)
1000 && TYPE_NAME (tem) == TYPE_NAME (type))
1005 if (TYPE_NAME (type)
1006 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1007 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
1011 if (TYPE_SYMTAB_ADDRESS (type) == 0)
1013 /* Type has no dbx number assigned. Assign next available number. */
1014 TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
1016 /* Make sure type vector is long enough to record about this type. */
1018 if (next_type_number == typevec_len)
1021 = (struct typeinfo *) xrealloc (typevec,
1022 typevec_len * 2 * sizeof typevec[0]);
1023 bzero ((char *) (typevec + typevec_len),
1024 typevec_len * sizeof typevec[0]);
1028 #ifdef DBX_USE_BINCL
1029 typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
1030 = current_file->file_number;
1031 typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
1032 = current_file->next_type_number++;
1036 /* Output the number of this type, to refer to it. */
1037 dbxout_type_index (type);
1039 #ifdef DBX_TYPE_DEFINED
1040 if (DBX_TYPE_DEFINED (type))
1044 /* If this type's definition has been output or is now being output,
1047 switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
1052 /* If we have already had a cross reference,
1053 and either that's all we want or that's the best we could do,
1054 don't repeat the cross reference.
1055 Sun dbx crashes if we do. */
1056 if (! full || TYPE_SIZE (type) == 0
1057 /* No way in DBX fmt to describe a variable size. */
1058 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1066 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1067 leave the type-number completely undefined rather than output
1068 a cross-reference. If we have already used GNU debug info extensions,
1069 then it is OK to output a cross reference. This is necessary to get
1070 proper C++ debug output. */
1071 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
1072 || TREE_CODE (type) == QUAL_UNION_TYPE
1073 || TREE_CODE (type) == ENUMERAL_TYPE)
1074 && ! use_gnu_debug_info_extensions)
1075 /* We must use the same test here as we use twice below when deciding
1076 whether to emit a cross-reference. */
1077 if ((TYPE_NAME (type) != 0
1078 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1079 && DECL_IGNORED_P (TYPE_NAME (type)))
1081 || TYPE_SIZE (type) == 0
1082 /* No way in DBX fmt to describe a variable size. */
1083 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1085 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1090 /* Output a definition now. */
1092 fprintf (asmfile, "=");
1095 /* Mark it as defined, so that if it is self-referent
1096 we will not get into an infinite recursion of definitions. */
1098 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
1100 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1101 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1103 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0, 0);
1107 switch (TREE_CODE (type))
1111 /* For a void type, just define it as itself; ie, "5=5".
1112 This makes us consider it defined
1113 without saying what it is. The debugger will make it
1114 a void type when the reference is seen, and nothing will
1115 ever override that default. */
1116 dbxout_type_index (type);
1120 if (type == char_type_node && ! TREE_UNSIGNED (type))
1122 /* Output the type `char' as a subrange of itself!
1123 I don't understand this definition, just copied it
1124 from the output of pcc.
1125 This used to use `r2' explicitly and we used to
1126 take care to make sure that `char' was type number 2. */
1127 fprintf (asmfile, "r");
1128 dbxout_type_index (type);
1129 fprintf (asmfile, ";0;127;");
1131 else if (use_gnu_debug_info_extensions
1132 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
1133 || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT))
1135 /* This used to say `r1' and we used to take care
1136 to make sure that `int' was type number 1. */
1137 fprintf (asmfile, "r");
1138 dbxout_type_index (integer_type_node);
1139 fprintf (asmfile, ";");
1140 print_int_cst_octal (TYPE_MIN_VALUE (type));
1141 fprintf (asmfile, ";");
1142 print_int_cst_octal (TYPE_MAX_VALUE (type));
1143 fprintf (asmfile, ";");
1145 else /* Output other integer types as subranges of `int'. */
1146 dbxout_range_type (type);
1151 /* This used to say `r1' and we used to take care
1152 to make sure that `int' was type number 1. */
1153 fprintf (asmfile, "r");
1154 dbxout_type_index (integer_type_node);
1155 fprintf (asmfile, ";%d;0;", int_size_in_bytes (type));
1160 if (use_gnu_debug_info_extensions)
1161 fprintf (asmfile, "@s%d;-20;",
1162 BITS_PER_UNIT * int_size_in_bytes (type));
1165 /* Output the type `char' as a subrange of itself.
1166 That is what pcc seems to do. */
1167 fprintf (asmfile, "r");
1168 dbxout_type_index (char_type_node);
1169 fprintf (asmfile, ";0;%d;", TREE_UNSIGNED (type) ? 255 : 127);
1175 if (use_gnu_debug_info_extensions)
1176 fprintf (asmfile, "@s%d;-16;",
1177 BITS_PER_UNIT * int_size_in_bytes (type));
1178 else /* Define as enumeral type (False, True) */
1179 fprintf (asmfile, "eFalse:0,True:1,;");
1184 putc ('d', asmfile);
1186 dbxout_type (TREE_TYPE (type), 0, 0);
1190 /* Differs from the REAL_TYPE by its new data type number */
1192 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1194 fprintf (asmfile, "r");
1195 dbxout_type_index (type);
1196 fprintf (asmfile, ";%d;0;",
1197 int_size_in_bytes (TREE_TYPE (type)));
1198 CHARS (12); /* The number is probably incorrect here. */
1202 /* Output a complex integer type as a structure,
1203 pending some other way to do it. */
1204 fprintf (asmfile, "s%d", int_size_in_bytes (type));
1206 fprintf (asmfile, "real:");
1208 dbxout_type (TREE_TYPE (type), 0, 0);
1209 fprintf (asmfile, ",%d,%d;",
1210 0, TYPE_PRECISION (TREE_TYPE (type)));
1212 fprintf (asmfile, "imag:");
1214 dbxout_type (TREE_TYPE (type), 0, 0);
1215 fprintf (asmfile, ",%d,%d;;",
1216 TYPE_PRECISION (TREE_TYPE (type)),
1217 TYPE_PRECISION (TREE_TYPE (type)));
1223 if (use_gnu_debug_info_extensions)
1225 have_used_extensions = 1;
1226 fprintf (asmfile, "@s%d;",
1227 BITS_PER_UNIT * int_size_in_bytes (type));
1228 /* Check if a bitstring type, which in Chill is
1229 different from a [power]set. */
1230 if (TYPE_STRING_FLAG (type))
1231 fprintf (asmfile, "@S;");
1233 putc ('S', asmfile);
1235 dbxout_type (TYPE_DOMAIN (type), 0, 0);
1239 /* Output "a" followed by a range type definition
1240 for the index type of the array
1241 followed by a reference to the target-type.
1242 ar1;0;N;M for a C array of type M and size N+1. */
1243 /* Check if a character string type, which in Chill is
1244 different from an array of characters. */
1245 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
1247 have_used_extensions = 1;
1248 fprintf (asmfile, "@S;");
1250 tem = TYPE_DOMAIN (type);
1253 fprintf (asmfile, "ar");
1254 dbxout_type_index (integer_type_node);
1255 fprintf (asmfile, ";0;-1;");
1259 fprintf (asmfile, "a");
1260 dbxout_range_type (tem);
1263 dbxout_type (TREE_TYPE (type), 0, 0);
1268 case QUAL_UNION_TYPE:
1270 int i, n_baseclasses = 0;
1272 if (TYPE_BINFO (type) != 0
1273 && TREE_CODE (TYPE_BINFO (type)) == TREE_VEC
1274 && TYPE_BINFO_BASETYPES (type) != 0)
1275 n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
1277 /* Output a structure type. We must use the same test here as we
1278 use in the DBX_NO_XREFS case above. */
1279 if ((TYPE_NAME (type) != 0
1280 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1281 && DECL_IGNORED_P (TYPE_NAME (type)))
1283 || TYPE_SIZE (type) == 0
1284 /* No way in DBX fmt to describe a variable size. */
1285 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1287 /* If the type is just a cross reference, output one
1288 and mark the type as partially described.
1289 If it later becomes defined, we will output
1290 its real definition.
1291 If the type has a name, don't nest its definition within
1292 another type's definition; instead, output an xref
1293 and let the definition come when the name is defined. */
1294 fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
1296 #if 0 /* This assertion is legitimately false in C++. */
1297 /* We shouldn't be outputting a reference to a type before its
1298 definition unless the type has a tag name.
1299 A typedef name without a tag name should be impossible. */
1300 if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
1303 if (TYPE_NAME (type) != 0)
1304 dbxout_type_name (type);
1306 fprintf (asmfile, "$$%d", anonymous_type_number++);
1307 fprintf (asmfile, ":");
1308 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1312 /* Identify record or union, and print its size. */
1313 fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "s%d" : "u%d",
1314 int_size_in_bytes (type));
1316 if (use_gnu_debug_info_extensions)
1320 have_used_extensions = 1;
1321 fprintf (asmfile, "!%d,", n_baseclasses);
1325 for (i = 0; i < n_baseclasses; i++)
1327 tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i);
1328 if (use_gnu_debug_info_extensions)
1330 have_used_extensions = 1;
1331 putc (TREE_VIA_VIRTUAL (child) ? '1'
1334 putc (TREE_VIA_PUBLIC (child) ? '2'
1337 fprintf (asmfile, "%d,",
1338 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT);
1340 dbxout_type (BINFO_TYPE (child), 0, 0);
1341 putc (';', asmfile);
1345 /* Print out the base class information with fields
1346 which have the same names at the types they hold. */
1347 dbxout_type_name (BINFO_TYPE (child));
1348 putc (':', asmfile);
1349 dbxout_type (BINFO_TYPE (child), full, 0);
1350 fprintf (asmfile, ",%d,%d;",
1351 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT,
1352 TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child)))) * BITS_PER_UNIT);
1360 /* Write out the field declarations. */
1361 dbxout_type_fields (type);
1362 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
1364 have_used_extensions = 1;
1365 dbxout_type_methods (type);
1367 putc (';', asmfile);
1369 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
1370 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1371 && TYPE_VFIELD (type))
1373 have_used_extensions = 1;
1375 /* Tell GDB+ that it may keep reading. */
1376 putc ('~', asmfile);
1378 /* We need to write out info about what field this class
1379 uses as its "main" vtable pointer field, because if this
1380 field is inherited from a base class, GDB cannot necessarily
1381 figure out which field it's using in time. */
1382 if (TYPE_VFIELD (type))
1384 putc ('%', asmfile);
1385 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0, 0);
1387 putc (';', asmfile);
1393 /* We must use the same test here as we use in the DBX_NO_XREFS case
1394 above. We simplify it a bit since an enum will never have a variable
1396 if ((TYPE_NAME (type) != 0
1397 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1398 && DECL_IGNORED_P (TYPE_NAME (type)))
1400 || TYPE_SIZE (type) == 0)
1402 fprintf (asmfile, "xe");
1404 dbxout_type_name (type);
1405 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1406 fprintf (asmfile, ":");
1409 #ifdef DBX_OUTPUT_ENUM
1410 DBX_OUTPUT_ENUM (asmfile, type);
1412 if (use_gnu_debug_info_extensions
1413 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1414 fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1415 putc ('e', asmfile);
1417 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
1419 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1420 if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
1421 fprintf (asmfile, "%lu",
1422 (unsigned long) TREE_INT_CST_LOW (TREE_VALUE (tem)));
1423 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
1424 && TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
1425 fprintf (asmfile, "%ld",
1426 (long) TREE_INT_CST_LOW (TREE_VALUE (tem)));
1428 print_int_cst_octal (TREE_VALUE (tem));
1429 fprintf (asmfile, ",");
1430 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem)));
1431 if (TREE_CHAIN (tem) != 0)
1436 putc (';', asmfile);
1442 putc ('*', asmfile);
1444 dbxout_type (TREE_TYPE (type), 0, 0);
1448 if (use_gnu_debug_info_extensions)
1450 have_used_extensions = 1;
1451 putc ('#', asmfile);
1453 if (flag_minimal_debug && !show_arg_types)
1455 /* Normally, just output the return type.
1456 The argument types are encoded in the method name. */
1457 putc ('#', asmfile);
1459 dbxout_type (TREE_TYPE (type), 0, 0);
1460 putc (';', asmfile);
1465 /* When outputting destructors, we need to write
1466 the argument types out longhand. */
1467 dbxout_type (TYPE_METHOD_BASETYPE (type), 0, 0);
1468 putc (',', asmfile);
1470 dbxout_type (TREE_TYPE (type), 0, 0);
1471 dbxout_args (TYPE_ARG_TYPES (type));
1472 putc (';', asmfile);
1478 /* Treat it as a function type. */
1479 dbxout_type (TREE_TYPE (type), 0, 0);
1484 if (use_gnu_debug_info_extensions)
1486 have_used_extensions = 1;
1487 putc ('@', asmfile);
1489 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0, 0);
1490 putc (',', asmfile);
1492 dbxout_type (TREE_TYPE (type), 0, 0);
1496 /* Should print as an int, because it is really
1498 dbxout_type (integer_type_node, 0, 0);
1502 case REFERENCE_TYPE:
1503 if (use_gnu_debug_info_extensions)
1504 have_used_extensions = 1;
1505 putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
1507 dbxout_type (TREE_TYPE (type), 0, 0);
1511 putc ('f', asmfile);
1513 dbxout_type (TREE_TYPE (type), 0, 0);
1521 /* Print the value of integer constant C, in octal,
1522 handling double precision. */
1525 print_int_cst_octal (c)
1528 unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
1529 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
1530 int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
1531 int width = TYPE_PRECISION (TREE_TYPE (c));
1533 /* GDB wants constants with no extra leading "1" bits, so
1534 we need to remove any sign-extension that might be
1536 if (width == HOST_BITS_PER_WIDE_INT * 2)
1538 else if (width > HOST_BITS_PER_WIDE_INT)
1539 high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
1540 else if (width == HOST_BITS_PER_WIDE_INT)
1543 high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
1545 fprintf (asmfile, "0");
1549 print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
1550 print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
1554 unsigned HOST_WIDE_INT beg = high >> excess;
1555 unsigned HOST_WIDE_INT middle
1556 = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
1557 | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
1558 unsigned HOST_WIDE_INT end
1559 = low & (((unsigned HOST_WIDE_INT) 1
1560 << (HOST_BITS_PER_WIDE_INT / 3 * 3))
1563 fprintf (asmfile, "%o%01o", beg, middle);
1564 print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
1569 print_octal (value, digits)
1570 unsigned HOST_WIDE_INT value;
1575 for (i = digits - 1; i >= 0; i--)
1576 fprintf (asmfile, "%01o", ((value >> (3 * i)) & 7));
1579 /* Output the name of type TYPE, with no punctuation.
1580 Such names can be set up either by typedef declarations
1581 or by struct, enum and union tags. */
1584 dbxout_type_name (type)
1588 if (TYPE_NAME (type) == 0)
1590 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
1592 t = TYPE_NAME (type);
1594 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1596 t = DECL_NAME (TYPE_NAME (type));
1601 fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
1602 CHARS (IDENTIFIER_LENGTH (t));
1605 /* Output a .stabs for the symbol defined by DECL,
1606 which must be a ..._DECL node in the normal namespace.
1607 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1608 LOCAL is nonzero if the scope is less than the entire file. */
1611 dbxout_symbol (decl, local)
1615 tree type = TREE_TYPE (decl);
1616 tree context = NULL_TREE;
1618 /* Cast avoids warning in old compilers. */
1619 current_sym_code = (STAB_CODE_TYPE) 0;
1620 current_sym_value = 0;
1621 current_sym_addr = 0;
1623 /* Ignore nameless syms, but don't ignore type tags. */
1625 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
1626 || DECL_IGNORED_P (decl))
1629 dbxout_prepare_symbol (decl);
1631 /* The output will always start with the symbol name,
1632 so always count that in the length-output-so-far. */
1634 if (DECL_NAME (decl) != 0)
1635 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
1637 switch (TREE_CODE (decl))
1640 /* Enum values are defined by defining the enum type. */
1644 if (DECL_RTL (decl) == 0)
1646 if (DECL_EXTERNAL (decl))
1648 /* Don't mention a nested function under its parent. */
1649 context = decl_function_context (decl);
1650 if (context == current_function_decl)
1652 if (GET_CODE (DECL_RTL (decl)) != MEM
1653 || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
1657 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
1658 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1659 TREE_PUBLIC (decl) ? 'F' : 'f');
1661 current_sym_code = N_FUN;
1662 current_sym_addr = XEXP (DECL_RTL (decl), 0);
1664 if (TREE_TYPE (type))
1665 dbxout_type (TREE_TYPE (type), 0, 0);
1667 dbxout_type (void_type_node, 0, 0);
1669 /* For a nested function, when that function is compiled,
1670 mention the containing function name
1671 as well as (since dbx wants it) our own assembler-name. */
1673 fprintf (asmfile, ",%s,%s",
1674 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1675 IDENTIFIER_POINTER (DECL_NAME (context)));
1677 dbxout_finish_symbol (decl);
1682 /* This seems all wrong. Outputting most kinds of types gives no name
1683 at all. A true definition gives no name; a cross-ref for a
1684 structure can give the tag name, but not a type name.
1685 It seems that no typedef name is defined by outputting a type. */
1687 /* If this typedef name was defined by outputting the type,
1688 don't duplicate it. */
1689 if (typevec[TYPE_SYMTAB_ADDRESS (type)].status == TYPE_DEFINED
1690 && TYPE_NAME (TREE_TYPE (decl)) == decl)
1693 /* Don't output the same typedef twice.
1694 And don't output what language-specific stuff doesn't want output. */
1695 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
1704 if (DECL_NAME (decl))
1706 /* Nonzero means we must output a tag as well as a typedef. */
1709 /* Handle the case of a C++ structure or union
1710 where the TYPE_NAME is a TYPE_DECL
1711 which gives both a typedef name and a tag. */
1712 /* dbx requires the tag first and the typedef second. */
1713 if ((TREE_CODE (type) == RECORD_TYPE
1714 || TREE_CODE (type) == UNION_TYPE
1715 || TREE_CODE (type) == QUAL_UNION_TYPE)
1716 && TYPE_NAME (type) == decl
1717 && !(use_gnu_debug_info_extensions && have_used_extensions)
1718 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
1719 /* Distinguish the implicit typedefs of C++
1720 from explicit ones that might be found in C. */
1721 && DECL_ARTIFICIAL (decl))
1723 tree name = TYPE_NAME (type);
1724 if (TREE_CODE (name) == TYPE_DECL)
1725 name = DECL_NAME (name);
1727 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1728 current_sym_value = 0;
1729 current_sym_addr = 0;
1730 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1732 fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP,
1733 IDENTIFIER_POINTER (name));
1734 dbxout_type (type, 1, 0);
1735 dbxout_finish_symbol (NULL_TREE);
1738 /* Output typedef name. */
1739 fprintf (asmfile, "%s \"%s:", ASM_STABS_OP,
1740 IDENTIFIER_POINTER (DECL_NAME (decl)));
1742 /* Short cut way to output a tag also. */
1743 if ((TREE_CODE (type) == RECORD_TYPE
1744 || TREE_CODE (type) == UNION_TYPE
1745 || TREE_CODE (type) == QUAL_UNION_TYPE)
1746 && TYPE_NAME (type) == decl
1747 /* Distinguish the implicit typedefs of C++
1748 from explicit ones that might be found in C. */
1749 && DECL_ARTIFICIAL (decl))
1751 if (use_gnu_debug_info_extensions && have_used_extensions)
1753 putc ('T', asmfile);
1754 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
1756 #if 0 /* Now we generate the tag for this case up above. */
1762 putc ('t', asmfile);
1763 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1765 dbxout_type (type, 1, 0);
1766 dbxout_finish_symbol (decl);
1770 /* Don't output a tag if this is an incomplete type (TYPE_SIZE is
1771 zero). This prevents the sun4 Sun OS 4.x dbx from crashing. */
1773 if (tag_needed && TYPE_NAME (type) != 0
1774 && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
1775 || (DECL_NAME (TYPE_NAME (type)) != 0))
1776 && TYPE_SIZE (type) != 0
1777 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
1779 /* For a TYPE_DECL with no name, but the type has a name,
1781 This is what represents `struct foo' with no typedef. */
1782 /* In C++, the name of a type is the corresponding typedef.
1783 In C, it is an IDENTIFIER_NODE. */
1784 tree name = TYPE_NAME (type);
1785 if (TREE_CODE (name) == TYPE_DECL)
1786 name = DECL_NAME (name);
1788 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1789 current_sym_value = 0;
1790 current_sym_addr = 0;
1791 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1793 fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP,
1794 IDENTIFIER_POINTER (name));
1795 dbxout_type (type, 1, 0);
1796 dbxout_finish_symbol (NULL_TREE);
1800 /* If an enum type has no name, it cannot be referred to,
1801 but we must output it anyway, since the enumeration constants
1802 can be referred to. */
1803 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
1805 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1806 current_sym_value = 0;
1807 current_sym_addr = 0;
1808 current_sym_nchars = 2;
1810 /* Some debuggers fail when given NULL names, so give this a
1811 harmless name of ` '. */
1812 fprintf (asmfile, "%s \" :T", ASM_STABS_OP);
1813 dbxout_type (type, 1, 0);
1814 dbxout_finish_symbol (NULL_TREE);
1817 /* Prevent duplicate output of a typedef. */
1818 TREE_ASM_WRITTEN (decl) = 1;
1823 /* Parm decls go in their own separate chains
1824 and are output by dbxout_reg_parms and dbxout_parms. */
1828 /* Named return value, treat like a VAR_DECL. */
1830 if (DECL_RTL (decl) == 0)
1832 /* Don't mention a variable that is external.
1833 Let the file that defines it describe it. */
1834 if (DECL_EXTERNAL (decl))
1837 /* If the variable is really a constant
1838 and not written in memory, inform the debugger. */
1839 if (TREE_STATIC (decl) && TREE_READONLY (decl)
1840 && DECL_INITIAL (decl) != 0
1841 && ! TREE_ASM_WRITTEN (decl)
1842 && (DECL_FIELD_CONTEXT (decl) == NULL_TREE
1843 || TREE_CODE (DECL_FIELD_CONTEXT (decl)) == BLOCK))
1845 if (TREE_PUBLIC (decl) == 0)
1847 /* The sun4 assembler does not grok this. */
1848 char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1849 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
1850 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
1852 HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl));
1853 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1854 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile, name, ival);
1856 fprintf (asmfile, "%s \"%s:c=i%d\",0x%x,0,0,0\n",
1857 ASM_STABS_OP, name, ival, N_LSYM);
1861 else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
1863 /* don't know how to do this yet. */
1867 /* else it is something we handle like a normal variable. */
1870 DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, NULL_RTX);
1871 #ifdef LEAF_REG_REMAP
1873 leaf_renumber_regs_insn (DECL_RTL (decl));
1876 dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
1884 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1885 Add SUFFIX to its name, if SUFFIX is not 0.
1886 Describe the variable as residing in HOME
1887 (usually HOME is DECL_RTL (DECL), but not always). */
1890 dbxout_symbol_location (decl, type, suffix, home)
1898 /* Don't mention a variable at all
1899 if it was completely optimized into nothingness.
1901 If the decl was from an inline function, then it's rtl
1902 is not identically the rtl that was used in this
1903 particular compilation. */
1904 if (GET_CODE (home) == REG)
1906 regno = REGNO (home);
1907 if (regno >= FIRST_PSEUDO_REGISTER)
1910 else if (GET_CODE (home) == SUBREG)
1914 while (GET_CODE (value) == SUBREG)
1916 offset += SUBREG_WORD (value);
1917 value = SUBREG_REG (value);
1919 if (GET_CODE (value) == REG)
1921 regno = REGNO (value);
1922 if (regno >= FIRST_PSEUDO_REGISTER)
1926 alter_subreg (home);
1929 /* The kind-of-variable letter depends on where
1930 the variable is and on the scope of its name:
1931 G and N_GSYM for static storage and global scope,
1932 S for static storage and file scope,
1933 V for static storage and local scope,
1934 for those two, use N_LCSYM if data is in bss segment,
1935 N_STSYM if in data segment, N_FUN otherwise.
1936 (We used N_FUN originally, then changed to N_STSYM
1937 to please GDB. However, it seems that confused ld.
1938 Now GDB has been fixed to like N_FUN, says Kingdon.)
1939 no letter at all, and N_LSYM, for auto variable,
1940 r and N_RSYM for register variable. */
1942 if (GET_CODE (home) == MEM
1943 && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
1945 if (TREE_PUBLIC (decl))
1948 current_sym_code = N_GSYM;
1952 current_sym_addr = XEXP (home, 0);
1954 letter = decl_function_context (decl) ? 'V' : 'S';
1956 /* This should be the same condition as in assemble_variable, but
1957 we don't have access to dont_output_data here. So, instead,
1958 we rely on the fact that error_mark_node initializers always
1959 end up in bss for C++ and never end up in bss for C. */
1960 if (DECL_INITIAL (decl) == 0
1961 || (!strcmp (lang_identify (), "cplusplus")
1962 && DECL_INITIAL (decl) == error_mark_node))
1963 current_sym_code = N_LCSYM;
1964 else if (DECL_IN_TEXT_SECTION (decl))
1965 /* This is not quite right, but it's the closest
1966 of all the codes that Unix defines. */
1967 current_sym_code = DBX_STATIC_CONST_VAR_CODE;
1970 /* Ultrix `as' seems to need this. */
1971 #ifdef DBX_STATIC_STAB_DATA_SECTION
1974 current_sym_code = N_STSYM;
1978 else if (regno >= 0)
1981 current_sym_code = N_RSYM;
1982 current_sym_value = DBX_REGISTER_NUMBER (regno);
1984 else if (GET_CODE (home) == MEM
1985 && (GET_CODE (XEXP (home, 0)) == MEM
1986 || (GET_CODE (XEXP (home, 0)) == REG
1987 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
1988 && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
1989 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
1990 && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
1993 /* If the value is indirect by memory or by a register
1994 that isn't the frame pointer
1995 then it means the object is variable-sized and address through
1996 that register or stack slot. DBX has no way to represent this
1997 so all we can do is output the variable as a pointer.
1998 If it's not a parameter, ignore it.
1999 (VAR_DECLs like this can be made by integrate.c.) */
2001 if (GET_CODE (XEXP (home, 0)) == REG)
2004 current_sym_code = N_RSYM;
2005 current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
2009 current_sym_code = N_LSYM;
2010 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2011 We want the value of that CONST_INT. */
2013 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
2016 /* Effectively do build_pointer_type, but don't cache this type,
2017 since it might be temporary whereas the type it points to
2018 might have been saved for inlining. */
2019 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2020 type = make_node (POINTER_TYPE);
2021 TREE_TYPE (type) = TREE_TYPE (decl);
2023 else if (GET_CODE (home) == MEM
2024 && GET_CODE (XEXP (home, 0)) == REG)
2026 current_sym_code = N_LSYM;
2027 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2029 else if (GET_CODE (home) == MEM
2030 && GET_CODE (XEXP (home, 0)) == PLUS
2031 && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
2033 current_sym_code = N_LSYM;
2034 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2035 We want the value of that CONST_INT. */
2036 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2038 else if (GET_CODE (home) == MEM
2039 && GET_CODE (XEXP (home, 0)) == CONST)
2041 /* Handle an obscure case which can arise when optimizing and
2042 when there are few available registers. (This is *always*
2043 the case for i386/i486 targets). The RTL looks like
2044 (MEM (CONST ...)) even though this variable is a local `auto'
2045 or a local `register' variable. In effect, what has happened
2046 is that the reload pass has seen that all assignments and
2047 references for one such a local variable can be replaced by
2048 equivalent assignments and references to some static storage
2049 variable, thereby avoiding the need for a register. In such
2050 cases we're forced to lie to debuggers and tell them that
2051 this variable was itself `static'. */
2052 current_sym_code = N_LCSYM;
2054 current_sym_addr = XEXP (XEXP (home, 0), 0);
2056 else if (GET_CODE (home) == CONCAT)
2058 tree subtype = TREE_TYPE (type);
2060 /* If the variable's storage is in two parts,
2061 output each as a separate stab with a modified name. */
2062 if (WORDS_BIG_ENDIAN)
2063 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
2065 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
2067 /* Cast avoids warning in old compilers. */
2068 current_sym_code = (STAB_CODE_TYPE) 0;
2069 current_sym_value = 0;
2070 current_sym_addr = 0;
2071 dbxout_prepare_symbol (decl);
2073 if (WORDS_BIG_ENDIAN)
2074 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
2076 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
2080 /* Address might be a MEM, when DECL is a variable-sized object.
2081 Or it might be const0_rtx, meaning previous passes
2082 want us to ignore this variable. */
2085 /* Ok, start a symtab entry and output the variable name. */
2088 #ifdef DBX_STATIC_BLOCK_START
2089 DBX_STATIC_BLOCK_START (asmfile, current_sym_code);
2092 dbxout_symbol_name (decl, suffix, letter);
2093 dbxout_type (type, 0, 0);
2094 dbxout_finish_symbol (decl);
2096 #ifdef DBX_STATIC_BLOCK_END
2097 DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
2101 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2102 Then output LETTER to indicate the kind of location the symbol has. */
2105 dbxout_symbol_name (decl, suffix, letter)
2110 /* One slight hitch: if this is a VAR_DECL which is a static
2111 class member, we must put out the mangled name instead of the
2112 DECL_NAME. Note also that static member (variable) names DO NOT begin
2113 with underscores in .stabs directives. */
2114 char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2117 fprintf (asmfile, "%s \"%s%s:", ASM_STABS_OP, name,
2118 (suffix ? suffix : ""));
2120 if (letter) putc (letter, asmfile);
2124 dbxout_prepare_symbol (decl)
2128 char *filename = DECL_SOURCE_FILE (decl);
2130 dbxout_source_file (asmfile, filename);
2135 dbxout_finish_symbol (sym)
2138 #ifdef DBX_FINISH_SYMBOL
2139 DBX_FINISH_SYMBOL (sym);
2142 if (use_gnu_debug_info_extensions && sym != 0)
2143 line = DECL_SOURCE_LINE (sym);
2145 fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line);
2146 if (current_sym_addr)
2147 output_addr_const (asmfile, current_sym_addr);
2149 fprintf (asmfile, "%d", current_sym_value);
2150 putc ('\n', asmfile);
2154 /* Output definitions of all the decls in a chain. */
2162 dbxout_symbol (syms, 1);
2163 syms = TREE_CHAIN (syms);
2167 /* The following two functions output definitions of function parameters.
2168 Each parameter gets a definition locating it in the parameter list.
2169 Each parameter that is a register variable gets a second definition
2170 locating it in the register.
2172 Printing or argument lists in gdb uses the definitions that
2173 locate in the parameter list. But reference to the variable in
2174 expressions uses preferentially the definition as a register. */
2176 /* Output definitions, referring to storage in the parmlist,
2177 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2180 dbxout_parms (parms)
2183 for (; parms; parms = TREE_CHAIN (parms))
2184 if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node)
2186 dbxout_prepare_symbol (parms);
2188 /* Perform any necessary register eliminations on the parameter's rtl,
2189 so that the debugging output will be accurate. */
2190 DECL_INCOMING_RTL (parms)
2191 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
2192 DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX);
2193 #ifdef LEAF_REG_REMAP
2196 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
2197 leaf_renumber_regs_insn (DECL_RTL (parms));
2201 if (PARM_PASSED_IN_MEMORY (parms))
2203 rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
2205 /* ??? Here we assume that the parm address is indexed
2206 off the frame pointer or arg pointer.
2207 If that is not true, we produce meaningless results,
2208 but do not crash. */
2209 if (GET_CODE (addr) == PLUS
2210 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
2211 current_sym_value = INTVAL (XEXP (addr, 1));
2213 current_sym_value = 0;
2215 current_sym_code = N_PSYM;
2216 current_sym_addr = 0;
2219 if (DECL_NAME (parms))
2221 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2223 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2224 IDENTIFIER_POINTER (DECL_NAME (parms)),
2225 DBX_MEMPARM_STABS_LETTER);
2229 current_sym_nchars = 8;
2230 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2231 DBX_MEMPARM_STABS_LETTER);
2234 dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
2235 current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
2236 dbxout_finish_symbol (parms);
2238 else if (GET_CODE (DECL_RTL (parms)) == REG)
2241 char regparm_letter;
2243 /* Parm passed in registers and lives in registers or nowhere. */
2245 current_sym_code = DBX_REGPARM_STABS_CODE;
2246 regparm_letter = DBX_REGPARM_STABS_LETTER;
2247 current_sym_addr = 0;
2249 /* If parm lives in a register, use that register;
2250 pretend the parm was passed there. It would be more consistent
2251 to describe the register where the parm was passed,
2252 but in practice that register usually holds something else.
2254 If we use DECL_RTL, then we must use the declared type of
2255 the variable, not the type that it arrived in. */
2256 if (REGNO (DECL_RTL (parms)) >= 0
2257 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2259 best_rtl = DECL_RTL (parms);
2260 parm_type = TREE_TYPE (parms);
2262 /* If the parm lives nowhere, use the register where it was
2263 passed. It is also better to use the declared type here. */
2266 best_rtl = DECL_INCOMING_RTL (parms);
2267 parm_type = TREE_TYPE (parms);
2269 current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
2272 if (DECL_NAME (parms))
2274 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2275 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2276 IDENTIFIER_POINTER (DECL_NAME (parms)),
2281 current_sym_nchars = 8;
2282 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2286 dbxout_type (parm_type, 0, 0);
2287 dbxout_finish_symbol (parms);
2289 else if (GET_CODE (DECL_RTL (parms)) == MEM
2290 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2291 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
2292 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
2293 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2294 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
2298 /* Parm was passed via invisible reference.
2299 That is, its address was passed in a register.
2300 Output it as if it lived in that register.
2301 The debugger will know from the type
2302 that it was actually passed by invisible reference. */
2304 char regparm_letter;
2305 /* Parm passed in registers and lives in registers or nowhere. */
2307 current_sym_code = DBX_REGPARM_STABS_CODE;
2308 if (use_gnu_debug_info_extensions)
2309 regparm_letter = GDB_INV_REF_REGPARM_STABS_LETTER;
2311 regparm_letter = DBX_REGPARM_STABS_LETTER;
2313 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2314 If it is an unallocated pseudo-reg, then use the register where
2315 it was passed instead. */
2316 if (REGNO (XEXP (DECL_RTL (parms), 0)) >= 0
2317 && REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
2318 current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2320 current_sym_value = REGNO (DECL_INCOMING_RTL (parms));
2322 current_sym_addr = 0;
2325 if (DECL_NAME (parms))
2327 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2329 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2330 IDENTIFIER_POINTER (DECL_NAME (parms)),
2335 current_sym_nchars = 8;
2336 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2340 dbxout_type (TREE_TYPE (parms), 0, 0);
2341 dbxout_finish_symbol (parms);
2343 else if (GET_CODE (DECL_RTL (parms)) == MEM
2344 && XEXP (DECL_RTL (parms), 0) != const0_rtx
2345 /* ??? A constant address for a parm can happen
2346 when the reg it lives in is equiv to a constant in memory.
2347 Should make this not happen, after 2.4. */
2348 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
2350 /* Parm was passed in registers but lives on the stack. */
2352 current_sym_code = N_PSYM;
2353 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2354 in which case we want the value of that CONST_INT,
2355 or (MEM (REG ...)) or (MEM (MEM ...)),
2356 in which case we use a value of zero. */
2357 if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2358 || GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
2359 current_sym_value = 0;
2361 current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
2362 current_sym_addr = 0;
2365 if (DECL_NAME (parms))
2367 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2369 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2370 IDENTIFIER_POINTER (DECL_NAME (parms)),
2371 DBX_MEMPARM_STABS_LETTER);
2375 current_sym_nchars = 8;
2376 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2377 DBX_MEMPARM_STABS_LETTER);
2381 = DEBUGGER_ARG_OFFSET (current_sym_value,
2382 XEXP (DECL_RTL (parms), 0));
2383 dbxout_type (TREE_TYPE (parms), 0, 0);
2384 dbxout_finish_symbol (parms);
2389 /* Output definitions for the places where parms live during the function,
2390 when different from where they were passed, when the parms were passed
2393 It is not useful to do this for parms passed in registers
2394 that live during the function in different registers, because it is
2395 impossible to look in the passed register for the passed value,
2396 so we use the within-the-function register to begin with.
2398 PARMS is a chain of PARM_DECL nodes. */
2401 dbxout_reg_parms (parms)
2404 for (; parms; parms = TREE_CHAIN (parms))
2405 if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
2407 dbxout_prepare_symbol (parms);
2409 /* Report parms that live in registers during the function
2410 but were passed in memory. */
2411 if (GET_CODE (DECL_RTL (parms)) == REG
2412 && REGNO (DECL_RTL (parms)) >= 0
2413 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2414 dbxout_symbol_location (parms, TREE_TYPE (parms),
2415 0, DECL_RTL (parms));
2416 else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
2417 dbxout_symbol_location (parms, TREE_TYPE (parms),
2418 0, DECL_RTL (parms));
2419 /* Report parms that live in memory but not where they were passed. */
2420 else if (GET_CODE (DECL_RTL (parms)) == MEM
2421 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
2422 dbxout_symbol_location (parms, TREE_TYPE (parms),
2423 0, DECL_RTL (parms));
2427 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2428 output definitions of those names, in raw form */
2436 putc (',', asmfile);
2437 dbxout_type (TREE_VALUE (args), 0, 0);
2439 args = TREE_CHAIN (args);
2443 /* Given a chain of ..._TYPE nodes,
2444 find those which have typedef names and output those names.
2445 This is to ensure those types get output. */
2448 dbxout_types (types)
2449 register tree types;
2453 if (TYPE_NAME (types)
2454 && TREE_CODE (TYPE_NAME (types)) == TYPE_DECL
2455 && ! TREE_ASM_WRITTEN (TYPE_NAME (types)))
2456 dbxout_symbol (TYPE_NAME (types), 1);
2457 types = TREE_CHAIN (types);
2461 /* Output everything about a symbol block (a BLOCK node
2462 that represents a scope level),
2463 including recursive output of contained blocks.
2465 BLOCK is the BLOCK node.
2466 DEPTH is its depth within containing symbol blocks.
2467 ARGS is usually zero; but for the outermost block of the
2468 body of a function, it is a chain of PARM_DECLs for the function parameters.
2469 We output definitions of all the register parms
2470 as if they were local variables of that block.
2472 If -g1 was used, we count blocks just the same, but output nothing
2473 except for the outermost block.
2475 Actually, BLOCK may be several blocks chained together.
2476 We handle them all in sequence. */
2479 dbxout_block (block, depth, args)
2480 register tree block;
2488 /* Ignore blocks never expanded or otherwise marked as real. */
2489 if (TREE_USED (block))
2491 #ifndef DBX_LBRAC_FIRST
2492 /* In dbx format, the syms of a block come before the N_LBRAC. */
2493 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2494 dbxout_syms (BLOCK_VARS (block));
2496 dbxout_reg_parms (args);
2499 /* Now output an N_LBRAC symbol to represent the beginning of
2500 the block. Use the block's tree-walk order to generate
2501 the assembler symbols LBBn and LBEn
2502 that final will define around the code in this block. */
2503 if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE)
2506 blocknum = next_block_number++;
2507 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
2509 if (BLOCK_HANDLER_BLOCK (block))
2511 /* A catch block. Must precede N_LBRAC. */
2512 tree decl = BLOCK_VARS (block);
2515 #ifdef DBX_OUTPUT_CATCH
2516 DBX_OUTPUT_CATCH (asmfile, decl, buf);
2518 fprintf (asmfile, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP,
2519 IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
2520 assemble_name (asmfile, buf);
2521 fprintf (asmfile, "\n");
2523 decl = TREE_CHAIN (decl);
2527 #ifdef DBX_OUTPUT_LBRAC
2528 DBX_OUTPUT_LBRAC (asmfile, buf);
2530 fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_LBRAC);
2531 assemble_name (asmfile, buf);
2532 #if DBX_BLOCKS_FUNCTION_RELATIVE
2533 fputc ('-', asmfile);
2534 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
2536 fprintf (asmfile, "\n");
2540 /* Count blocks the same way regardless of debug_info_level. */
2541 next_block_number++;
2543 #ifdef DBX_LBRAC_FIRST
2544 /* On some weird machines, the syms of a block
2545 come after the N_LBRAC. */
2546 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2547 dbxout_syms (BLOCK_VARS (block));
2549 dbxout_reg_parms (args);
2552 /* Output the subblocks. */
2553 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
2555 /* Refer to the marker for the end of the block. */
2556 if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE)
2559 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
2560 #ifdef DBX_OUTPUT_RBRAC
2561 DBX_OUTPUT_RBRAC (asmfile, buf);
2563 fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_RBRAC);
2564 assemble_name (asmfile, buf);
2565 #if DBX_BLOCKS_FUNCTION_RELATIVE
2566 fputc ('-', asmfile);
2567 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
2569 fprintf (asmfile, "\n");
2573 block = BLOCK_CHAIN (block);
2577 /* Output the information about a function and its arguments and result.
2578 Usually this follows the function's code,
2579 but on some systems, it comes before. */
2582 dbxout_really_begin_function (decl)
2585 dbxout_symbol (decl, 0);
2586 dbxout_parms (DECL_ARGUMENTS (decl));
2587 if (DECL_NAME (DECL_RESULT (decl)) != 0)
2588 dbxout_symbol (DECL_RESULT (decl), 1);
2591 /* Called at beginning of output of function definition. */
2594 dbxout_begin_function (decl)
2597 #ifdef DBX_FUNCTION_FIRST
2598 dbxout_really_begin_function (decl);
2602 /* Output dbx data for a function definition.
2603 This includes a definition of the function name itself (a symbol),
2604 definitions of the parameters (locating them in the parameter list)
2605 and then output the block that makes up the function's body
2606 (including all the auto variables of the function). */
2609 dbxout_function (decl)
2612 #ifndef DBX_FUNCTION_FIRST
2613 dbxout_really_begin_function (decl);
2615 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
2616 #ifdef DBX_OUTPUT_FUNCTION_END
2617 DBX_OUTPUT_FUNCTION_END (asmfile, decl);
2619 #if defined(ASM_OUTPUT_SECTION_NAME)
2620 if (use_gnu_debug_info_extensions
2621 #if defined(NO_DBX_FUNCTION_END)
2622 && ! NO_DBX_FUNCTION_END
2625 dbxout_function_end ();
2628 #endif /* DBX_DEBUGGING_INFO */