1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* Output dbx-format symbol table data.
24 This consists of many symbol table entries, each of them
25 a .stabs assembler pseudo-op with four operands:
26 a "name" which is really a description of one symbol and its type,
27 a "code", which is a symbol defined in stab.h whose name starts with N_,
28 an unused operand always 0,
29 and a "value" which is an address or an offset.
30 The name is enclosed in doublequote characters.
32 Each function, variable, typedef, and structure tag
33 has a symbol table entry to define it.
34 The beginning and end of each level of name scoping within
35 a function are also marked by special symbol table entries.
37 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
38 and a data type number. The data type number may be followed by
39 "=" and a type definition; normally this will happen the first time
40 the type number is mentioned. The type definition may refer to
41 other types by number, and those type numbers may be followed
42 by "=" and nested definitions.
44 This can make the "name" quite long.
45 When a name is more than 80 characters, we split the .stabs pseudo-op
46 into two .stabs pseudo-ops, both sharing the same "code" and "value".
47 The first one is marked as continued with a double-backslash at the
50 The kind-of-symbol letter distinguished function names from global
51 variables from file-scope variables from parameters from auto
52 variables in memory from typedef names from register variables.
55 The "code" is mostly redundant with the kind-of-symbol letter
56 that goes in the "name", but not entirely: for symbols located
57 in static storage, the "code" says which segment the address is in,
58 which controls how it is relocated.
60 The "value" for a symbol in static storage
61 is the core address of the symbol (actually, the assembler
62 label for the symbol). For a symbol located in a stack slot
63 it is the stack offset; for one in a register, the register number.
64 For a typedef symbol, it is zero.
66 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
67 output while in the text section.
69 For more on data type definitions, see `dbxout_type'. */
78 #include "insn-config.h"
80 #include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions. */
86 #ifdef XCOFF_DEBUGGING_INFO
91 #define ASM_STABS_OP "\t.stabs\t"
95 #define ASM_STABN_OP "\t.stabn\t"
98 #ifndef DBX_TYPE_DECL_STABS_CODE
99 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
102 #ifndef DBX_STATIC_CONST_VAR_CODE
103 #define DBX_STATIC_CONST_VAR_CODE N_FUN
106 #ifndef DBX_REGPARM_STABS_CODE
107 #define DBX_REGPARM_STABS_CODE N_RSYM
110 #ifndef DBX_REGPARM_STABS_LETTER
111 #define DBX_REGPARM_STABS_LETTER 'P'
114 /* This is used for parameters passed by invisible reference in a register. */
115 #ifndef GDB_INV_REF_REGPARM_STABS_LETTER
116 #define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
119 #ifndef DBX_MEMPARM_STABS_LETTER
120 #define DBX_MEMPARM_STABS_LETTER 'p'
123 #ifndef FILE_NAME_JOINER
124 #define FILE_NAME_JOINER "/"
127 /* Nonzero means if the type has methods, only output debugging
128 information if methods are actually written to the asm file. This
129 optimization only works if the debugger can detect the special C++
132 #define MINIMAL_DEBUG 1
134 #ifdef NO_DOLLAR_IN_LABEL
135 #ifdef NO_DOT_IN_LABEL
137 #define MINIMAL_DEBUG 0
141 /* Typical USG systems don't have stab.h, and they also have
142 no use for DBX-format debugging info. */
144 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
146 static int flag_minimal_debug = MINIMAL_DEBUG;
148 /* Nonzero if we have actually used any of the GDB extensions
149 to the debugging format. The idea is that we use them for the
150 first time only if there's a strong reason, but once we have done that,
151 we use them whenever convenient. */
153 static int have_used_extensions = 0;
155 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
156 for the N_SO filename stabs label. */
158 static int source_label_number = 1;
160 #ifdef DEBUG_SYMS_TEXT
161 #define FORCE_TEXT text_section ();
166 /* If there is a system stab.h, use it. Otherwise, use our own. */
167 /* ??? This is supposed to describe the target's stab format, so using
168 the host HAVE_STAB_H appears to be wrong. For now, we use our own file
169 when cross compiling. */
170 #if defined (USG) || !defined (HAVE_STAB_H) || defined (CROSS_COMPILE)
171 #include "gstab.h" /* If doing DBX on sysV, use our own stab.h. */
175 /* This is a GNU extension we need to reference in this file. */
182 #define STAB_CODE_TYPE enum __stab_debug_code
184 #define STAB_CODE_TYPE int
187 /* 1 if PARM is passed to this function in memory. */
189 #define PARM_PASSED_IN_MEMORY(PARM) \
190 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
192 /* A C expression for the integer offset value of an automatic variable
193 (N_LSYM) having address X (an RTX). */
194 #ifndef DEBUGGER_AUTO_OFFSET
195 #define DEBUGGER_AUTO_OFFSET(X) \
196 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
199 /* A C expression for the integer offset value of an argument (N_PSYM)
200 having address X (an RTX). The nominal offset is OFFSET. */
201 #ifndef DEBUGGER_ARG_OFFSET
202 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
205 /* Stream for writing to assembler file. */
207 static FILE *asmfile;
209 /* Last source file name mentioned in a NOTE insn. */
211 static const char *lastfile;
213 /* Current working directory. */
215 static const char *cwd;
217 enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
219 /* Structure recording information about a C data type.
220 The status element says whether we have yet output
221 the definition of the type. TYPE_XREF says we have
222 output it as a cross-reference only.
223 The file_number and type_number elements are used if DBX_USE_BINCL
228 enum typestatus status;
235 /* Vector recording information about C data types.
236 When we first notice a data type (a tree node),
237 we assign it a number using next_type_number.
238 That is its index in this vector. */
240 struct typeinfo *typevec;
242 /* Number of elements of space allocated in `typevec'. */
244 static int typevec_len;
246 /* In dbx output, each type gets a unique number.
247 This is the number for the next type output.
248 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
250 static int next_type_number;
254 /* When using N_BINCL in dbx output, each type number is actually a
255 pair of the file number and the type number within the file.
256 This is a stack of input files. */
260 struct dbx_file *next;
262 int next_type_number;
265 /* This is the top of the stack. */
267 static struct dbx_file *current_file;
269 /* This is the next file number to use. */
271 static int next_file_number;
273 #endif /* DBX_USE_BINCL */
275 /* These variables are for dbxout_symbol to communicate to
276 dbxout_finish_symbol.
277 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
278 current_sym_value and current_sym_addr are two ways to address the
279 value to store in the symtab entry.
280 current_sym_addr if nonzero represents the value as an rtx.
281 If that is zero, current_sym_value is used. This is used
282 when the value is an offset (such as for auto variables,
283 register variables and parms). */
285 static STAB_CODE_TYPE current_sym_code;
286 static int current_sym_value;
287 static rtx current_sym_addr;
289 /* Number of chars of symbol-description generated so far for the
290 current symbol. Used by CHARS and CONTIN. */
292 static int current_sym_nchars;
294 /* Report having output N chars of the current symbol-description. */
296 #define CHARS(N) (current_sym_nchars += (N))
298 /* Break the current symbol-description, generating a continuation,
299 if it has become long. */
301 #ifndef DBX_CONTIN_LENGTH
302 #define DBX_CONTIN_LENGTH 80
305 #if DBX_CONTIN_LENGTH > 0
307 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
309 #define CONTIN do { } while (0)
312 #if defined(ASM_OUTPUT_SECTION_NAME)
313 static void dbxout_function_end PARAMS ((void));
315 static void dbxout_typedefs PARAMS ((tree));
316 static void dbxout_type_index PARAMS ((tree));
317 #if DBX_CONTIN_LENGTH > 0
318 static void dbxout_continue PARAMS ((void));
320 static void dbxout_type_fields PARAMS ((tree));
321 static void dbxout_type_method_1 PARAMS ((tree, const char *));
322 static void dbxout_type_methods PARAMS ((tree));
323 static void dbxout_range_type PARAMS ((tree));
324 static void dbxout_type PARAMS ((tree, int, int));
325 static void print_int_cst_octal PARAMS ((tree));
326 static void print_octal PARAMS ((unsigned HOST_WIDE_INT, int));
327 static void dbxout_type_name PARAMS ((tree));
328 static int dbxout_symbol_location PARAMS ((tree, tree, const char *, rtx));
329 static void dbxout_symbol_name PARAMS ((tree, const char *, int));
330 static void dbxout_prepare_symbol PARAMS ((tree));
331 static void dbxout_finish_symbol PARAMS ((tree));
332 static void dbxout_block PARAMS ((tree, int, tree));
333 static void dbxout_really_begin_function PARAMS ((tree));
335 #if defined(ASM_OUTPUT_SECTION_NAME)
337 dbxout_function_end ()
339 static int scope_labelno = 0;
340 char lscope_label_name[100];
341 /* Convert Ltext into the appropriate format for local labels in case
342 the system doesn't insert underscores in front of user generated
344 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
345 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Lscope", scope_labelno);
348 /* By convention, GCC will mark the end of a function with an N_FUN
349 symbol and an empty string. */
350 fprintf (asmfile, "%s\"\",%d,0,0,", ASM_STABS_OP, N_FUN);
351 assemble_name (asmfile, lscope_label_name);
352 fputc ('-', asmfile);
353 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
354 fprintf (asmfile, "\n");
356 #endif /* ! NO_DBX_FUNCTION_END */
358 /* At the beginning of compilation, start writing the symbol table.
359 Initialize `typevec' and output the standard data types of C. */
362 dbxout_init (asm_file, input_file_name, syms)
364 const char *input_file_name;
367 char ltext_label_name[100];
372 typevec = (struct typeinfo *) xcalloc (typevec_len, sizeof typevec[0]);
374 /* Convert Ltext into the appropriate format for local labels in case
375 the system doesn't insert underscores in front of user generated
377 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
379 /* Put the current working directory in an N_SO symbol. */
380 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
381 but GDB always does. */
382 if (use_gnu_debug_info_extensions)
385 if (!cwd && (cwd = getpwd ()) && (!*cwd || cwd[strlen (cwd) - 1] != '/'))
387 char *wdslash = xmalloc (strlen (cwd) + sizeof (FILE_NAME_JOINER));
388 sprintf (wdslash, "%s%s", cwd, FILE_NAME_JOINER);
393 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
394 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd);
395 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
396 fprintf (asmfile, "%s", ASM_STABS_OP);
397 output_quoted_string (asmfile, cwd);
398 fprintf (asmfile, ",%d,0,0,%s\n", N_SO, <ext_label_name[1]);
399 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
403 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
404 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
405 would give us an N_SOL, and we want an N_SO. */
406 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile, input_file_name);
407 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
408 /* We include outputting `Ltext:' here,
409 because that gives you a way to override it. */
410 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
411 fprintf (asmfile, "%s", ASM_STABS_OP);
412 output_quoted_string (asmfile, input_file_name);
413 fprintf (asmfile, ",%d,0,0,%s\n",
414 N_SO, <ext_label_name[1]);
416 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Ltext", 0);
417 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
419 /* Possibly output something to inform GDB that this compilation was by
420 GCC. It's easier for GDB to parse it when after the N_SO's. This
421 is used in Solaris 2. */
422 #ifdef ASM_IDENTIFY_GCC_AFTER_SOURCE
423 ASM_IDENTIFY_GCC_AFTER_SOURCE (asmfile);
426 lastfile = input_file_name;
428 next_type_number = 1;
431 current_file = (struct dbx_file *) xmalloc (sizeof *current_file);
432 current_file->next = NULL;
433 current_file->file_number = 0;
434 current_file->next_type_number = 1;
435 next_file_number = 1;
438 /* Make sure that types `int' and `char' have numbers 1 and 2.
439 Definitions of other integer types will refer to those numbers.
440 (Actually it should no longer matter what their numbers are.
441 Also, if any types with tags have been defined, dbxout_symbol
442 will output them first, so the numbers won't be 1 and 2. That
443 happens in C++. So it's a good thing it should no longer matter). */
445 #ifdef DBX_OUTPUT_STANDARD_TYPES
446 DBX_OUTPUT_STANDARD_TYPES (syms);
448 dbxout_symbol (TYPE_NAME (integer_type_node), 0);
449 dbxout_symbol (TYPE_NAME (char_type_node), 0);
452 /* Get all permanent types that have typedef names,
453 and output them all, except for those already output. */
455 dbxout_typedefs (syms);
458 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
459 in the reverse order from that which is found in SYMS. */
462 dbxout_typedefs (syms)
467 dbxout_typedefs (TREE_CHAIN (syms));
468 if (TREE_CODE (syms) == TYPE_DECL)
470 tree type = TREE_TYPE (syms);
472 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
473 && COMPLETE_TYPE_P (type)
474 && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
475 dbxout_symbol (TYPE_NAME (type), 0);
480 /* Change to reading from a new source file. Generate a N_BINCL stab. */
483 dbxout_start_new_source_file (filename)
484 const char *filename ATTRIBUTE_UNUSED;
487 struct dbx_file *n = (struct dbx_file *) xmalloc (sizeof *n);
489 n->next = current_file;
490 n->file_number = next_file_number++;
491 n->next_type_number = 1;
493 fprintf (asmfile, "%s", ASM_STABS_OP);
494 output_quoted_string (asmfile, filename);
495 fprintf (asmfile, ",%d,0,0,0\n", N_BINCL);
499 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
502 dbxout_resume_previous_source_file ()
505 struct dbx_file *next;
507 fprintf (asmfile, "%s%d,0,0,0\n", ASM_STABN_OP, N_EINCL);
508 next = current_file->next;
514 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
517 dbxout_source_file (file, filename)
519 const char *filename;
521 char ltext_label_name[100];
523 if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
525 #ifdef DBX_OUTPUT_SOURCE_FILENAME
526 DBX_OUTPUT_SOURCE_FILENAME (file, filename);
528 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext",
529 source_label_number);
530 fprintf (file, "%s", ASM_STABS_OP);
531 output_quoted_string (file, filename);
532 fprintf (file, ",%d,0,0,%s\n", N_SOL, <ext_label_name[1]);
533 if (current_function_decl != NULL_TREE
534 && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
535 ; /* Don't change section amid function. */
538 ASM_OUTPUT_INTERNAL_LABEL (file, "Ltext", source_label_number);
539 source_label_number++;
545 /* Output a line number symbol entry into output stream FILE,
546 for source file FILENAME and line number LINENO. */
549 dbxout_source_line (file, filename, lineno)
551 const char *filename;
554 dbxout_source_file (file, filename);
556 #ifdef ASM_OUTPUT_SOURCE_LINE
557 ASM_OUTPUT_SOURCE_LINE (file, lineno);
559 fprintf (file, "%s%d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno);
563 /* At the end of compilation, finish writing the symbol table.
564 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
568 dbxout_finish (file, filename)
569 FILE *file ATTRIBUTE_UNUSED;
570 const char *filename ATTRIBUTE_UNUSED;
572 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
573 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file, filename);
574 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
577 /* Output the index of a type. */
580 dbxout_type_index (type)
583 #ifndef DBX_USE_BINCL
584 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
587 struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
588 fprintf (asmfile, "(%d,%d)", t->file_number, t->type_number);
593 #if DBX_CONTIN_LENGTH > 0
594 /* Continue a symbol-description that gets too big.
595 End one symbol table entry with a double-backslash
596 and start a new one, eventually producing something like
597 .stabs "start......\\",code,0,value
598 .stabs "...rest",code,0,value */
603 #ifdef DBX_CONTIN_CHAR
604 fprintf (asmfile, "%c", DBX_CONTIN_CHAR);
606 fprintf (asmfile, "\\\\");
608 dbxout_finish_symbol (NULL_TREE);
609 fprintf (asmfile, "%s\"", ASM_STABS_OP);
610 current_sym_nchars = 0;
612 #endif /* DBX_CONTIN_LENGTH > 0 */
614 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
615 This must be a separate function because anonymous unions require
619 dbxout_type_fields (type)
624 /* Output the name, type, position (in bits), size (in bits) of each
625 field that we can support. */
626 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
628 /* Omit here local type decls until we know how to support them. */
629 if (TREE_CODE (tem) == TYPE_DECL
630 /* Omit fields whose position or size are variable or too large to
632 || (TREE_CODE (tem) == FIELD_DECL
633 && (! host_integerp (bit_position (tem), 0)
635 || ! host_integerp (DECL_SIZE (tem), 1)))
636 /* Omit here the nameless fields that are used to skip bits. */
637 || DECL_IGNORED_P (tem))
640 else if (TREE_CODE (tem) != CONST_DECL)
642 /* Continue the line if necessary,
643 but not before the first field. */
644 if (tem != TYPE_FIELDS (type))
647 if (use_gnu_debug_info_extensions
648 && flag_minimal_debug
649 && TREE_CODE (tem) == FIELD_DECL
650 && DECL_VIRTUAL_P (tem)
651 && DECL_ASSEMBLER_NAME (tem))
653 have_used_extensions = 1;
654 CHARS (3 + IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (tem)));
655 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem)), asmfile);
656 dbxout_type (DECL_FCONTEXT (tem), 0, 0);
657 fprintf (asmfile, ":");
658 dbxout_type (TREE_TYPE (tem), 0, 0);
659 fputc (',', asmfile);
660 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
661 int_bit_position (tem));
662 fputc (';', asmfile);
668 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
669 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem)));
673 fprintf (asmfile, ":");
677 if (use_gnu_debug_info_extensions
678 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
679 || TREE_CODE (tem) != FIELD_DECL))
681 have_used_extensions = 1;
683 putc ((TREE_PRIVATE (tem) ? '0'
684 : TREE_PROTECTED (tem) ? '1' : '2'),
689 dbxout_type ((TREE_CODE (tem) == FIELD_DECL
690 && DECL_BIT_FIELD_TYPE (tem))
691 ? DECL_BIT_FIELD_TYPE (tem) : TREE_TYPE (tem), 0, 0);
693 if (TREE_CODE (tem) == VAR_DECL)
695 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
698 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem));
699 have_used_extensions = 1;
700 fprintf (asmfile, ":%s;", name);
701 CHARS (strlen (name));
704 /* If TEM is non-static, GDB won't understand it. */
705 fprintf (asmfile, ",0,0;");
709 fputc (',', asmfile);
710 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
711 int_bit_position (tem));
712 fputc (',', asmfile);
713 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
714 tree_low_cst (DECL_SIZE (tem), 1));
715 fputc (';', asmfile);
722 /* Subroutine of `dbxout_type_methods'. Output debug info about the
723 method described DECL. DEBUG_NAME is an encoding of the method's
724 type signature. ??? We may be able to do without DEBUG_NAME altogether
728 dbxout_type_method_1 (decl, debug_name)
730 const char *debug_name;
734 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
736 else /* it's a METHOD_TYPE. */
738 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
739 /* A for normal functions.
740 B for `const' member functions.
741 C for `volatile' member functions.
742 D for `const volatile' member functions. */
743 if (TYPE_READONLY (TREE_TYPE (firstarg)))
745 if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
748 if (DECL_VINDEX (decl))
754 fprintf (asmfile, ":%s;%c%c%c", debug_name,
755 TREE_PRIVATE (decl) ? '0'
756 : TREE_PROTECTED (decl) ? '1' : '2', c1, c2);
757 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)) + 6
758 - (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
760 if (DECL_VINDEX (decl) && host_integerp (DECL_VINDEX (decl), 0))
762 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
763 tree_low_cst (DECL_VINDEX (decl), 0));
764 fputc (';', asmfile);
765 dbxout_type (DECL_CONTEXT (decl), 0, 0);
766 fprintf (asmfile, ";");
771 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
775 dbxout_type_methods (type)
778 /* C++: put out the method names and their parameter lists */
779 tree methods = TYPE_METHODS (type);
781 register tree fndecl;
783 char formatted_type_identifier_length[16];
784 register int type_identifier_length;
786 if (methods == NULL_TREE)
789 type_encoding = DECL_NAME (TYPE_NAME (type));
792 /* C++: Template classes break some assumptions made by this code about
793 the class names, constructor names, and encodings for assembler
794 label names. For now, disable output of dbx info for them. */
796 const char *ptr = IDENTIFIER_POINTER (type_encoding);
797 /* This should use index. (mrs) */
798 while (*ptr && *ptr != '<') ptr++;
809 type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
811 sprintf(formatted_type_identifier_length, "%d", type_identifier_length);
813 if (TREE_CODE (methods) != TREE_VEC)
815 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
816 fndecl = TREE_VEC_ELT (methods, 0);
818 fndecl = TREE_VEC_ELT (methods, 1);
822 tree name = DECL_NAME (fndecl);
825 /* Group together all the methods for the same operation.
826 These differ in the types of the arguments. */
827 for (last = NULL_TREE;
828 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
829 fndecl = TREE_CHAIN (fndecl))
830 /* Output the name of the field (after overloading), as
831 well as the name of the field before overloading, along
832 with its parameter list */
834 /* This is the "mangled" name of the method.
835 It encodes the argument types. */
836 const char *debug_name;
837 int show_arg_types = 0;
839 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
840 include TEMPLATE_DECLs.) The debugger doesn't know what
841 to do with such entities anyhow. */
842 if (TREE_CODE (fndecl) != FUNCTION_DECL)
846 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
852 /* Also ignore abstract methods; those are only interesting to
853 the DWARF backends. */
854 if (DECL_IGNORED_P (fndecl) || DECL_ABSTRACT (fndecl))
857 if (flag_minimal_debug)
861 /* We can't optimize a method which uses an anonymous
862 class, because the debugger will not be able to
863 associate the arbitrary class name with the actual
865 #ifndef NO_DOLLAR_IN_LABEL
870 if (strchr (debug_name, marker))
872 /* Detect ordinary methods because their mangled names
873 start with the operation name. */
874 else if (!strncmp (IDENTIFIER_POINTER (name), debug_name,
875 IDENTIFIER_LENGTH (name)))
877 debug_name += IDENTIFIER_LENGTH (name);
878 if (debug_name[0] == '_' && debug_name[1] == '_')
880 const char *method_name = debug_name + 2;
881 const char *length_ptr =
882 formatted_type_identifier_length;
883 /* Get past const and volatile qualifiers. */
884 while (*method_name == 'C' || *method_name == 'V')
886 /* Skip digits for length of type_encoding. */
887 while (*method_name == *length_ptr && *length_ptr)
888 length_ptr++, method_name++;
889 if (! strncmp (method_name,
890 IDENTIFIER_POINTER (type_encoding),
891 type_identifier_length))
892 method_name += type_identifier_length;
893 debug_name = method_name;
896 /* Detect constructors by their style of name mangling. */
897 else if (debug_name[0] == '_' && debug_name[1] == '_')
899 const char *ctor_name = debug_name + 2;
900 const char *length_ptr = formatted_type_identifier_length;
901 while (*ctor_name == 'C' || *ctor_name == 'V')
903 /* Skip digits for length of type_encoding. */
904 while (*ctor_name == *length_ptr && *length_ptr)
905 length_ptr++, ctor_name++;
906 if (!strncmp (IDENTIFIER_POINTER (type_encoding), ctor_name,
907 type_identifier_length))
908 debug_name = ctor_name + type_identifier_length;
910 /* The other alternative is a destructor. */
914 /* Output the operation name just once, for the first method
918 fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
919 CHARS (IDENTIFIER_LENGTH (name) + 2);
924 dbxout_type (TREE_TYPE (fndecl), 0, show_arg_types);
926 dbxout_type_method_1 (fndecl, debug_name);
936 /* Emit a "range" type specification, which has the form:
937 "r<index type>;<lower bound>;<upper bound>;".
938 TYPE is an INTEGER_TYPE. */
941 dbxout_range_type (type)
944 fprintf (asmfile, "r");
945 if (TREE_TYPE (type))
946 dbxout_type (TREE_TYPE (type), 0, 0);
947 else if (TREE_CODE (type) != INTEGER_TYPE)
948 dbxout_type (type, 0, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
951 /* Traditionally, we made sure 'int' was type 1, and builtin types
952 were defined to be sub-ranges of int. Unfortunately, this
953 does not allow us to distinguish true sub-ranges from integer
954 types. So, instead we define integer (non-sub-range) types as
955 sub-ranges of themselves. This matters for Chill. If this isn't
956 a subrange type, then we want to define it in terms of itself.
957 However, in C, this may be an anonymous integer type, and we don't
958 want to emit debug info referring to it. Just calling
959 dbxout_type_index won't work anyways, because the type hasn't been
960 defined yet. We make this work for both cases by checked to see
961 whether this is a defined type, referring to it if it is, and using
963 if (TYPE_SYMTAB_ADDRESS (type) != 0)
964 dbxout_type_index (type);
966 dbxout_type_index (integer_type_node);
969 if (TYPE_MIN_VALUE (type) != 0
970 && host_integerp (TYPE_MIN_VALUE (type), 0))
972 fputc (';', asmfile);
973 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
974 tree_low_cst (TYPE_MIN_VALUE (type), 0));
977 fprintf (asmfile, ";0");
979 if (TYPE_MAX_VALUE (type) != 0
980 && host_integerp (TYPE_MAX_VALUE (type), 0))
982 fputc (';', asmfile);
983 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
984 tree_low_cst (TYPE_MAX_VALUE (type), 0));
985 fputc (';', asmfile);
988 fprintf (asmfile, ";-1;");
991 /* Output a reference to a type. If the type has not yet been
992 described in the dbx output, output its definition now.
993 For a type already defined, just refer to its definition
994 using the type number.
996 If FULL is nonzero, and the type has been described only with
997 a forward-reference, output the definition now.
998 If FULL is zero in this case, just refer to the forward-reference
999 using the number previously allocated.
1001 If SHOW_ARG_TYPES is nonzero, we output a description of the argument
1002 types for a METHOD_TYPE. */
1005 dbxout_type (type, full, show_arg_types)
1011 static int anonymous_type_number = 0;
1013 if (TREE_CODE (type) == VECTOR_TYPE)
1014 type = TYPE_DEBUG_REPRESENTATION_TYPE (type);
1016 /* If there was an input error and we don't really have a type,
1017 avoid crashing and write something that is at least valid
1018 by assuming `int'. */
1019 if (type == error_mark_node)
1020 type = integer_type_node;
1023 /* Try to find the "main variant" with the same name but not const
1024 or volatile. (Since stabs does not distinguish const and volatile,
1025 there is no need to make them separate types. But types with
1026 different names are usefully distinguished.) */
1028 for (tem = TYPE_MAIN_VARIANT (type); tem; tem = TYPE_NEXT_VARIANT (tem))
1029 if (!TYPE_READONLY (tem) && !TYPE_VOLATILE (tem)
1030 && TYPE_NAME (tem) == TYPE_NAME (type))
1035 if (TYPE_NAME (type)
1036 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1037 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
1041 if (TYPE_SYMTAB_ADDRESS (type) == 0)
1043 /* Type has no dbx number assigned. Assign next available number. */
1044 TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
1046 /* Make sure type vector is long enough to record about this type. */
1048 if (next_type_number == typevec_len)
1051 = (struct typeinfo *) xrealloc (typevec,
1052 typevec_len * 2 * sizeof typevec[0]);
1053 memset ((char *) (typevec + typevec_len), 0,
1054 typevec_len * sizeof typevec[0]);
1058 #ifdef DBX_USE_BINCL
1059 typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
1060 = current_file->file_number;
1061 typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
1062 = current_file->next_type_number++;
1066 /* Output the number of this type, to refer to it. */
1067 dbxout_type_index (type);
1069 #ifdef DBX_TYPE_DEFINED
1070 if (DBX_TYPE_DEFINED (type))
1074 /* If this type's definition has been output or is now being output,
1077 switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
1082 /* If we have already had a cross reference,
1083 and either that's all we want or that's the best we could do,
1084 don't repeat the cross reference.
1085 Sun dbx crashes if we do. */
1086 if (! full || !COMPLETE_TYPE_P (type)
1087 /* No way in DBX fmt to describe a variable size. */
1088 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1096 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1097 leave the type-number completely undefined rather than output
1098 a cross-reference. If we have already used GNU debug info extensions,
1099 then it is OK to output a cross reference. This is necessary to get
1100 proper C++ debug output. */
1101 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
1102 || TREE_CODE (type) == QUAL_UNION_TYPE
1103 || TREE_CODE (type) == ENUMERAL_TYPE)
1104 && ! use_gnu_debug_info_extensions)
1105 /* We must use the same test here as we use twice below when deciding
1106 whether to emit a cross-reference. */
1107 if ((TYPE_NAME (type) != 0
1108 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1109 && DECL_IGNORED_P (TYPE_NAME (type)))
1111 || !COMPLETE_TYPE_P (type)
1112 /* No way in DBX fmt to describe a variable size. */
1113 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1115 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1120 /* Output a definition now. */
1122 fprintf (asmfile, "=");
1125 /* Mark it as defined, so that if it is self-referent
1126 we will not get into an infinite recursion of definitions. */
1128 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
1130 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1131 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1133 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0, 0);
1137 switch (TREE_CODE (type))
1141 /* For a void type, just define it as itself; ie, "5=5".
1142 This makes us consider it defined
1143 without saying what it is. The debugger will make it
1144 a void type when the reference is seen, and nothing will
1145 ever override that default. */
1146 dbxout_type_index (type);
1150 if (type == char_type_node && ! TREE_UNSIGNED (type))
1152 /* Output the type `char' as a subrange of itself!
1153 I don't understand this definition, just copied it
1154 from the output of pcc.
1155 This used to use `r2' explicitly and we used to
1156 take care to make sure that `char' was type number 2. */
1157 fprintf (asmfile, "r");
1158 dbxout_type_index (type);
1159 fprintf (asmfile, ";0;127;");
1162 /* If this is a subtype of another integer type, always prefer to
1163 write it as a subtype. */
1164 else if (TREE_TYPE (type) != 0
1165 && TREE_CODE (TREE_TYPE (type)) == INTEGER_CST)
1166 dbxout_range_type (type);
1170 /* If the size is non-standard, say what it is if we can use
1173 if (use_gnu_debug_info_extensions
1174 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1175 fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1177 /* If we can use GDB extensions and the size is wider than a
1178 long (the size used by GDB to read them) or we may have
1179 trouble writing the bounds the usual way, write them in
1180 octal. Note the test is for the *target's* size of "long",
1181 not that of the host. The host test is just to make sure we
1182 can write it out in case the host wide int is narrower than the
1185 /* For unsigned types, we use octal if they are the same size or
1186 larger. This is because we print the bounds as signed decimal,
1187 and hence they can't span same size unsigned types. */
1189 if (use_gnu_debug_info_extensions
1190 && TYPE_MIN_VALUE (type) != 0
1191 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
1192 && TYPE_MAX_VALUE (type) != 0
1193 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
1194 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
1195 || (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)
1196 && TREE_UNSIGNED (type))
1197 || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
1198 || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
1199 && TREE_UNSIGNED (type))))
1201 fprintf (asmfile, "r");
1202 dbxout_type_index (type);
1203 fprintf (asmfile, ";");
1204 print_int_cst_octal (TYPE_MIN_VALUE (type));
1205 fprintf (asmfile, ";");
1206 print_int_cst_octal (TYPE_MAX_VALUE (type));
1207 fprintf (asmfile, ";");
1211 /* Output other integer types as subranges of `int'. */
1212 dbxout_range_type (type);
1219 /* This used to say `r1' and we used to take care
1220 to make sure that `int' was type number 1. */
1221 fprintf (asmfile, "r");
1222 dbxout_type_index (integer_type_node);
1223 fputc (';', asmfile);
1224 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, int_size_in_bytes (type));
1225 fputs (";0;", asmfile);
1230 if (use_gnu_debug_info_extensions)
1232 fputs ("@s", asmfile);
1233 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1234 BITS_PER_UNIT * int_size_in_bytes (type));
1235 fputs (";-20;", asmfile);
1239 /* Output the type `char' as a subrange of itself.
1240 That is what pcc seems to do. */
1241 fprintf (asmfile, "r");
1242 dbxout_type_index (char_type_node);
1243 fprintf (asmfile, ";0;%d;", TREE_UNSIGNED (type) ? 255 : 127);
1249 if (use_gnu_debug_info_extensions)
1251 fputs ("@s", asmfile);
1252 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1253 BITS_PER_UNIT * int_size_in_bytes (type));
1254 fputs (";-16;", asmfile);
1256 else /* Define as enumeral type (False, True) */
1257 fprintf (asmfile, "eFalse:0,True:1,;");
1262 putc ('d', asmfile);
1264 dbxout_type (TREE_TYPE (type), 0, 0);
1268 /* Differs from the REAL_TYPE by its new data type number */
1270 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1272 fprintf (asmfile, "r");
1273 dbxout_type_index (type);
1274 fputc (';', asmfile);
1275 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1276 2 * int_size_in_bytes (TREE_TYPE (type)));
1277 fputs (";0;", asmfile);
1278 CHARS (12); /* The number is probably incorrect here. */
1282 /* Output a complex integer type as a structure,
1283 pending some other way to do it. */
1284 fputc ('s', asmfile);
1285 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, int_size_in_bytes (type));
1287 fprintf (asmfile, "real:");
1289 dbxout_type (TREE_TYPE (type), 0, 0);
1290 fprintf (asmfile, ",%d,%d;",
1291 0, TYPE_PRECISION (TREE_TYPE (type)));
1293 fprintf (asmfile, "imag:");
1295 dbxout_type (TREE_TYPE (type), 0, 0);
1296 fprintf (asmfile, ",%d,%d;;",
1297 TYPE_PRECISION (TREE_TYPE (type)),
1298 TYPE_PRECISION (TREE_TYPE (type)));
1304 if (use_gnu_debug_info_extensions)
1306 have_used_extensions = 1;
1307 fputs ("@s", asmfile);
1308 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1309 BITS_PER_UNIT * int_size_in_bytes (type));
1310 fputc (';', asmfile);
1311 /* Check if a bitstring type, which in Chill is
1312 different from a [power]set. */
1313 if (TYPE_STRING_FLAG (type))
1314 fprintf (asmfile, "@S;");
1316 putc ('S', asmfile);
1318 dbxout_type (TYPE_DOMAIN (type), 0, 0);
1322 /* Make arrays of packed bits look like bitstrings for chill. */
1323 if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
1325 have_used_extensions = 1;
1326 fputs ("@s", asmfile);
1327 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1328 BITS_PER_UNIT * int_size_in_bytes (type));
1329 fputc (';', asmfile);
1330 fprintf (asmfile, "@S;");
1331 putc ('S', asmfile);
1333 dbxout_type (TYPE_DOMAIN (type), 0, 0);
1336 /* Output "a" followed by a range type definition
1337 for the index type of the array
1338 followed by a reference to the target-type.
1339 ar1;0;N;M for a C array of type M and size N+1. */
1340 /* Check if a character string type, which in Chill is
1341 different from an array of characters. */
1342 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
1344 have_used_extensions = 1;
1345 fprintf (asmfile, "@S;");
1347 tem = TYPE_DOMAIN (type);
1350 fprintf (asmfile, "ar");
1351 dbxout_type_index (integer_type_node);
1352 fprintf (asmfile, ";0;-1;");
1356 fprintf (asmfile, "a");
1357 dbxout_range_type (tem);
1360 dbxout_type (TREE_TYPE (type), 0, 0);
1365 case QUAL_UNION_TYPE:
1367 int i, n_baseclasses = 0;
1369 if (TYPE_BINFO (type) != 0
1370 && TREE_CODE (TYPE_BINFO (type)) == TREE_VEC
1371 && TYPE_BINFO_BASETYPES (type) != 0)
1372 n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
1374 /* Output a structure type. We must use the same test here as we
1375 use in the DBX_NO_XREFS case above. */
1376 if ((TYPE_NAME (type) != 0
1377 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1378 && DECL_IGNORED_P (TYPE_NAME (type)))
1380 || !COMPLETE_TYPE_P (type)
1381 /* No way in DBX fmt to describe a variable size. */
1382 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1384 /* If the type is just a cross reference, output one
1385 and mark the type as partially described.
1386 If it later becomes defined, we will output
1387 its real definition.
1388 If the type has a name, don't nest its definition within
1389 another type's definition; instead, output an xref
1390 and let the definition come when the name is defined. */
1391 fputs ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu", asmfile);
1393 #if 0 /* This assertion is legitimately false in C++. */
1394 /* We shouldn't be outputting a reference to a type before its
1395 definition unless the type has a tag name.
1396 A typedef name without a tag name should be impossible. */
1397 if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
1400 if (TYPE_NAME (type) != 0)
1401 dbxout_type_name (type);
1403 fprintf (asmfile, "$$%d", anonymous_type_number++);
1404 fprintf (asmfile, ":");
1405 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1409 /* Identify record or union, and print its size. */
1410 fputc (((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'), asmfile);
1411 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1412 int_size_in_bytes (type));
1414 if (use_gnu_debug_info_extensions)
1418 have_used_extensions = 1;
1419 fprintf (asmfile, "!%d,", n_baseclasses);
1423 for (i = 0; i < n_baseclasses; i++)
1425 tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i);
1427 if (use_gnu_debug_info_extensions)
1429 have_used_extensions = 1;
1430 putc (TREE_VIA_VIRTUAL (child) ? '1' : '0', asmfile);
1431 putc (TREE_VIA_PUBLIC (child) ? '2' : '0', asmfile);
1432 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1433 (tree_low_cst (BINFO_OFFSET (child), 0)
1435 fputc (',', asmfile);
1437 dbxout_type (BINFO_TYPE (child), 0, 0);
1438 putc (';', asmfile);
1442 /* Print out the base class information with fields
1443 which have the same names at the types they hold. */
1444 dbxout_type_name (BINFO_TYPE (child));
1445 putc (':', asmfile);
1446 dbxout_type (BINFO_TYPE (child), full, 0);
1447 fputc (',', asmfile);
1448 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1449 tree_low_cst (BINFO_OFFSET (child), 0)
1451 fputc (',', asmfile);
1452 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1453 (tree_low_cst (DECL_SIZE (TYPE_NAME
1454 (BINFO_TYPE (child))), 0)
1456 fputc (';', asmfile);
1464 /* Write out the field declarations. */
1465 dbxout_type_fields (type);
1466 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
1468 have_used_extensions = 1;
1469 dbxout_type_methods (type);
1472 putc (';', asmfile);
1474 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
1475 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1476 && TYPE_VFIELD (type))
1478 have_used_extensions = 1;
1480 /* Tell GDB+ that it may keep reading. */
1481 putc ('~', asmfile);
1483 /* We need to write out info about what field this class
1484 uses as its "main" vtable pointer field, because if this
1485 field is inherited from a base class, GDB cannot necessarily
1486 figure out which field it's using in time. */
1487 if (TYPE_VFIELD (type))
1489 putc ('%', asmfile);
1490 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0, 0);
1492 putc (';', asmfile);
1498 /* We must use the same test here as we use in the DBX_NO_XREFS case
1499 above. We simplify it a bit since an enum will never have a variable
1501 if ((TYPE_NAME (type) != 0
1502 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1503 && DECL_IGNORED_P (TYPE_NAME (type)))
1505 || !COMPLETE_TYPE_P (type))
1507 fprintf (asmfile, "xe");
1509 dbxout_type_name (type);
1510 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1511 fprintf (asmfile, ":");
1514 #ifdef DBX_OUTPUT_ENUM
1515 DBX_OUTPUT_ENUM (asmfile, type);
1517 if (use_gnu_debug_info_extensions
1518 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1519 fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1520 putc ('e', asmfile);
1522 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
1524 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1525 if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
1526 fprintf (asmfile, HOST_WIDE_INT_PRINT_UNSIGNED,
1527 TREE_INT_CST_LOW (TREE_VALUE (tem)));
1528 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
1529 && (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
1530 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1531 TREE_INT_CST_LOW (TREE_VALUE (tem)));
1533 print_int_cst_octal (TREE_VALUE (tem));
1534 fprintf (asmfile, ",");
1535 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem)));
1536 if (TREE_CHAIN (tem) != 0)
1541 putc (';', asmfile);
1547 putc ('*', asmfile);
1549 dbxout_type (TREE_TYPE (type), 0, 0);
1553 if (use_gnu_debug_info_extensions)
1555 have_used_extensions = 1;
1556 putc ('#', asmfile);
1558 if (flag_minimal_debug && !show_arg_types)
1560 /* Normally, just output the return type.
1561 The argument types are encoded in the method name. */
1562 putc ('#', asmfile);
1564 dbxout_type (TREE_TYPE (type), 0, 0);
1565 putc (';', asmfile);
1570 /* When outputting destructors, we need to write
1571 the argument types out longhand. */
1572 dbxout_type (TYPE_METHOD_BASETYPE (type), 0, 0);
1573 putc (',', asmfile);
1575 dbxout_type (TREE_TYPE (type), 0, 0);
1576 dbxout_args (TYPE_ARG_TYPES (type));
1577 putc (';', asmfile);
1583 /* Treat it as a function type. */
1584 dbxout_type (TREE_TYPE (type), 0, 0);
1589 if (use_gnu_debug_info_extensions)
1591 have_used_extensions = 1;
1592 putc ('@', asmfile);
1594 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0, 0);
1595 putc (',', asmfile);
1597 dbxout_type (TREE_TYPE (type), 0, 0);
1601 /* Should print as an int, because it is really
1603 dbxout_type (integer_type_node, 0, 0);
1607 case REFERENCE_TYPE:
1608 if (use_gnu_debug_info_extensions)
1609 have_used_extensions = 1;
1610 putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
1612 dbxout_type (TREE_TYPE (type), 0, 0);
1616 putc ('f', asmfile);
1618 dbxout_type (TREE_TYPE (type), 0, 0);
1626 /* Print the value of integer constant C, in octal,
1627 handling double precision. */
1630 print_int_cst_octal (c)
1633 unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
1634 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
1635 int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
1636 unsigned int width = TYPE_PRECISION (TREE_TYPE (c));
1638 /* GDB wants constants with no extra leading "1" bits, so
1639 we need to remove any sign-extension that might be
1641 if (width == HOST_BITS_PER_WIDE_INT * 2)
1643 else if (width > HOST_BITS_PER_WIDE_INT)
1644 high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
1645 else if (width == HOST_BITS_PER_WIDE_INT)
1648 high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
1650 fprintf (asmfile, "0");
1654 print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
1655 print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
1659 unsigned HOST_WIDE_INT beg = high >> excess;
1660 unsigned HOST_WIDE_INT middle
1661 = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
1662 | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
1663 unsigned HOST_WIDE_INT end
1664 = low & (((unsigned HOST_WIDE_INT) 1
1665 << (HOST_BITS_PER_WIDE_INT / 3 * 3))
1668 fprintf (asmfile, "%o%01o", (int) beg, (int) middle);
1669 print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
1674 print_octal (value, digits)
1675 unsigned HOST_WIDE_INT value;
1680 for (i = digits - 1; i >= 0; i--)
1681 fprintf (asmfile, "%01o", (int) ((value >> (3 * i)) & 7));
1684 /* Output the name of type TYPE, with no punctuation.
1685 Such names can be set up either by typedef declarations
1686 or by struct, enum and union tags. */
1689 dbxout_type_name (type)
1693 if (TYPE_NAME (type) == 0)
1695 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
1697 t = TYPE_NAME (type);
1699 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1701 t = DECL_NAME (TYPE_NAME (type));
1706 fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
1707 CHARS (IDENTIFIER_LENGTH (t));
1710 /* Output a .stabs for the symbol defined by DECL,
1711 which must be a ..._DECL node in the normal namespace.
1712 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1713 LOCAL is nonzero if the scope is less than the entire file.
1714 Return 1 if a stabs might have been emitted. */
1717 dbxout_symbol (decl, local)
1719 int local ATTRIBUTE_UNUSED;
1721 tree type = TREE_TYPE (decl);
1722 tree context = NULL_TREE;
1725 /* Cast avoids warning in old compilers. */
1726 current_sym_code = (STAB_CODE_TYPE) 0;
1727 current_sym_value = 0;
1728 current_sym_addr = 0;
1730 /* Ignore nameless syms, but don't ignore type tags. */
1732 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
1733 || DECL_IGNORED_P (decl))
1736 dbxout_prepare_symbol (decl);
1738 /* The output will always start with the symbol name,
1739 so always count that in the length-output-so-far. */
1741 if (DECL_NAME (decl) != 0)
1742 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
1744 switch (TREE_CODE (decl))
1747 /* Enum values are defined by defining the enum type. */
1751 if (DECL_RTL (decl) == 0)
1753 if (DECL_EXTERNAL (decl))
1755 /* Don't mention a nested function under its parent. */
1756 context = decl_function_context (decl);
1757 if (context == current_function_decl)
1759 if (GET_CODE (DECL_RTL (decl)) != MEM
1760 || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
1764 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
1765 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1766 TREE_PUBLIC (decl) ? 'F' : 'f');
1769 current_sym_code = N_FUN;
1770 current_sym_addr = XEXP (DECL_RTL (decl), 0);
1772 if (TREE_TYPE (type))
1773 dbxout_type (TREE_TYPE (type), 0, 0);
1775 dbxout_type (void_type_node, 0, 0);
1777 /* For a nested function, when that function is compiled,
1778 mention the containing function name
1779 as well as (since dbx wants it) our own assembler-name. */
1781 fprintf (asmfile, ",%s,%s",
1782 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1783 IDENTIFIER_POINTER (DECL_NAME (context)));
1785 dbxout_finish_symbol (decl);
1790 /* This seems all wrong. Outputting most kinds of types gives no name
1791 at all. A true definition gives no name; a cross-ref for a
1792 structure can give the tag name, but not a type name.
1793 It seems that no typedef name is defined by outputting a type. */
1795 /* If this typedef name was defined by outputting the type,
1796 don't duplicate it. */
1797 if (typevec[TYPE_SYMTAB_ADDRESS (type)].status == TYPE_DEFINED
1798 && TYPE_NAME (TREE_TYPE (decl)) == decl)
1801 /* Don't output the same typedef twice.
1802 And don't output what language-specific stuff doesn't want output. */
1803 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
1812 if (DECL_NAME (decl))
1814 /* Nonzero means we must output a tag as well as a typedef. */
1817 /* Handle the case of a C++ structure or union
1818 where the TYPE_NAME is a TYPE_DECL
1819 which gives both a typedef name and a tag. */
1820 /* dbx requires the tag first and the typedef second. */
1821 if ((TREE_CODE (type) == RECORD_TYPE
1822 || TREE_CODE (type) == UNION_TYPE
1823 || TREE_CODE (type) == QUAL_UNION_TYPE)
1824 && TYPE_NAME (type) == decl
1825 && !(use_gnu_debug_info_extensions && have_used_extensions)
1826 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
1827 /* Distinguish the implicit typedefs of C++
1828 from explicit ones that might be found in C. */
1829 && DECL_ARTIFICIAL (decl))
1831 tree name = TYPE_NAME (type);
1832 if (TREE_CODE (name) == TYPE_DECL)
1833 name = DECL_NAME (name);
1835 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1836 current_sym_value = 0;
1837 current_sym_addr = 0;
1838 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1840 fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
1841 IDENTIFIER_POINTER (name));
1842 dbxout_type (type, 1, 0);
1843 dbxout_finish_symbol (NULL_TREE);
1846 /* Output typedef name. */
1847 fprintf (asmfile, "%s\"%s:", ASM_STABS_OP,
1848 IDENTIFIER_POINTER (DECL_NAME (decl)));
1850 /* Short cut way to output a tag also. */
1851 if ((TREE_CODE (type) == RECORD_TYPE
1852 || TREE_CODE (type) == UNION_TYPE
1853 || TREE_CODE (type) == QUAL_UNION_TYPE)
1854 && TYPE_NAME (type) == decl
1855 /* Distinguish the implicit typedefs of C++
1856 from explicit ones that might be found in C. */
1857 && DECL_ARTIFICIAL (decl))
1859 if (use_gnu_debug_info_extensions && have_used_extensions)
1861 putc ('T', asmfile);
1862 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
1864 #if 0 /* Now we generate the tag for this case up above. */
1870 putc ('t', asmfile);
1871 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1873 dbxout_type (type, 1, 0);
1874 dbxout_finish_symbol (decl);
1878 /* Don't output a tag if this is an incomplete type (TYPE_SIZE is
1879 zero). This prevents the sun4 Sun OS 4.x dbx from crashing. */
1881 if (tag_needed && TYPE_NAME (type) != 0
1882 && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
1883 || (DECL_NAME (TYPE_NAME (type)) != 0))
1884 && COMPLETE_TYPE_P (type)
1885 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
1887 /* For a TYPE_DECL with no name, but the type has a name,
1889 This is what represents `struct foo' with no typedef. */
1890 /* In C++, the name of a type is the corresponding typedef.
1891 In C, it is an IDENTIFIER_NODE. */
1892 tree name = TYPE_NAME (type);
1893 if (TREE_CODE (name) == TYPE_DECL)
1894 name = DECL_NAME (name);
1896 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1897 current_sym_value = 0;
1898 current_sym_addr = 0;
1899 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1901 fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
1902 IDENTIFIER_POINTER (name));
1903 dbxout_type (type, 1, 0);
1904 dbxout_finish_symbol (NULL_TREE);
1908 /* If an enum type has no name, it cannot be referred to,
1909 but we must output it anyway, since the enumeration constants
1910 can be referred to. */
1911 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
1913 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1914 current_sym_value = 0;
1915 current_sym_addr = 0;
1916 current_sym_nchars = 2;
1918 /* Some debuggers fail when given NULL names, so give this a
1919 harmless name of ` '. */
1920 fprintf (asmfile, "%s\" :T", ASM_STABS_OP);
1921 dbxout_type (type, 1, 0);
1922 dbxout_finish_symbol (NULL_TREE);
1925 /* Prevent duplicate output of a typedef. */
1926 TREE_ASM_WRITTEN (decl) = 1;
1931 /* Parm decls go in their own separate chains
1932 and are output by dbxout_reg_parms and dbxout_parms. */
1936 /* Named return value, treat like a VAR_DECL. */
1938 if (DECL_RTL (decl) == 0)
1940 /* Don't mention a variable that is external.
1941 Let the file that defines it describe it. */
1942 if (DECL_EXTERNAL (decl))
1945 /* If the variable is really a constant
1946 and not written in memory, inform the debugger. */
1947 if (TREE_STATIC (decl) && TREE_READONLY (decl)
1948 && DECL_INITIAL (decl) != 0
1949 && host_integerp (DECL_INITIAL (decl), 0)
1950 && ! TREE_ASM_WRITTEN (decl)
1951 && (DECL_CONTEXT (decl) == NULL_TREE
1952 || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK))
1954 if (TREE_PUBLIC (decl) == 0)
1956 /* The sun4 assembler does not grok this. */
1957 const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1959 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
1960 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
1962 HOST_WIDE_INT ival = tree_low_cst (DECL_INITIAL (decl), 0);
1963 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1964 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile, name, ival);
1966 fprintf (asmfile, "%s\"%s:c=i", ASM_STABS_OP, name);
1968 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, ival);
1969 fprintf (asmfile, "\",0x%x,0,0,0\n", N_LSYM);
1973 else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
1975 /* don't know how to do this yet. */
1979 /* else it is something we handle like a normal variable. */
1982 SET_DECL_RTL (decl, eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
1983 #ifdef LEAF_REG_REMAP
1984 if (current_function_uses_only_leaf_regs)
1985 leaf_renumber_regs_insn (DECL_RTL (decl));
1988 result = dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
1997 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1998 Add SUFFIX to its name, if SUFFIX is not 0.
1999 Describe the variable as residing in HOME
2000 (usually HOME is DECL_RTL (DECL), but not always).
2001 Returns 1 if the stab was really emitted. */
2004 dbxout_symbol_location (decl, type, suffix, home)
2012 /* Don't mention a variable at all
2013 if it was completely optimized into nothingness.
2015 If the decl was from an inline function, then its rtl
2016 is not identically the rtl that was used in this
2017 particular compilation. */
2018 if (GET_CODE (home) == REG)
2020 regno = REGNO (home);
2021 if (regno >= FIRST_PSEUDO_REGISTER)
2024 else if (GET_CODE (home) == SUBREG)
2028 while (GET_CODE (value) == SUBREG)
2029 value = SUBREG_REG (value);
2030 if (GET_CODE (value) == REG)
2032 if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
2035 regno = REGNO (alter_subreg (home));
2038 /* The kind-of-variable letter depends on where
2039 the variable is and on the scope of its name:
2040 G and N_GSYM for static storage and global scope,
2041 S for static storage and file scope,
2042 V for static storage and local scope,
2043 for those two, use N_LCSYM if data is in bss segment,
2044 N_STSYM if in data segment, N_FUN otherwise.
2045 (We used N_FUN originally, then changed to N_STSYM
2046 to please GDB. However, it seems that confused ld.
2047 Now GDB has been fixed to like N_FUN, says Kingdon.)
2048 no letter at all, and N_LSYM, for auto variable,
2049 r and N_RSYM for register variable. */
2051 if (GET_CODE (home) == MEM
2052 && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
2054 if (TREE_PUBLIC (decl))
2057 current_sym_code = N_GSYM;
2061 current_sym_addr = XEXP (home, 0);
2063 letter = decl_function_context (decl) ? 'V' : 'S';
2065 /* This should be the same condition as in assemble_variable, but
2066 we don't have access to dont_output_data here. So, instead,
2067 we rely on the fact that error_mark_node initializers always
2068 end up in bss for C++ and never end up in bss for C. */
2069 if (DECL_INITIAL (decl) == 0
2070 || (!strcmp (lang_identify (), "cplusplus")
2071 && DECL_INITIAL (decl) == error_mark_node))
2072 current_sym_code = N_LCSYM;
2073 else if (DECL_IN_TEXT_SECTION (decl))
2074 /* This is not quite right, but it's the closest
2075 of all the codes that Unix defines. */
2076 current_sym_code = DBX_STATIC_CONST_VAR_CODE;
2079 /* Ultrix `as' seems to need this. */
2080 #ifdef DBX_STATIC_STAB_DATA_SECTION
2083 current_sym_code = N_STSYM;
2087 else if (regno >= 0)
2090 current_sym_code = N_RSYM;
2091 current_sym_value = DBX_REGISTER_NUMBER (regno);
2093 else if (GET_CODE (home) == MEM
2094 && (GET_CODE (XEXP (home, 0)) == MEM
2095 || (GET_CODE (XEXP (home, 0)) == REG
2096 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
2097 && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
2098 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2099 && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
2102 /* If the value is indirect by memory or by a register
2103 that isn't the frame pointer
2104 then it means the object is variable-sized and address through
2105 that register or stack slot. DBX has no way to represent this
2106 so all we can do is output the variable as a pointer.
2107 If it's not a parameter, ignore it.
2108 (VAR_DECLs like this can be made by integrate.c.) */
2110 if (GET_CODE (XEXP (home, 0)) == REG)
2113 current_sym_code = N_RSYM;
2114 current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
2118 current_sym_code = N_LSYM;
2119 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2120 We want the value of that CONST_INT. */
2122 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
2125 /* Effectively do build_pointer_type, but don't cache this type,
2126 since it might be temporary whereas the type it points to
2127 might have been saved for inlining. */
2128 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2129 type = make_node (POINTER_TYPE);
2130 TREE_TYPE (type) = TREE_TYPE (decl);
2132 else if (GET_CODE (home) == MEM
2133 && GET_CODE (XEXP (home, 0)) == REG)
2135 current_sym_code = N_LSYM;
2136 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2138 else if (GET_CODE (home) == MEM
2139 && GET_CODE (XEXP (home, 0)) == PLUS
2140 && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
2142 current_sym_code = N_LSYM;
2143 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2144 We want the value of that CONST_INT. */
2145 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2147 else if (GET_CODE (home) == MEM
2148 && GET_CODE (XEXP (home, 0)) == CONST)
2150 /* Handle an obscure case which can arise when optimizing and
2151 when there are few available registers. (This is *always*
2152 the case for i386/i486 targets). The RTL looks like
2153 (MEM (CONST ...)) even though this variable is a local `auto'
2154 or a local `register' variable. In effect, what has happened
2155 is that the reload pass has seen that all assignments and
2156 references for one such a local variable can be replaced by
2157 equivalent assignments and references to some static storage
2158 variable, thereby avoiding the need for a register. In such
2159 cases we're forced to lie to debuggers and tell them that
2160 this variable was itself `static'. */
2161 current_sym_code = N_LCSYM;
2163 current_sym_addr = XEXP (XEXP (home, 0), 0);
2165 else if (GET_CODE (home) == CONCAT)
2167 tree subtype = TREE_TYPE (type);
2169 /* If the variable's storage is in two parts,
2170 output each as a separate stab with a modified name. */
2171 if (WORDS_BIG_ENDIAN)
2172 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
2174 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
2176 /* Cast avoids warning in old compilers. */
2177 current_sym_code = (STAB_CODE_TYPE) 0;
2178 current_sym_value = 0;
2179 current_sym_addr = 0;
2180 dbxout_prepare_symbol (decl);
2182 if (WORDS_BIG_ENDIAN)
2183 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
2185 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
2189 /* Address might be a MEM, when DECL is a variable-sized object.
2190 Or it might be const0_rtx, meaning previous passes
2191 want us to ignore this variable. */
2194 /* Ok, start a symtab entry and output the variable name. */
2197 #ifdef DBX_STATIC_BLOCK_START
2198 DBX_STATIC_BLOCK_START (asmfile, current_sym_code);
2201 dbxout_symbol_name (decl, suffix, letter);
2202 dbxout_type (type, 0, 0);
2203 dbxout_finish_symbol (decl);
2205 #ifdef DBX_STATIC_BLOCK_END
2206 DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
2211 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2212 Then output LETTER to indicate the kind of location the symbol has. */
2215 dbxout_symbol_name (decl, suffix, letter)
2222 if (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)))
2223 /* One slight hitch: if this is a VAR_DECL which is a static
2224 class member, we must put out the mangled name instead of the
2225 DECL_NAME. Note also that static member (variable) names DO NOT begin
2226 with underscores in .stabs directives. */
2227 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2229 /* ...but if we're function-local, we don't want to include the junk
2230 added by ASM_FORMAT_PRIVATE_NAME. */
2231 name = IDENTIFIER_POINTER (DECL_NAME (decl));
2235 fprintf (asmfile, "%s\"%s%s:", ASM_STABS_OP, name,
2236 (suffix ? suffix : ""));
2238 if (letter) putc (letter, asmfile);
2242 dbxout_prepare_symbol (decl)
2243 tree decl ATTRIBUTE_UNUSED;
2246 const char *filename = DECL_SOURCE_FILE (decl);
2248 dbxout_source_file (asmfile, filename);
2253 dbxout_finish_symbol (sym)
2256 #ifdef DBX_FINISH_SYMBOL
2257 DBX_FINISH_SYMBOL (sym);
2260 if (use_gnu_debug_info_extensions && sym != 0)
2261 line = DECL_SOURCE_LINE (sym);
2263 fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line);
2264 if (current_sym_addr)
2265 output_addr_const (asmfile, current_sym_addr);
2267 fprintf (asmfile, "%d", current_sym_value);
2268 putc ('\n', asmfile);
2272 /* Output definitions of all the decls in a chain. Return non-zero if
2273 anything was output */
2282 result += dbxout_symbol (syms, 1);
2283 syms = TREE_CHAIN (syms);
2288 /* The following two functions output definitions of function parameters.
2289 Each parameter gets a definition locating it in the parameter list.
2290 Each parameter that is a register variable gets a second definition
2291 locating it in the register.
2293 Printing or argument lists in gdb uses the definitions that
2294 locate in the parameter list. But reference to the variable in
2295 expressions uses preferentially the definition as a register. */
2297 /* Output definitions, referring to storage in the parmlist,
2298 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2301 dbxout_parms (parms)
2304 for (; parms; parms = TREE_CHAIN (parms))
2305 if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node)
2307 dbxout_prepare_symbol (parms);
2309 /* Perform any necessary register eliminations on the parameter's rtl,
2310 so that the debugging output will be accurate. */
2311 DECL_INCOMING_RTL (parms)
2312 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
2313 SET_DECL_RTL (parms, eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
2314 #ifdef LEAF_REG_REMAP
2315 if (current_function_uses_only_leaf_regs)
2317 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
2318 leaf_renumber_regs_insn (DECL_RTL (parms));
2322 if (PARM_PASSED_IN_MEMORY (parms))
2324 rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
2326 /* ??? Here we assume that the parm address is indexed
2327 off the frame pointer or arg pointer.
2328 If that is not true, we produce meaningless results,
2329 but do not crash. */
2330 if (GET_CODE (addr) == PLUS
2331 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
2332 current_sym_value = INTVAL (XEXP (addr, 1));
2334 current_sym_value = 0;
2336 current_sym_code = N_PSYM;
2337 current_sym_addr = 0;
2340 if (DECL_NAME (parms))
2342 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2344 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2345 IDENTIFIER_POINTER (DECL_NAME (parms)),
2346 DBX_MEMPARM_STABS_LETTER);
2350 current_sym_nchars = 8;
2351 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2352 DBX_MEMPARM_STABS_LETTER);
2355 /* It is quite tempting to use:
2357 dbxout_type (TREE_TYPE (parms), 0, 0);
2359 as the next statement, rather than using DECL_ARG_TYPE(), so
2360 that gcc reports the actual type of the parameter, rather
2361 than the promoted type. This certainly makes GDB's life
2362 easier, at least for some ports. The change is a bad idea
2363 however, since GDB expects to be able access the type without
2364 performing any conversions. So for example, if we were
2365 passing a float to an unprototyped function, gcc will store a
2366 double on the stack, but if we emit a stab saying the type is a
2367 float, then gdb will only read in a single value, and this will
2368 produce an erropneous value. */
2369 dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
2370 current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
2371 dbxout_finish_symbol (parms);
2373 else if (GET_CODE (DECL_RTL (parms)) == REG)
2376 char regparm_letter;
2378 /* Parm passed in registers and lives in registers or nowhere. */
2380 current_sym_code = DBX_REGPARM_STABS_CODE;
2381 regparm_letter = DBX_REGPARM_STABS_LETTER;
2382 current_sym_addr = 0;
2384 /* If parm lives in a register, use that register;
2385 pretend the parm was passed there. It would be more consistent
2386 to describe the register where the parm was passed,
2387 but in practice that register usually holds something else.
2389 If we use DECL_RTL, then we must use the declared type of
2390 the variable, not the type that it arrived in. */
2391 if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2393 best_rtl = DECL_RTL (parms);
2394 parm_type = TREE_TYPE (parms);
2396 /* If the parm lives nowhere, use the register where it was
2397 passed. It is also better to use the declared type here. */
2400 best_rtl = DECL_INCOMING_RTL (parms);
2401 parm_type = TREE_TYPE (parms);
2403 current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
2406 if (DECL_NAME (parms))
2408 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2409 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2410 IDENTIFIER_POINTER (DECL_NAME (parms)),
2415 current_sym_nchars = 8;
2416 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2420 dbxout_type (parm_type, 0, 0);
2421 dbxout_finish_symbol (parms);
2423 else if (GET_CODE (DECL_RTL (parms)) == MEM
2424 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2425 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
2426 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
2427 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2428 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
2432 /* Parm was passed via invisible reference.
2433 That is, its address was passed in a register.
2434 Output it as if it lived in that register.
2435 The debugger will know from the type
2436 that it was actually passed by invisible reference. */
2438 char regparm_letter;
2439 /* Parm passed in registers and lives in registers or nowhere. */
2441 current_sym_code = DBX_REGPARM_STABS_CODE;
2442 if (use_gnu_debug_info_extensions)
2443 regparm_letter = GDB_INV_REF_REGPARM_STABS_LETTER;
2445 regparm_letter = DBX_REGPARM_STABS_LETTER;
2447 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2448 If it is an unallocated pseudo-reg, then use the register where
2449 it was passed instead. */
2450 if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
2451 current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2453 current_sym_value = REGNO (DECL_INCOMING_RTL (parms));
2455 current_sym_addr = 0;
2458 if (DECL_NAME (parms))
2460 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2462 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2463 IDENTIFIER_POINTER (DECL_NAME (parms)),
2468 current_sym_nchars = 8;
2469 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2473 dbxout_type (TREE_TYPE (parms), 0, 0);
2474 dbxout_finish_symbol (parms);
2476 else if (GET_CODE (DECL_RTL (parms)) == MEM
2477 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
2479 /* Parm was passed via invisible reference, with the reference
2480 living on the stack. DECL_RTL looks like
2481 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
2482 could look like (MEM (MEM (REG))). */
2483 const char *decl_name = (DECL_NAME (parms)
2484 ? IDENTIFIER_POINTER (DECL_NAME (parms))
2486 if (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 0)) == REG)
2487 current_sym_value = 0;
2490 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
2491 current_sym_addr = 0;
2494 fprintf (asmfile, "%s\"%s:v", ASM_STABS_OP, decl_name);
2495 dbxout_type (TREE_TYPE (parms), 0, 0);
2496 dbxout_finish_symbol (parms);
2498 else if (GET_CODE (DECL_RTL (parms)) == MEM
2499 && XEXP (DECL_RTL (parms), 0) != const0_rtx
2500 /* ??? A constant address for a parm can happen
2501 when the reg it lives in is equiv to a constant in memory.
2502 Should make this not happen, after 2.4. */
2503 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
2505 /* Parm was passed in registers but lives on the stack. */
2507 current_sym_code = N_PSYM;
2508 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2509 in which case we want the value of that CONST_INT,
2511 in which case we use a value of zero. */
2512 if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG)
2513 current_sym_value = 0;
2516 = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
2518 current_sym_addr = 0;
2520 /* Make a big endian correction if the mode of the type of the
2521 parameter is not the same as the mode of the rtl. */
2522 if (BYTES_BIG_ENDIAN
2523 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
2524 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
2526 current_sym_value +=
2527 GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
2528 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms)));
2532 if (DECL_NAME (parms))
2535 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2537 fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
2538 IDENTIFIER_POINTER (DECL_NAME (parms)),
2539 DBX_MEMPARM_STABS_LETTER);
2543 current_sym_nchars = 8;
2544 fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
2545 DBX_MEMPARM_STABS_LETTER);
2549 = DEBUGGER_ARG_OFFSET (current_sym_value,
2550 XEXP (DECL_RTL (parms), 0));
2551 dbxout_type (TREE_TYPE (parms), 0, 0);
2552 dbxout_finish_symbol (parms);
2557 /* Output definitions for the places where parms live during the function,
2558 when different from where they were passed, when the parms were passed
2561 It is not useful to do this for parms passed in registers
2562 that live during the function in different registers, because it is
2563 impossible to look in the passed register for the passed value,
2564 so we use the within-the-function register to begin with.
2566 PARMS is a chain of PARM_DECL nodes. */
2569 dbxout_reg_parms (parms)
2572 for (; parms; parms = TREE_CHAIN (parms))
2573 if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
2575 dbxout_prepare_symbol (parms);
2577 /* Report parms that live in registers during the function
2578 but were passed in memory. */
2579 if (GET_CODE (DECL_RTL (parms)) == REG
2580 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2581 dbxout_symbol_location (parms, TREE_TYPE (parms),
2582 0, DECL_RTL (parms));
2583 else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
2584 dbxout_symbol_location (parms, TREE_TYPE (parms),
2585 0, DECL_RTL (parms));
2586 /* Report parms that live in memory but not where they were passed. */
2587 else if (GET_CODE (DECL_RTL (parms)) == MEM
2588 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
2589 dbxout_symbol_location (parms, TREE_TYPE (parms),
2590 0, DECL_RTL (parms));
2594 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2595 output definitions of those names, in raw form */
2603 putc (',', asmfile);
2604 dbxout_type (TREE_VALUE (args), 0, 0);
2606 args = TREE_CHAIN (args);
2610 /* Given a chain of ..._TYPE nodes,
2611 find those which have typedef names and output those names.
2612 This is to ensure those types get output. */
2615 dbxout_types (types)
2616 register tree types;
2620 if (TYPE_NAME (types)
2621 && TREE_CODE (TYPE_NAME (types)) == TYPE_DECL
2622 && ! TREE_ASM_WRITTEN (TYPE_NAME (types)))
2623 dbxout_symbol (TYPE_NAME (types), 1);
2624 types = TREE_CHAIN (types);
2628 /* Output everything about a symbol block (a BLOCK node
2629 that represents a scope level),
2630 including recursive output of contained blocks.
2632 BLOCK is the BLOCK node.
2633 DEPTH is its depth within containing symbol blocks.
2634 ARGS is usually zero; but for the outermost block of the
2635 body of a function, it is a chain of PARM_DECLs for the function parameters.
2636 We output definitions of all the register parms
2637 as if they were local variables of that block.
2639 If -g1 was used, we count blocks just the same, but output nothing
2640 except for the outermost block.
2642 Actually, BLOCK may be several blocks chained together.
2643 We handle them all in sequence. */
2646 dbxout_block (block, depth, args)
2647 register tree block;
2653 #if DBX_BLOCKS_FUNCTION_RELATIVE
2654 const char *begin_label;
2655 if (current_function_func_begin_label != NULL_TREE)
2656 begin_label = IDENTIFIER_POINTER (current_function_func_begin_label);
2658 begin_label = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
2663 /* Ignore blocks never expanded or otherwise marked as real. */
2664 if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
2668 #ifdef DBX_LBRAC_FIRST
2671 /* In dbx format, the syms of a block come before the N_LBRAC.
2672 If nothing is output, we don't need the N_LBRAC, either. */
2674 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2675 did_output = dbxout_syms (BLOCK_VARS (block));
2677 dbxout_reg_parms (args);
2680 /* Now output an N_LBRAC symbol to represent the beginning of
2681 the block. Use the block's tree-walk order to generate
2682 the assembler symbols LBBn and LBEn
2683 that final will define around the code in this block. */
2684 if (depth > 0 && did_output)
2687 blocknum = BLOCK_NUMBER (block);
2688 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
2690 if (BLOCK_HANDLER_BLOCK (block))
2692 /* A catch block. Must precede N_LBRAC. */
2693 tree decl = BLOCK_VARS (block);
2696 #ifdef DBX_OUTPUT_CATCH
2697 DBX_OUTPUT_CATCH (asmfile, decl, buf);
2699 fprintf (asmfile, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP,
2700 IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
2701 assemble_name (asmfile, buf);
2702 fprintf (asmfile, "\n");
2704 decl = TREE_CHAIN (decl);
2708 #ifdef DBX_OUTPUT_LBRAC
2709 DBX_OUTPUT_LBRAC (asmfile, buf);
2711 fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_LBRAC);
2712 assemble_name (asmfile, buf);
2713 #if DBX_BLOCKS_FUNCTION_RELATIVE
2714 fputc ('-', asmfile);
2715 assemble_name (asmfile, begin_label);
2717 fprintf (asmfile, "\n");
2721 #ifdef DBX_LBRAC_FIRST
2722 /* On some weird machines, the syms of a block
2723 come after the N_LBRAC. */
2724 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2725 dbxout_syms (BLOCK_VARS (block));
2727 dbxout_reg_parms (args);
2730 /* Output the subblocks. */
2731 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
2733 /* Refer to the marker for the end of the block. */
2734 if (depth > 0 && did_output)
2737 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
2738 #ifdef DBX_OUTPUT_RBRAC
2739 DBX_OUTPUT_RBRAC (asmfile, buf);
2741 fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_RBRAC);
2742 assemble_name (asmfile, buf);
2743 #if DBX_BLOCKS_FUNCTION_RELATIVE
2744 fputc ('-', asmfile);
2745 assemble_name (asmfile, begin_label);
2747 fprintf (asmfile, "\n");
2751 block = BLOCK_CHAIN (block);
2755 /* Output the information about a function and its arguments and result.
2756 Usually this follows the function's code,
2757 but on some systems, it comes before. */
2760 dbxout_really_begin_function (decl)
2763 dbxout_symbol (decl, 0);
2764 dbxout_parms (DECL_ARGUMENTS (decl));
2765 if (DECL_NAME (DECL_RESULT (decl)) != 0)
2766 dbxout_symbol (DECL_RESULT (decl), 1);
2769 /* Called at beginning of output of function definition. */
2772 dbxout_begin_function (decl)
2773 tree decl ATTRIBUTE_UNUSED;
2775 #ifdef DBX_FUNCTION_FIRST
2776 dbxout_really_begin_function (decl);
2780 /* Output dbx data for a function definition.
2781 This includes a definition of the function name itself (a symbol),
2782 definitions of the parameters (locating them in the parameter list)
2783 and then output the block that makes up the function's body
2784 (including all the auto variables of the function). */
2787 dbxout_function (decl)
2790 #ifndef DBX_FUNCTION_FIRST
2791 dbxout_really_begin_function (decl);
2793 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
2794 #ifdef DBX_OUTPUT_FUNCTION_END
2795 DBX_OUTPUT_FUNCTION_END (asmfile, decl);
2797 #if defined(ASM_OUTPUT_SECTION_NAME)
2798 if (use_gnu_debug_info_extensions
2799 #if defined(NO_DBX_FUNCTION_END)
2800 && ! NO_DBX_FUNCTION_END
2803 dbxout_function_end ();
2806 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */