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 /* GDB needs to know that the stabs were generated by GCC. We emit an
128 N_OPT stab at the beginning of the source file to indicate this.
129 The string is historical, and different on a very few targets. */
130 #ifndef STABS_GCC_MARKER
131 #define STABS_GCC_MARKER "gcc2_compiled."
134 /* Nonzero means if the type has methods, only output debugging
135 information if methods are actually written to the asm file. This
136 optimization only works if the debugger can detect the special C++
139 #define MINIMAL_DEBUG 1
141 #ifdef NO_DOLLAR_IN_LABEL
142 #ifdef NO_DOT_IN_LABEL
144 #define MINIMAL_DEBUG 0
148 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
150 static int flag_minimal_debug
= MINIMAL_DEBUG
;
152 /* Nonzero if we have actually used any of the GDB extensions
153 to the debugging format. The idea is that we use them for the
154 first time only if there's a strong reason, but once we have done that,
155 we use them whenever convenient. */
157 static int have_used_extensions
= 0;
159 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
160 for the N_SO filename stabs label. */
162 static int source_label_number
= 1;
164 #ifdef DEBUG_SYMS_TEXT
165 #define FORCE_TEXT text_section ();
172 #define STAB_CODE_TYPE enum __stab_debug_code
174 /* 1 if PARM is passed to this function in memory. */
176 #define PARM_PASSED_IN_MEMORY(PARM) \
177 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
179 /* A C expression for the integer offset value of an automatic variable
180 (N_LSYM) having address X (an RTX). */
181 #ifndef DEBUGGER_AUTO_OFFSET
182 #define DEBUGGER_AUTO_OFFSET(X) \
183 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
186 /* A C expression for the integer offset value of an argument (N_PSYM)
187 having address X (an RTX). The nominal offset is OFFSET. */
188 #ifndef DEBUGGER_ARG_OFFSET
189 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
192 /* Stream for writing to assembler file. */
194 static FILE *asmfile
;
196 /* Last source file name mentioned in a NOTE insn. */
198 static const char *lastfile
;
200 /* Current working directory. */
202 static const char *cwd
;
204 enum typestatus
{TYPE_UNSEEN
, TYPE_XREF
, TYPE_DEFINED
};
206 /* Structure recording information about a C data type.
207 The status element says whether we have yet output
208 the definition of the type. TYPE_XREF says we have
209 output it as a cross-reference only.
210 The file_number and type_number elements are used if DBX_USE_BINCL
215 enum typestatus status
;
222 /* Vector recording information about C data types.
223 When we first notice a data type (a tree node),
224 we assign it a number using next_type_number.
225 That is its index in this vector. */
227 struct typeinfo
*typevec
;
229 /* Number of elements of space allocated in `typevec'. */
231 static int typevec_len
;
233 /* In dbx output, each type gets a unique number.
234 This is the number for the next type output.
235 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
237 static int next_type_number
;
241 /* When using N_BINCL in dbx output, each type number is actually a
242 pair of the file number and the type number within the file.
243 This is a stack of input files. */
247 struct dbx_file
*next
;
249 int next_type_number
;
252 /* This is the top of the stack. */
254 static struct dbx_file
*current_file
;
256 /* This is the next file number to use. */
258 static int next_file_number
;
260 #endif /* DBX_USE_BINCL */
262 /* These variables are for dbxout_symbol to communicate to
263 dbxout_finish_symbol.
264 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
265 current_sym_value and current_sym_addr are two ways to address the
266 value to store in the symtab entry.
267 current_sym_addr if nonzero represents the value as an rtx.
268 If that is zero, current_sym_value is used. This is used
269 when the value is an offset (such as for auto variables,
270 register variables and parms). */
272 static STAB_CODE_TYPE current_sym_code
;
273 static int current_sym_value
;
274 static rtx current_sym_addr
;
276 /* Number of chars of symbol-description generated so far for the
277 current symbol. Used by CHARS and CONTIN. */
279 static int current_sym_nchars
;
281 /* Report having output N chars of the current symbol-description. */
283 #define CHARS(N) (current_sym_nchars += (N))
285 /* Break the current symbol-description, generating a continuation,
286 if it has become long. */
288 #ifndef DBX_CONTIN_LENGTH
289 #define DBX_CONTIN_LENGTH 80
292 #if DBX_CONTIN_LENGTH > 0
294 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
296 #define CONTIN do { } while (0)
299 #if defined(ASM_OUTPUT_SECTION_NAME)
300 static void dbxout_function_end
PARAMS ((void));
302 static void dbxout_typedefs
PARAMS ((tree
));
303 static void dbxout_type_index
PARAMS ((tree
));
304 #if DBX_CONTIN_LENGTH > 0
305 static void dbxout_continue
PARAMS ((void));
307 static void dbxout_type_fields
PARAMS ((tree
));
308 static void dbxout_type_method_1
PARAMS ((tree
, const char *));
309 static void dbxout_type_methods
PARAMS ((tree
));
310 static void dbxout_range_type
PARAMS ((tree
));
311 static void dbxout_type
PARAMS ((tree
, int, int));
312 static void print_int_cst_octal
PARAMS ((tree
));
313 static void print_octal
PARAMS ((unsigned HOST_WIDE_INT
, int));
314 static void dbxout_type_name
PARAMS ((tree
));
315 static int dbxout_symbol_location
PARAMS ((tree
, tree
, const char *, rtx
));
316 static void dbxout_symbol_name
PARAMS ((tree
, const char *, int));
317 static void dbxout_prepare_symbol
PARAMS ((tree
));
318 static void dbxout_finish_symbol
PARAMS ((tree
));
319 static void dbxout_block
PARAMS ((tree
, int, tree
));
320 static void dbxout_really_begin_function
PARAMS ((tree
));
322 #if defined(ASM_OUTPUT_SECTION_NAME)
324 dbxout_function_end ()
326 static int scope_labelno
= 0;
327 char lscope_label_name
[100];
328 /* Convert Ltext into the appropriate format for local labels in case
329 the system doesn't insert underscores in front of user generated
331 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
332 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Lscope", scope_labelno
);
335 /* By convention, GCC will mark the end of a function with an N_FUN
336 symbol and an empty string. */
337 fprintf (asmfile
, "%s\"\",%d,0,0,", ASM_STABS_OP
, N_FUN
);
338 assemble_name (asmfile
, lscope_label_name
);
339 fputc ('-', asmfile
);
340 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
341 fprintf (asmfile
, "\n");
343 #endif /* ! NO_DBX_FUNCTION_END */
345 /* At the beginning of compilation, start writing the symbol table.
346 Initialize `typevec' and output the standard data types of C. */
349 dbxout_init (asm_file
, input_file_name
, syms
)
351 const char *input_file_name
;
354 char ltext_label_name
[100];
359 typevec
= (struct typeinfo
*) xcalloc (typevec_len
, sizeof typevec
[0]);
361 /* Convert Ltext into the appropriate format for local labels in case
362 the system doesn't insert underscores in front of user generated
364 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
366 /* Put the current working directory in an N_SO symbol. */
367 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
368 but GDB always does. */
369 if (use_gnu_debug_info_extensions
)
372 if (!cwd
&& (cwd
= getpwd ()) && (!*cwd
|| cwd
[strlen (cwd
) - 1] != '/'))
373 cwd
= concat (cwd
, FILE_NAME_JOINER
, NULL
);
376 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
377 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile
, cwd
);
378 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
379 fprintf (asmfile
, "%s", ASM_STABS_OP
);
380 output_quoted_string (asmfile
, cwd
);
381 fprintf (asmfile
, ",%d,0,0,%s\n", N_SO
, <ext_label_name
[1]);
382 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
386 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
387 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
388 would give us an N_SOL, and we want an N_SO. */
389 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile
, input_file_name
);
390 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
391 /* We include outputting `Ltext:' here,
392 because that gives you a way to override it. */
393 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
394 fprintf (asmfile
, "%s", ASM_STABS_OP
);
395 output_quoted_string (asmfile
, input_file_name
);
396 fprintf (asmfile
, ",%d,0,0,%s\n",
397 N_SO
, <ext_label_name
[1]);
399 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Ltext", 0);
400 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
402 #ifdef DBX_OUTPUT_GCC_MARKER
403 DBX_OUTPUT_GCC_MARKER (asmfile
);
405 /* Emit an N_OPT stab to indicate that this file was compiled by GCC. */
406 fprintf (asmfile
, "%s\"%s\",%d,0,0,0\n",
407 ASM_STABS_OP
, STABS_GCC_MARKER
, N_OPT
);
410 lastfile
= input_file_name
;
412 next_type_number
= 1;
415 current_file
= (struct dbx_file
*) xmalloc (sizeof *current_file
);
416 current_file
->next
= NULL
;
417 current_file
->file_number
= 0;
418 current_file
->next_type_number
= 1;
419 next_file_number
= 1;
422 /* Make sure that types `int' and `char' have numbers 1 and 2.
423 Definitions of other integer types will refer to those numbers.
424 (Actually it should no longer matter what their numbers are.
425 Also, if any types with tags have been defined, dbxout_symbol
426 will output them first, so the numbers won't be 1 and 2. That
427 happens in C++. So it's a good thing it should no longer matter). */
429 #ifdef DBX_OUTPUT_STANDARD_TYPES
430 DBX_OUTPUT_STANDARD_TYPES (syms
);
432 dbxout_symbol (TYPE_NAME (integer_type_node
), 0);
433 dbxout_symbol (TYPE_NAME (char_type_node
), 0);
436 /* Get all permanent types that have typedef names,
437 and output them all, except for those already output. */
439 dbxout_typedefs (syms
);
442 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
443 in the reverse order from that which is found in SYMS. */
446 dbxout_typedefs (syms
)
451 dbxout_typedefs (TREE_CHAIN (syms
));
452 if (TREE_CODE (syms
) == TYPE_DECL
)
454 tree type
= TREE_TYPE (syms
);
456 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
457 && COMPLETE_TYPE_P (type
)
458 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
459 dbxout_symbol (TYPE_NAME (type
), 0);
464 /* Change to reading from a new source file. Generate a N_BINCL stab. */
467 dbxout_start_new_source_file (filename
)
468 const char *filename ATTRIBUTE_UNUSED
;
471 struct dbx_file
*n
= (struct dbx_file
*) xmalloc (sizeof *n
);
473 n
->next
= current_file
;
474 n
->file_number
= next_file_number
++;
475 n
->next_type_number
= 1;
477 fprintf (asmfile
, "%s", ASM_STABS_OP
);
478 output_quoted_string (asmfile
, filename
);
479 fprintf (asmfile
, ",%d,0,0,0\n", N_BINCL
);
483 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
486 dbxout_resume_previous_source_file ()
489 struct dbx_file
*next
;
491 fprintf (asmfile
, "%s%d,0,0,0\n", ASM_STABN_OP
, N_EINCL
);
492 next
= current_file
->next
;
498 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
501 dbxout_source_file (file
, filename
)
503 const char *filename
;
505 char ltext_label_name
[100];
507 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
509 #ifdef DBX_OUTPUT_SOURCE_FILENAME
510 DBX_OUTPUT_SOURCE_FILENAME (file
, filename
);
512 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext",
513 source_label_number
);
514 fprintf (file
, "%s", ASM_STABS_OP
);
515 output_quoted_string (file
, filename
);
516 fprintf (file
, ",%d,0,0,%s\n", N_SOL
, <ext_label_name
[1]);
517 if (current_function_decl
!= NULL_TREE
518 && DECL_SECTION_NAME (current_function_decl
) != NULL_TREE
)
519 ; /* Don't change section amid function. */
522 ASM_OUTPUT_INTERNAL_LABEL (file
, "Ltext", source_label_number
);
523 source_label_number
++;
529 /* Output a line number symbol entry into output stream FILE,
530 for source file FILENAME and line number LINENO. */
533 dbxout_source_line (file
, filename
, lineno
)
535 const char *filename
;
538 dbxout_source_file (file
, filename
);
540 #ifdef ASM_OUTPUT_SOURCE_LINE
541 ASM_OUTPUT_SOURCE_LINE (file
, lineno
);
543 fprintf (file
, "%s%d,0,%d\n", ASM_STABD_OP
, N_SLINE
, lineno
);
547 /* At the end of compilation, finish writing the symbol table.
548 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
552 dbxout_finish (file
, filename
)
553 FILE *file ATTRIBUTE_UNUSED
;
554 const char *filename ATTRIBUTE_UNUSED
;
556 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
557 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file
, filename
);
558 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
561 /* Output the index of a type. */
564 dbxout_type_index (type
)
567 #ifndef DBX_USE_BINCL
568 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
571 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
572 fprintf (asmfile
, "(%d,%d)", t
->file_number
, t
->type_number
);
577 #if DBX_CONTIN_LENGTH > 0
578 /* Continue a symbol-description that gets too big.
579 End one symbol table entry with a double-backslash
580 and start a new one, eventually producing something like
581 .stabs "start......\\",code,0,value
582 .stabs "...rest",code,0,value */
587 #ifdef DBX_CONTIN_CHAR
588 fprintf (asmfile
, "%c", DBX_CONTIN_CHAR
);
590 fprintf (asmfile
, "\\\\");
592 dbxout_finish_symbol (NULL_TREE
);
593 fprintf (asmfile
, "%s\"", ASM_STABS_OP
);
594 current_sym_nchars
= 0;
596 #endif /* DBX_CONTIN_LENGTH > 0 */
598 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
599 This must be a separate function because anonymous unions require
603 dbxout_type_fields (type
)
608 /* Output the name, type, position (in bits), size (in bits) of each
609 field that we can support. */
610 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
612 /* Omit here local type decls until we know how to support them. */
613 if (TREE_CODE (tem
) == TYPE_DECL
614 /* Omit fields whose position or size are variable or too large to
616 || (TREE_CODE (tem
) == FIELD_DECL
617 && (! host_integerp (bit_position (tem
), 0)
619 || ! host_integerp (DECL_SIZE (tem
), 1)))
620 /* Omit here the nameless fields that are used to skip bits. */
621 || DECL_IGNORED_P (tem
))
624 else if (TREE_CODE (tem
) != CONST_DECL
)
626 /* Continue the line if necessary,
627 but not before the first field. */
628 if (tem
!= TYPE_FIELDS (type
))
631 if (use_gnu_debug_info_extensions
632 && flag_minimal_debug
633 && TREE_CODE (tem
) == FIELD_DECL
634 && DECL_VIRTUAL_P (tem
)
635 && DECL_ASSEMBLER_NAME (tem
))
637 have_used_extensions
= 1;
638 CHARS (3 + IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (tem
)));
639 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
)), asmfile
);
640 dbxout_type (DECL_FCONTEXT (tem
), 0, 0);
641 fprintf (asmfile
, ":");
642 dbxout_type (TREE_TYPE (tem
), 0, 0);
643 fputc (',', asmfile
);
644 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
645 int_bit_position (tem
));
646 fputc (';', asmfile
);
652 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem
)));
653 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem
)));
657 fprintf (asmfile
, ":");
661 if (use_gnu_debug_info_extensions
662 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
663 || TREE_CODE (tem
) != FIELD_DECL
))
665 have_used_extensions
= 1;
667 putc ((TREE_PRIVATE (tem
) ? '0'
668 : TREE_PROTECTED (tem
) ? '1' : '2'),
673 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
674 && DECL_BIT_FIELD_TYPE (tem
))
675 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0, 0);
677 if (TREE_CODE (tem
) == VAR_DECL
)
679 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
682 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
));
683 have_used_extensions
= 1;
684 fprintf (asmfile
, ":%s;", name
);
685 CHARS (strlen (name
));
688 /* If TEM is non-static, GDB won't understand it. */
689 fprintf (asmfile
, ",0,0;");
693 fputc (',', asmfile
);
694 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
695 int_bit_position (tem
));
696 fputc (',', asmfile
);
697 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
698 tree_low_cst (DECL_SIZE (tem
), 1));
699 fputc (';', asmfile
);
706 /* Subroutine of `dbxout_type_methods'. Output debug info about the
707 method described DECL. DEBUG_NAME is an encoding of the method's
708 type signature. ??? We may be able to do without DEBUG_NAME altogether
712 dbxout_type_method_1 (decl
, debug_name
)
714 const char *debug_name
;
718 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
720 else /* it's a METHOD_TYPE. */
722 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
723 /* A for normal functions.
724 B for `const' member functions.
725 C for `volatile' member functions.
726 D for `const volatile' member functions. */
727 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
729 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
732 if (DECL_VINDEX (decl
))
738 fprintf (asmfile
, ":%s;%c%c%c", debug_name
,
739 TREE_PRIVATE (decl
) ? '0'
740 : TREE_PROTECTED (decl
) ? '1' : '2', c1
, c2
);
741 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
)) + 6
742 - (debug_name
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
744 if (DECL_VINDEX (decl
) && host_integerp (DECL_VINDEX (decl
), 0))
746 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
747 tree_low_cst (DECL_VINDEX (decl
), 0));
748 fputc (';', asmfile
);
749 dbxout_type (DECL_CONTEXT (decl
), 0, 0);
750 fprintf (asmfile
, ";");
755 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
759 dbxout_type_methods (type
)
762 /* C++: put out the method names and their parameter lists */
763 tree methods
= TYPE_METHODS (type
);
765 register tree fndecl
;
767 char formatted_type_identifier_length
[16];
768 register int type_identifier_length
;
770 if (methods
== NULL_TREE
)
773 type_encoding
= DECL_NAME (TYPE_NAME (type
));
776 /* C++: Template classes break some assumptions made by this code about
777 the class names, constructor names, and encodings for assembler
778 label names. For now, disable output of dbx info for them. */
780 const char *ptr
= IDENTIFIER_POINTER (type_encoding
);
781 /* This should use index. (mrs) */
782 while (*ptr
&& *ptr
!= '<') ptr
++;
793 type_identifier_length
= IDENTIFIER_LENGTH (type_encoding
);
795 sprintf(formatted_type_identifier_length
, "%d", type_identifier_length
);
797 if (TREE_CODE (methods
) != TREE_VEC
)
799 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
800 fndecl
= TREE_VEC_ELT (methods
, 0);
802 fndecl
= TREE_VEC_ELT (methods
, 1);
806 tree name
= DECL_NAME (fndecl
);
809 /* Group together all the methods for the same operation.
810 These differ in the types of the arguments. */
811 for (last
= NULL_TREE
;
812 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
813 fndecl
= TREE_CHAIN (fndecl
))
814 /* Output the name of the field (after overloading), as
815 well as the name of the field before overloading, along
816 with its parameter list */
818 /* This is the "mangled" name of the method.
819 It encodes the argument types. */
820 const char *debug_name
;
821 int show_arg_types
= 0;
823 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
824 include TEMPLATE_DECLs.) The debugger doesn't know what
825 to do with such entities anyhow. */
826 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
830 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
));
836 /* Also ignore abstract methods; those are only interesting to
837 the DWARF backends. */
838 if (DECL_IGNORED_P (fndecl
) || DECL_ABSTRACT (fndecl
))
841 if (flag_minimal_debug
)
845 /* We can't optimize a method which uses an anonymous
846 class, because the debugger will not be able to
847 associate the arbitrary class name with the actual
849 #ifndef NO_DOLLAR_IN_LABEL
854 if (strchr (debug_name
, marker
))
856 /* Detect ordinary methods because their mangled names
857 start with the operation name. */
858 else if (!strncmp (IDENTIFIER_POINTER (name
), debug_name
,
859 IDENTIFIER_LENGTH (name
)))
861 debug_name
+= IDENTIFIER_LENGTH (name
);
862 if (debug_name
[0] == '_' && debug_name
[1] == '_')
864 const char *method_name
= debug_name
+ 2;
865 const char *length_ptr
=
866 formatted_type_identifier_length
;
867 /* Get past const and volatile qualifiers. */
868 while (*method_name
== 'C' || *method_name
== 'V')
870 /* Skip digits for length of type_encoding. */
871 while (*method_name
== *length_ptr
&& *length_ptr
)
872 length_ptr
++, method_name
++;
873 if (! strncmp (method_name
,
874 IDENTIFIER_POINTER (type_encoding
),
875 type_identifier_length
))
876 method_name
+= type_identifier_length
;
877 debug_name
= method_name
;
880 /* Detect constructors by their style of name mangling. */
881 else if (debug_name
[0] == '_' && debug_name
[1] == '_')
883 const char *ctor_name
= debug_name
+ 2;
884 const char *length_ptr
= formatted_type_identifier_length
;
885 while (*ctor_name
== 'C' || *ctor_name
== 'V')
887 /* Skip digits for length of type_encoding. */
888 while (*ctor_name
== *length_ptr
&& *length_ptr
)
889 length_ptr
++, ctor_name
++;
890 if (!strncmp (IDENTIFIER_POINTER (type_encoding
), ctor_name
,
891 type_identifier_length
))
892 debug_name
= ctor_name
+ type_identifier_length
;
894 /* The other alternative is a destructor. */
898 /* Output the operation name just once, for the first method
902 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (name
));
903 CHARS (IDENTIFIER_LENGTH (name
) + 2);
908 dbxout_type (TREE_TYPE (fndecl
), 0, show_arg_types
);
910 dbxout_type_method_1 (fndecl
, debug_name
);
920 /* Emit a "range" type specification, which has the form:
921 "r<index type>;<lower bound>;<upper bound>;".
922 TYPE is an INTEGER_TYPE. */
925 dbxout_range_type (type
)
928 fprintf (asmfile
, "r");
929 if (TREE_TYPE (type
))
930 dbxout_type (TREE_TYPE (type
), 0, 0);
931 else if (TREE_CODE (type
) != INTEGER_TYPE
)
932 dbxout_type (type
, 0, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
935 /* Traditionally, we made sure 'int' was type 1, and builtin types
936 were defined to be sub-ranges of int. Unfortunately, this
937 does not allow us to distinguish true sub-ranges from integer
938 types. So, instead we define integer (non-sub-range) types as
939 sub-ranges of themselves. This matters for Chill. If this isn't
940 a subrange type, then we want to define it in terms of itself.
941 However, in C, this may be an anonymous integer type, and we don't
942 want to emit debug info referring to it. Just calling
943 dbxout_type_index won't work anyways, because the type hasn't been
944 defined yet. We make this work for both cases by checked to see
945 whether this is a defined type, referring to it if it is, and using
947 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
948 dbxout_type_index (type
);
950 dbxout_type_index (integer_type_node
);
953 if (TYPE_MIN_VALUE (type
) != 0
954 && host_integerp (TYPE_MIN_VALUE (type
), 0))
956 fputc (';', asmfile
);
957 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
958 tree_low_cst (TYPE_MIN_VALUE (type
), 0));
961 fprintf (asmfile
, ";0");
963 if (TYPE_MAX_VALUE (type
) != 0
964 && host_integerp (TYPE_MAX_VALUE (type
), 0))
966 fputc (';', asmfile
);
967 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
968 tree_low_cst (TYPE_MAX_VALUE (type
), 0));
969 fputc (';', asmfile
);
972 fprintf (asmfile
, ";-1;");
975 /* Output a reference to a type. If the type has not yet been
976 described in the dbx output, output its definition now.
977 For a type already defined, just refer to its definition
978 using the type number.
980 If FULL is nonzero, and the type has been described only with
981 a forward-reference, output the definition now.
982 If FULL is zero in this case, just refer to the forward-reference
983 using the number previously allocated.
985 If SHOW_ARG_TYPES is nonzero, we output a description of the argument
986 types for a METHOD_TYPE. */
989 dbxout_type (type
, full
, show_arg_types
)
995 static int anonymous_type_number
= 0;
997 if (TREE_CODE (type
) == VECTOR_TYPE
)
998 type
= TYPE_DEBUG_REPRESENTATION_TYPE (type
);
1000 /* If there was an input error and we don't really have a type,
1001 avoid crashing and write something that is at least valid
1002 by assuming `int'. */
1003 if (type
== error_mark_node
)
1004 type
= integer_type_node
;
1007 /* Try to find the "main variant" with the same name but not const
1008 or volatile. (Since stabs does not distinguish const and volatile,
1009 there is no need to make them separate types. But types with
1010 different names are usefully distinguished.) */
1012 for (tem
= TYPE_MAIN_VARIANT (type
); tem
; tem
= TYPE_NEXT_VARIANT (tem
))
1013 if (!TYPE_READONLY (tem
) && !TYPE_VOLATILE (tem
)
1014 && TYPE_NAME (tem
) == TYPE_NAME (type
))
1019 if (TYPE_NAME (type
)
1020 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1021 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1025 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1027 /* Type has no dbx number assigned. Assign next available number. */
1028 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1030 /* Make sure type vector is long enough to record about this type. */
1032 if (next_type_number
== typevec_len
)
1035 = (struct typeinfo
*) xrealloc (typevec
,
1036 typevec_len
* 2 * sizeof typevec
[0]);
1037 memset ((char *) (typevec
+ typevec_len
), 0,
1038 typevec_len
* sizeof typevec
[0]);
1042 #ifdef DBX_USE_BINCL
1043 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1044 = current_file
->file_number
;
1045 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1046 = current_file
->next_type_number
++;
1050 /* Output the number of this type, to refer to it. */
1051 dbxout_type_index (type
);
1053 #ifdef DBX_TYPE_DEFINED
1054 if (DBX_TYPE_DEFINED (type
))
1058 /* If this type's definition has been output or is now being output,
1061 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1066 /* If we have already had a cross reference,
1067 and either that's all we want or that's the best we could do,
1068 don't repeat the cross reference.
1069 Sun dbx crashes if we do. */
1070 if (! full
|| !COMPLETE_TYPE_P (type
)
1071 /* No way in DBX fmt to describe a variable size. */
1072 || ! host_integerp (TYPE_SIZE (type
), 1))
1080 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1081 leave the type-number completely undefined rather than output
1082 a cross-reference. If we have already used GNU debug info extensions,
1083 then it is OK to output a cross reference. This is necessary to get
1084 proper C++ debug output. */
1085 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1086 || TREE_CODE (type
) == QUAL_UNION_TYPE
1087 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1088 && ! use_gnu_debug_info_extensions
)
1089 /* We must use the same test here as we use twice below when deciding
1090 whether to emit a cross-reference. */
1091 if ((TYPE_NAME (type
) != 0
1092 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1093 && DECL_IGNORED_P (TYPE_NAME (type
)))
1095 || !COMPLETE_TYPE_P (type
)
1096 /* No way in DBX fmt to describe a variable size. */
1097 || ! host_integerp (TYPE_SIZE (type
), 1))
1099 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1104 /* Output a definition now. */
1106 fprintf (asmfile
, "=");
1109 /* Mark it as defined, so that if it is self-referent
1110 we will not get into an infinite recursion of definitions. */
1112 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1114 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1115 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1117 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0, 0);
1121 switch (TREE_CODE (type
))
1125 /* For a void type, just define it as itself; ie, "5=5".
1126 This makes us consider it defined
1127 without saying what it is. The debugger will make it
1128 a void type when the reference is seen, and nothing will
1129 ever override that default. */
1130 dbxout_type_index (type
);
1134 if (type
== char_type_node
&& ! TREE_UNSIGNED (type
))
1136 /* Output the type `char' as a subrange of itself!
1137 I don't understand this definition, just copied it
1138 from the output of pcc.
1139 This used to use `r2' explicitly and we used to
1140 take care to make sure that `char' was type number 2. */
1141 fprintf (asmfile
, "r");
1142 dbxout_type_index (type
);
1143 fprintf (asmfile
, ";0;127;");
1146 /* If this is a subtype of another integer type, always prefer to
1147 write it as a subtype. */
1148 else if (TREE_TYPE (type
) != 0
1149 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
1150 dbxout_range_type (type
);
1154 /* If the size is non-standard, say what it is if we can use
1157 if (use_gnu_debug_info_extensions
1158 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1159 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1161 /* If we can use GDB extensions and the size is wider than a
1162 long (the size used by GDB to read them) or we may have
1163 trouble writing the bounds the usual way, write them in
1164 octal. Note the test is for the *target's* size of "long",
1165 not that of the host. The host test is just to make sure we
1166 can write it out in case the host wide int is narrower than the
1169 /* For unsigned types, we use octal if they are the same size or
1170 larger. This is because we print the bounds as signed decimal,
1171 and hence they can't span same size unsigned types. */
1173 if (use_gnu_debug_info_extensions
1174 && TYPE_MIN_VALUE (type
) != 0
1175 && TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
1176 && TYPE_MAX_VALUE (type
) != 0
1177 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
1178 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
1179 || ((TYPE_PRECISION (type
)
1180 == TYPE_PRECISION (integer_type_node
))
1181 && TREE_UNSIGNED (type
))
1182 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
1183 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
1184 && TREE_UNSIGNED (type
))))
1186 fprintf (asmfile
, "r");
1187 dbxout_type_index (type
);
1188 fprintf (asmfile
, ";");
1189 print_int_cst_octal (TYPE_MIN_VALUE (type
));
1190 fprintf (asmfile
, ";");
1191 print_int_cst_octal (TYPE_MAX_VALUE (type
));
1192 fprintf (asmfile
, ";");
1196 /* Output other integer types as subranges of `int'. */
1197 dbxout_range_type (type
);
1204 /* This used to say `r1' and we used to take care
1205 to make sure that `int' was type number 1. */
1206 fprintf (asmfile
, "r");
1207 dbxout_type_index (integer_type_node
);
1208 fputc (';', asmfile
);
1209 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1210 fputs (";0;", asmfile
);
1215 if (use_gnu_debug_info_extensions
)
1217 fputs ("@s", asmfile
);
1218 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1219 BITS_PER_UNIT
* int_size_in_bytes (type
));
1220 fputs (";-20;", asmfile
);
1224 /* Output the type `char' as a subrange of itself.
1225 That is what pcc seems to do. */
1226 fprintf (asmfile
, "r");
1227 dbxout_type_index (char_type_node
);
1228 fprintf (asmfile
, ";0;%d;", TREE_UNSIGNED (type
) ? 255 : 127);
1234 if (use_gnu_debug_info_extensions
)
1236 fputs ("@s", asmfile
);
1237 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1238 BITS_PER_UNIT
* int_size_in_bytes (type
));
1239 fputs (";-16;", asmfile
);
1241 else /* Define as enumeral type (False, True) */
1242 fprintf (asmfile
, "eFalse:0,True:1,;");
1247 putc ('d', asmfile
);
1249 dbxout_type (TREE_TYPE (type
), 0, 0);
1253 /* Differs from the REAL_TYPE by its new data type number */
1255 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1257 fprintf (asmfile
, "r");
1258 dbxout_type_index (type
);
1259 fputc (';', asmfile
);
1260 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1261 2 * int_size_in_bytes (TREE_TYPE (type
)));
1262 fputs (";0;", asmfile
);
1263 CHARS (12); /* The number is probably incorrect here. */
1267 /* Output a complex integer type as a structure,
1268 pending some other way to do it. */
1269 fputc ('s', asmfile
);
1270 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1272 fprintf (asmfile
, "real:");
1274 dbxout_type (TREE_TYPE (type
), 0, 0);
1275 fprintf (asmfile
, ",%d,%d;",
1276 0, TYPE_PRECISION (TREE_TYPE (type
)));
1278 fprintf (asmfile
, "imag:");
1280 dbxout_type (TREE_TYPE (type
), 0, 0);
1281 fprintf (asmfile
, ",%d,%d;;",
1282 TYPE_PRECISION (TREE_TYPE (type
)),
1283 TYPE_PRECISION (TREE_TYPE (type
)));
1289 if (use_gnu_debug_info_extensions
)
1291 have_used_extensions
= 1;
1292 fputs ("@s", asmfile
);
1293 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1294 BITS_PER_UNIT
* int_size_in_bytes (type
));
1295 fputc (';', asmfile
);
1296 /* Check if a bitstring type, which in Chill is
1297 different from a [power]set. */
1298 if (TYPE_STRING_FLAG (type
))
1299 fprintf (asmfile
, "@S;");
1301 putc ('S', asmfile
);
1303 dbxout_type (TYPE_DOMAIN (type
), 0, 0);
1307 /* Make arrays of packed bits look like bitstrings for chill. */
1308 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
1310 have_used_extensions
= 1;
1311 fputs ("@s", asmfile
);
1312 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1313 BITS_PER_UNIT
* int_size_in_bytes (type
));
1314 fputc (';', asmfile
);
1315 fprintf (asmfile
, "@S;");
1316 putc ('S', asmfile
);
1318 dbxout_type (TYPE_DOMAIN (type
), 0, 0);
1321 /* Output "a" followed by a range type definition
1322 for the index type of the array
1323 followed by a reference to the target-type.
1324 ar1;0;N;M for a C array of type M and size N+1. */
1325 /* Check if a character string type, which in Chill is
1326 different from an array of characters. */
1327 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
1329 have_used_extensions
= 1;
1330 fprintf (asmfile
, "@S;");
1332 tem
= TYPE_DOMAIN (type
);
1335 fprintf (asmfile
, "ar");
1336 dbxout_type_index (integer_type_node
);
1337 fprintf (asmfile
, ";0;-1;");
1341 fprintf (asmfile
, "a");
1342 dbxout_range_type (tem
);
1345 dbxout_type (TREE_TYPE (type
), 0, 0);
1350 case QUAL_UNION_TYPE
:
1352 int i
, n_baseclasses
= 0;
1354 if (TYPE_BINFO (type
) != 0
1355 && TREE_CODE (TYPE_BINFO (type
)) == TREE_VEC
1356 && TYPE_BINFO_BASETYPES (type
) != 0)
1357 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
1359 /* Output a structure type. We must use the same test here as we
1360 use in the DBX_NO_XREFS case above. */
1361 if ((TYPE_NAME (type
) != 0
1362 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1363 && DECL_IGNORED_P (TYPE_NAME (type
)))
1365 || !COMPLETE_TYPE_P (type
)
1366 /* No way in DBX fmt to describe a variable size. */
1367 || ! host_integerp (TYPE_SIZE (type
), 1))
1369 /* If the type is just a cross reference, output one
1370 and mark the type as partially described.
1371 If it later becomes defined, we will output
1372 its real definition.
1373 If the type has a name, don't nest its definition within
1374 another type's definition; instead, output an xref
1375 and let the definition come when the name is defined. */
1376 fputs ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu", asmfile
);
1378 #if 0 /* This assertion is legitimately false in C++. */
1379 /* We shouldn't be outputting a reference to a type before its
1380 definition unless the type has a tag name.
1381 A typedef name without a tag name should be impossible. */
1382 if (TREE_CODE (TYPE_NAME (type
)) != IDENTIFIER_NODE
)
1385 if (TYPE_NAME (type
) != 0)
1386 dbxout_type_name (type
);
1388 fprintf (asmfile
, "$$%d", anonymous_type_number
++);
1389 fprintf (asmfile
, ":");
1390 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1394 /* Identify record or union, and print its size. */
1395 fputc (((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u'), asmfile
);
1396 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1397 int_size_in_bytes (type
));
1399 if (use_gnu_debug_info_extensions
)
1403 have_used_extensions
= 1;
1404 fprintf (asmfile
, "!%d,", n_baseclasses
);
1408 for (i
= 0; i
< n_baseclasses
; i
++)
1410 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)), i
);
1412 if (use_gnu_debug_info_extensions
)
1414 have_used_extensions
= 1;
1415 putc (TREE_VIA_VIRTUAL (child
) ? '1' : '0', asmfile
);
1416 putc (TREE_VIA_PUBLIC (child
) ? '2' : '0', asmfile
);
1417 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1418 (tree_low_cst (BINFO_OFFSET (child
), 0)
1420 fputc (',', asmfile
);
1422 dbxout_type (BINFO_TYPE (child
), 0, 0);
1423 putc (';', asmfile
);
1427 /* Print out the base class information with fields
1428 which have the same names at the types they hold. */
1429 dbxout_type_name (BINFO_TYPE (child
));
1430 putc (':', asmfile
);
1431 dbxout_type (BINFO_TYPE (child
), full
, 0);
1432 fputc (',', asmfile
);
1433 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1434 tree_low_cst (BINFO_OFFSET (child
), 0)
1436 fputc (',', asmfile
);
1437 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1438 (tree_low_cst (DECL_SIZE (TYPE_NAME
1439 (BINFO_TYPE (child
))), 0)
1441 fputc (';', asmfile
);
1449 /* Write out the field declarations. */
1450 dbxout_type_fields (type
);
1451 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1453 have_used_extensions
= 1;
1454 dbxout_type_methods (type
);
1457 putc (';', asmfile
);
1459 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1460 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1461 && TYPE_VFIELD (type
))
1463 have_used_extensions
= 1;
1465 /* Tell GDB+ that it may keep reading. */
1466 putc ('~', asmfile
);
1468 /* We need to write out info about what field this class
1469 uses as its "main" vtable pointer field, because if this
1470 field is inherited from a base class, GDB cannot necessarily
1471 figure out which field it's using in time. */
1472 if (TYPE_VFIELD (type
))
1474 putc ('%', asmfile
);
1475 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0, 0);
1477 putc (';', asmfile
);
1483 /* We must use the same test here as we use in the DBX_NO_XREFS case
1484 above. We simplify it a bit since an enum will never have a variable
1486 if ((TYPE_NAME (type
) != 0
1487 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1488 && DECL_IGNORED_P (TYPE_NAME (type
)))
1490 || !COMPLETE_TYPE_P (type
))
1492 fprintf (asmfile
, "xe");
1494 dbxout_type_name (type
);
1495 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1496 fprintf (asmfile
, ":");
1499 #ifdef DBX_OUTPUT_ENUM
1500 DBX_OUTPUT_ENUM (asmfile
, type
);
1502 if (use_gnu_debug_info_extensions
1503 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1504 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1505 putc ('e', asmfile
);
1507 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1509 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)));
1510 if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == 0)
1511 fprintf (asmfile
, HOST_WIDE_INT_PRINT_UNSIGNED
,
1512 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1513 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == -1
1514 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (TREE_VALUE (tem
)) < 0)
1515 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1516 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1518 print_int_cst_octal (TREE_VALUE (tem
));
1519 fprintf (asmfile
, ",");
1520 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)));
1521 if (TREE_CHAIN (tem
) != 0)
1526 putc (';', asmfile
);
1532 putc ('*', asmfile
);
1534 dbxout_type (TREE_TYPE (type
), 0, 0);
1538 if (use_gnu_debug_info_extensions
)
1540 have_used_extensions
= 1;
1541 putc ('#', asmfile
);
1543 if (flag_minimal_debug
&& !show_arg_types
)
1545 /* Normally, just output the return type.
1546 The argument types are encoded in the method name. */
1547 putc ('#', asmfile
);
1549 dbxout_type (TREE_TYPE (type
), 0, 0);
1550 putc (';', asmfile
);
1555 /* When outputting destructors, we need to write
1556 the argument types out longhand. */
1557 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0, 0);
1558 putc (',', asmfile
);
1560 dbxout_type (TREE_TYPE (type
), 0, 0);
1561 dbxout_args (TYPE_ARG_TYPES (type
));
1562 putc (';', asmfile
);
1568 /* Treat it as a function type. */
1569 dbxout_type (TREE_TYPE (type
), 0, 0);
1574 if (use_gnu_debug_info_extensions
)
1576 have_used_extensions
= 1;
1577 putc ('@', asmfile
);
1579 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0, 0);
1580 putc (',', asmfile
);
1582 dbxout_type (TREE_TYPE (type
), 0, 0);
1586 /* Should print as an int, because it is really
1588 dbxout_type (integer_type_node
, 0, 0);
1592 case REFERENCE_TYPE
:
1593 if (use_gnu_debug_info_extensions
)
1594 have_used_extensions
= 1;
1595 putc (use_gnu_debug_info_extensions
? '&' : '*', asmfile
);
1597 dbxout_type (TREE_TYPE (type
), 0, 0);
1601 putc ('f', asmfile
);
1603 dbxout_type (TREE_TYPE (type
), 0, 0);
1611 /* Print the value of integer constant C, in octal,
1612 handling double precision. */
1615 print_int_cst_octal (c
)
1618 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (c
);
1619 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (c
);
1620 int excess
= (3 - (HOST_BITS_PER_WIDE_INT
% 3));
1621 unsigned int width
= TYPE_PRECISION (TREE_TYPE (c
));
1623 /* GDB wants constants with no extra leading "1" bits, so
1624 we need to remove any sign-extension that might be
1626 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
1628 else if (width
> HOST_BITS_PER_WIDE_INT
)
1629 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
1630 else if (width
== HOST_BITS_PER_WIDE_INT
)
1633 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
1635 fprintf (asmfile
, "0");
1639 print_octal (high
, HOST_BITS_PER_WIDE_INT
/ 3);
1640 print_octal (low
, HOST_BITS_PER_WIDE_INT
/ 3);
1644 unsigned HOST_WIDE_INT beg
= high
>> excess
;
1645 unsigned HOST_WIDE_INT middle
1646 = ((high
& (((HOST_WIDE_INT
) 1 << excess
) - 1)) << (3 - excess
)
1647 | (low
>> (HOST_BITS_PER_WIDE_INT
/ 3 * 3)));
1648 unsigned HOST_WIDE_INT end
1649 = low
& (((unsigned HOST_WIDE_INT
) 1
1650 << (HOST_BITS_PER_WIDE_INT
/ 3 * 3))
1653 fprintf (asmfile
, "%o%01o", (int) beg
, (int) middle
);
1654 print_octal (end
, HOST_BITS_PER_WIDE_INT
/ 3);
1659 print_octal (value
, digits
)
1660 unsigned HOST_WIDE_INT value
;
1665 for (i
= digits
- 1; i
>= 0; i
--)
1666 fprintf (asmfile
, "%01o", (int) ((value
>> (3 * i
)) & 7));
1669 /* Output the name of type TYPE, with no punctuation.
1670 Such names can be set up either by typedef declarations
1671 or by struct, enum and union tags. */
1674 dbxout_type_name (type
)
1678 if (TYPE_NAME (type
) == 0)
1680 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
1682 t
= TYPE_NAME (type
);
1684 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1686 t
= DECL_NAME (TYPE_NAME (type
));
1691 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
1692 CHARS (IDENTIFIER_LENGTH (t
));
1695 /* Output a .stabs for the symbol defined by DECL,
1696 which must be a ..._DECL node in the normal namespace.
1697 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1698 LOCAL is nonzero if the scope is less than the entire file.
1699 Return 1 if a stabs might have been emitted. */
1702 dbxout_symbol (decl
, local
)
1704 int local ATTRIBUTE_UNUSED
;
1706 tree type
= TREE_TYPE (decl
);
1707 tree context
= NULL_TREE
;
1710 /* Cast avoids warning in old compilers. */
1711 current_sym_code
= (STAB_CODE_TYPE
) 0;
1712 current_sym_value
= 0;
1713 current_sym_addr
= 0;
1715 /* Ignore nameless syms, but don't ignore type tags. */
1717 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
1718 || DECL_IGNORED_P (decl
))
1721 dbxout_prepare_symbol (decl
);
1723 /* The output will always start with the symbol name,
1724 so always count that in the length-output-so-far. */
1726 if (DECL_NAME (decl
) != 0)
1727 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
1729 switch (TREE_CODE (decl
))
1732 /* Enum values are defined by defining the enum type. */
1736 if (DECL_RTL (decl
) == 0)
1738 if (DECL_EXTERNAL (decl
))
1740 /* Don't mention a nested function under its parent. */
1741 context
= decl_function_context (decl
);
1742 if (context
== current_function_decl
)
1744 if (GET_CODE (DECL_RTL (decl
)) != MEM
1745 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
1749 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
1750 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1751 TREE_PUBLIC (decl
) ? 'F' : 'f');
1754 current_sym_code
= N_FUN
;
1755 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1757 if (TREE_TYPE (type
))
1758 dbxout_type (TREE_TYPE (type
), 0, 0);
1760 dbxout_type (void_type_node
, 0, 0);
1762 /* For a nested function, when that function is compiled,
1763 mention the containing function name
1764 as well as (since dbx wants it) our own assembler-name. */
1766 fprintf (asmfile
, ",%s,%s",
1767 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1768 IDENTIFIER_POINTER (DECL_NAME (context
)));
1770 dbxout_finish_symbol (decl
);
1775 /* This seems all wrong. Outputting most kinds of types gives no name
1776 at all. A true definition gives no name; a cross-ref for a
1777 structure can give the tag name, but not a type name.
1778 It seems that no typedef name is defined by outputting a type. */
1780 /* If this typedef name was defined by outputting the type,
1781 don't duplicate it. */
1782 if (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
== TYPE_DEFINED
1783 && TYPE_NAME (TREE_TYPE (decl
)) == decl
)
1786 /* Don't output the same typedef twice.
1787 And don't output what language-specific stuff doesn't want output. */
1788 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
1797 if (DECL_NAME (decl
))
1799 /* Nonzero means we must output a tag as well as a typedef. */
1802 /* Handle the case of a C++ structure or union
1803 where the TYPE_NAME is a TYPE_DECL
1804 which gives both a typedef name and a tag. */
1805 /* dbx requires the tag first and the typedef second. */
1806 if ((TREE_CODE (type
) == RECORD_TYPE
1807 || TREE_CODE (type
) == UNION_TYPE
1808 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1809 && TYPE_NAME (type
) == decl
1810 && !(use_gnu_debug_info_extensions
&& have_used_extensions
)
1811 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
1812 /* Distinguish the implicit typedefs of C++
1813 from explicit ones that might be found in C. */
1814 && DECL_ARTIFICIAL (decl
)
1815 /* Do not generate a tag for records of variable size,
1816 since this type can not be properly described in the
1817 DBX format, and it confuses some tools such as objdump. */
1818 && ! host_integerp (TYPE_SIZE (type
), 1))
1820 tree name
= TYPE_NAME (type
);
1821 if (TREE_CODE (name
) == TYPE_DECL
)
1822 name
= DECL_NAME (name
);
1824 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1825 current_sym_value
= 0;
1826 current_sym_addr
= 0;
1827 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1829 fprintf (asmfile
, "%s\"%s:T", ASM_STABS_OP
,
1830 IDENTIFIER_POINTER (name
));
1831 dbxout_type (type
, 1, 0);
1832 dbxout_finish_symbol (NULL_TREE
);
1835 /* Output typedef name. */
1836 fprintf (asmfile
, "%s\"%s:", ASM_STABS_OP
,
1837 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1839 /* Short cut way to output a tag also. */
1840 if ((TREE_CODE (type
) == RECORD_TYPE
1841 || TREE_CODE (type
) == UNION_TYPE
1842 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1843 && TYPE_NAME (type
) == decl
1844 /* Distinguish the implicit typedefs of C++
1845 from explicit ones that might be found in C. */
1846 && DECL_ARTIFICIAL (decl
))
1848 if (use_gnu_debug_info_extensions
&& have_used_extensions
)
1850 putc ('T', asmfile
);
1851 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
1853 #if 0 /* Now we generate the tag for this case up above. */
1859 putc ('t', asmfile
);
1860 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1862 dbxout_type (type
, 1, 0);
1863 dbxout_finish_symbol (decl
);
1867 /* Don't output a tag if this is an incomplete type. This prevents
1868 the sun4 Sun OS 4.x dbx from crashing. */
1870 if (tag_needed
&& TYPE_NAME (type
) != 0
1871 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
1872 || (DECL_NAME (TYPE_NAME (type
)) != 0))
1873 && COMPLETE_TYPE_P (type
)
1874 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1876 /* For a TYPE_DECL with no name, but the type has a name,
1878 This is what represents `struct foo' with no typedef. */
1879 /* In C++, the name of a type is the corresponding typedef.
1880 In C, it is an IDENTIFIER_NODE. */
1881 tree name
= TYPE_NAME (type
);
1882 if (TREE_CODE (name
) == TYPE_DECL
)
1883 name
= DECL_NAME (name
);
1885 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1886 current_sym_value
= 0;
1887 current_sym_addr
= 0;
1888 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1890 fprintf (asmfile
, "%s\"%s:T", ASM_STABS_OP
,
1891 IDENTIFIER_POINTER (name
));
1892 dbxout_type (type
, 1, 0);
1893 dbxout_finish_symbol (NULL_TREE
);
1897 /* If an enum type has no name, it cannot be referred to,
1898 but we must output it anyway, since the enumeration constants
1899 can be referred to. */
1900 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
1902 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1903 current_sym_value
= 0;
1904 current_sym_addr
= 0;
1905 current_sym_nchars
= 2;
1907 /* Some debuggers fail when given NULL names, so give this a
1908 harmless name of ` '. */
1909 fprintf (asmfile
, "%s\" :T", ASM_STABS_OP
);
1910 dbxout_type (type
, 1, 0);
1911 dbxout_finish_symbol (NULL_TREE
);
1914 /* Prevent duplicate output of a typedef. */
1915 TREE_ASM_WRITTEN (decl
) = 1;
1920 /* Parm decls go in their own separate chains
1921 and are output by dbxout_reg_parms and dbxout_parms. */
1925 /* Named return value, treat like a VAR_DECL. */
1927 if (DECL_RTL (decl
) == 0)
1929 /* Don't mention a variable that is external.
1930 Let the file that defines it describe it. */
1931 if (DECL_EXTERNAL (decl
))
1934 /* If the variable is really a constant
1935 and not written in memory, inform the debugger. */
1936 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
1937 && DECL_INITIAL (decl
) != 0
1938 && host_integerp (DECL_INITIAL (decl
), 0)
1939 && ! TREE_ASM_WRITTEN (decl
)
1940 && (DECL_CONTEXT (decl
) == NULL_TREE
1941 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
))
1943 if (TREE_PUBLIC (decl
) == 0)
1945 /* The sun4 assembler does not grok this. */
1946 const char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1948 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
1949 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
1951 HOST_WIDE_INT ival
= tree_low_cst (DECL_INITIAL (decl
), 0);
1952 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1953 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile
, name
, ival
);
1955 fprintf (asmfile
, "%s\"%s:c=i", ASM_STABS_OP
, name
);
1957 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, ival
);
1958 fprintf (asmfile
, "\",0x%x,0,0,0\n", N_LSYM
);
1962 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
1964 /* don't know how to do this yet. */
1968 /* else it is something we handle like a normal variable. */
1971 SET_DECL_RTL (decl
, eliminate_regs (DECL_RTL (decl
), 0, NULL_RTX
));
1972 #ifdef LEAF_REG_REMAP
1973 if (current_function_uses_only_leaf_regs
)
1974 leaf_renumber_regs_insn (DECL_RTL (decl
));
1977 result
= dbxout_symbol_location (decl
, type
, 0, DECL_RTL (decl
));
1986 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1987 Add SUFFIX to its name, if SUFFIX is not 0.
1988 Describe the variable as residing in HOME
1989 (usually HOME is DECL_RTL (DECL), but not always).
1990 Returns 1 if the stab was really emitted. */
1993 dbxout_symbol_location (decl
, type
, suffix
, home
)
2001 /* Don't mention a variable at all
2002 if it was completely optimized into nothingness.
2004 If the decl was from an inline function, then its rtl
2005 is not identically the rtl that was used in this
2006 particular compilation. */
2007 if (GET_CODE (home
) == REG
)
2009 regno
= REGNO (home
);
2010 if (regno
>= FIRST_PSEUDO_REGISTER
)
2013 else if (GET_CODE (home
) == SUBREG
)
2017 while (GET_CODE (value
) == SUBREG
)
2018 value
= SUBREG_REG (value
);
2019 if (GET_CODE (value
) == REG
)
2021 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
2024 regno
= REGNO (alter_subreg (home
));
2027 /* The kind-of-variable letter depends on where
2028 the variable is and on the scope of its name:
2029 G and N_GSYM for static storage and global scope,
2030 S for static storage and file scope,
2031 V for static storage and local scope,
2032 for those two, use N_LCSYM if data is in bss segment,
2033 N_STSYM if in data segment, N_FUN otherwise.
2034 (We used N_FUN originally, then changed to N_STSYM
2035 to please GDB. However, it seems that confused ld.
2036 Now GDB has been fixed to like N_FUN, says Kingdon.)
2037 no letter at all, and N_LSYM, for auto variable,
2038 r and N_RSYM for register variable. */
2040 if (GET_CODE (home
) == MEM
2041 && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2043 if (TREE_PUBLIC (decl
))
2046 current_sym_code
= N_GSYM
;
2050 current_sym_addr
= XEXP (home
, 0);
2052 letter
= decl_function_context (decl
) ? 'V' : 'S';
2054 /* This should be the same condition as in assemble_variable, but
2055 we don't have access to dont_output_data here. So, instead,
2056 we rely on the fact that error_mark_node initializers always
2057 end up in bss for C++ and never end up in bss for C. */
2058 if (DECL_INITIAL (decl
) == 0
2059 || (!strcmp (lang_identify (), "cplusplus")
2060 && DECL_INITIAL (decl
) == error_mark_node
))
2061 current_sym_code
= N_LCSYM
;
2062 else if (DECL_IN_TEXT_SECTION (decl
))
2063 /* This is not quite right, but it's the closest
2064 of all the codes that Unix defines. */
2065 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
2068 /* Ultrix `as' seems to need this. */
2069 #ifdef DBX_STATIC_STAB_DATA_SECTION
2072 current_sym_code
= N_STSYM
;
2076 else if (regno
>= 0)
2079 current_sym_code
= N_RSYM
;
2080 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
2082 else if (GET_CODE (home
) == MEM
2083 && (GET_CODE (XEXP (home
, 0)) == MEM
2084 || (GET_CODE (XEXP (home
, 0)) == REG
2085 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
2086 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
2087 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2088 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
2091 /* If the value is indirect by memory or by a register
2092 that isn't the frame pointer
2093 then it means the object is variable-sized and address through
2094 that register or stack slot. DBX has no way to represent this
2095 so all we can do is output the variable as a pointer.
2096 If it's not a parameter, ignore it.
2097 (VAR_DECLs like this can be made by integrate.c.) */
2099 if (GET_CODE (XEXP (home
, 0)) == REG
)
2102 current_sym_code
= N_RSYM
;
2103 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
2107 current_sym_code
= N_LSYM
;
2108 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2109 We want the value of that CONST_INT. */
2111 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
2114 /* Effectively do build_pointer_type, but don't cache this type,
2115 since it might be temporary whereas the type it points to
2116 might have been saved for inlining. */
2117 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2118 type
= make_node (POINTER_TYPE
);
2119 TREE_TYPE (type
) = TREE_TYPE (decl
);
2121 else if (GET_CODE (home
) == MEM
2122 && GET_CODE (XEXP (home
, 0)) == REG
)
2124 current_sym_code
= N_LSYM
;
2125 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2127 else if (GET_CODE (home
) == MEM
2128 && GET_CODE (XEXP (home
, 0)) == PLUS
2129 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
2131 current_sym_code
= N_LSYM
;
2132 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2133 We want the value of that CONST_INT. */
2134 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2136 else if (GET_CODE (home
) == MEM
2137 && GET_CODE (XEXP (home
, 0)) == CONST
)
2139 /* Handle an obscure case which can arise when optimizing and
2140 when there are few available registers. (This is *always*
2141 the case for i386/i486 targets). The RTL looks like
2142 (MEM (CONST ...)) even though this variable is a local `auto'
2143 or a local `register' variable. In effect, what has happened
2144 is that the reload pass has seen that all assignments and
2145 references for one such a local variable can be replaced by
2146 equivalent assignments and references to some static storage
2147 variable, thereby avoiding the need for a register. In such
2148 cases we're forced to lie to debuggers and tell them that
2149 this variable was itself `static'. */
2150 current_sym_code
= N_LCSYM
;
2152 current_sym_addr
= XEXP (XEXP (home
, 0), 0);
2154 else if (GET_CODE (home
) == CONCAT
)
2158 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
2159 for example), then there is no easy way to figure out
2160 what SUBTYPE should be. So, we give up. */
2161 if (TREE_CODE (type
) != COMPLEX_TYPE
)
2164 subtype
= TREE_TYPE (type
);
2166 /* If the variable's storage is in two parts,
2167 output each as a separate stab with a modified name. */
2168 if (WORDS_BIG_ENDIAN
)
2169 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
2171 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
2173 /* Cast avoids warning in old compilers. */
2174 current_sym_code
= (STAB_CODE_TYPE
) 0;
2175 current_sym_value
= 0;
2176 current_sym_addr
= 0;
2177 dbxout_prepare_symbol (decl
);
2179 if (WORDS_BIG_ENDIAN
)
2180 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
2182 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
2186 /* Address might be a MEM, when DECL is a variable-sized object.
2187 Or it might be const0_rtx, meaning previous passes
2188 want us to ignore this variable. */
2191 /* Ok, start a symtab entry and output the variable name. */
2194 #ifdef DBX_STATIC_BLOCK_START
2195 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
2198 dbxout_symbol_name (decl
, suffix
, letter
);
2199 dbxout_type (type
, 0, 0);
2200 dbxout_finish_symbol (decl
);
2202 #ifdef DBX_STATIC_BLOCK_END
2203 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
2208 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2209 Then output LETTER to indicate the kind of location the symbol has. */
2212 dbxout_symbol_name (decl
, suffix
, letter
)
2219 if (DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
)))
2220 /* One slight hitch: if this is a VAR_DECL which is a static
2221 class member, we must put out the mangled name instead of the
2222 DECL_NAME. Note also that static member (variable) names DO NOT begin
2223 with underscores in .stabs directives. */
2224 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2226 /* ...but if we're function-local, we don't want to include the junk
2227 added by ASM_FORMAT_PRIVATE_NAME. */
2228 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
2232 fprintf (asmfile
, "%s\"%s%s:", ASM_STABS_OP
, name
,
2233 (suffix
? suffix
: ""));
2235 if (letter
) putc (letter
, asmfile
);
2239 dbxout_prepare_symbol (decl
)
2240 tree decl ATTRIBUTE_UNUSED
;
2243 const char *filename
= DECL_SOURCE_FILE (decl
);
2245 dbxout_source_file (asmfile
, filename
);
2250 dbxout_finish_symbol (sym
)
2253 #ifdef DBX_FINISH_SYMBOL
2254 DBX_FINISH_SYMBOL (sym
);
2257 if (use_gnu_debug_info_extensions
&& sym
!= 0)
2258 line
= DECL_SOURCE_LINE (sym
);
2260 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
2261 if (current_sym_addr
)
2262 output_addr_const (asmfile
, current_sym_addr
);
2264 fprintf (asmfile
, "%d", current_sym_value
);
2265 putc ('\n', asmfile
);
2269 /* Output definitions of all the decls in a chain. Return non-zero if
2270 anything was output */
2279 result
+= dbxout_symbol (syms
, 1);
2280 syms
= TREE_CHAIN (syms
);
2285 /* The following two functions output definitions of function parameters.
2286 Each parameter gets a definition locating it in the parameter list.
2287 Each parameter that is a register variable gets a second definition
2288 locating it in the register.
2290 Printing or argument lists in gdb uses the definitions that
2291 locate in the parameter list. But reference to the variable in
2292 expressions uses preferentially the definition as a register. */
2294 /* Output definitions, referring to storage in the parmlist,
2295 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2298 dbxout_parms (parms
)
2301 for (; parms
; parms
= TREE_CHAIN (parms
))
2302 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
2304 dbxout_prepare_symbol (parms
);
2306 /* Perform any necessary register eliminations on the parameter's rtl,
2307 so that the debugging output will be accurate. */
2308 DECL_INCOMING_RTL (parms
)
2309 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
2310 SET_DECL_RTL (parms
, eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
));
2311 #ifdef LEAF_REG_REMAP
2312 if (current_function_uses_only_leaf_regs
)
2314 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
2315 leaf_renumber_regs_insn (DECL_RTL (parms
));
2319 if (PARM_PASSED_IN_MEMORY (parms
))
2321 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
2323 /* ??? Here we assume that the parm address is indexed
2324 off the frame pointer or arg pointer.
2325 If that is not true, we produce meaningless results,
2326 but do not crash. */
2327 if (GET_CODE (addr
) == PLUS
2328 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
2329 current_sym_value
= INTVAL (XEXP (addr
, 1));
2331 current_sym_value
= 0;
2333 current_sym_code
= N_PSYM
;
2334 current_sym_addr
= 0;
2337 if (DECL_NAME (parms
))
2339 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2341 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2342 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2343 DBX_MEMPARM_STABS_LETTER
);
2347 current_sym_nchars
= 8;
2348 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2349 DBX_MEMPARM_STABS_LETTER
);
2352 /* It is quite tempting to use:
2354 dbxout_type (TREE_TYPE (parms), 0, 0);
2356 as the next statement, rather than using DECL_ARG_TYPE(), so
2357 that gcc reports the actual type of the parameter, rather
2358 than the promoted type. This certainly makes GDB's life
2359 easier, at least for some ports. The change is a bad idea
2360 however, since GDB expects to be able access the type without
2361 performing any conversions. So for example, if we were
2362 passing a float to an unprototyped function, gcc will store a
2363 double on the stack, but if we emit a stab saying the type is a
2364 float, then gdb will only read in a single value, and this will
2365 produce an erropneous value. */
2366 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
2367 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
2368 dbxout_finish_symbol (parms
);
2370 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
2373 char regparm_letter
;
2375 /* Parm passed in registers and lives in registers or nowhere. */
2377 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2378 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2379 current_sym_addr
= 0;
2381 /* If parm lives in a register, use that register;
2382 pretend the parm was passed there. It would be more consistent
2383 to describe the register where the parm was passed,
2384 but in practice that register usually holds something else.
2386 If we use DECL_RTL, then we must use the declared type of
2387 the variable, not the type that it arrived in. */
2388 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2390 best_rtl
= DECL_RTL (parms
);
2391 parm_type
= TREE_TYPE (parms
);
2393 /* If the parm lives nowhere, use the register where it was
2394 passed. It is also better to use the declared type here. */
2397 best_rtl
= DECL_INCOMING_RTL (parms
);
2398 parm_type
= TREE_TYPE (parms
);
2400 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
2403 if (DECL_NAME (parms
))
2405 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2406 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2407 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2412 current_sym_nchars
= 8;
2413 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2417 dbxout_type (parm_type
, 0, 0);
2418 dbxout_finish_symbol (parms
);
2420 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2421 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
2422 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
2423 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
2424 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2425 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
2429 /* Parm was passed via invisible reference.
2430 That is, its address was passed in a register.
2431 Output it as if it lived in that register.
2432 The debugger will know from the type
2433 that it was actually passed by invisible reference. */
2435 char regparm_letter
;
2436 /* Parm passed in registers and lives in registers or nowhere. */
2438 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2439 if (use_gnu_debug_info_extensions
)
2440 regparm_letter
= GDB_INV_REF_REGPARM_STABS_LETTER
;
2442 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2444 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2445 If it is an unallocated pseudo-reg, then use the register where
2446 it was passed instead. */
2447 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
2448 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
2450 current_sym_value
= REGNO (DECL_INCOMING_RTL (parms
));
2452 current_sym_addr
= 0;
2455 if (DECL_NAME (parms
))
2457 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2459 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2460 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2465 current_sym_nchars
= 8;
2466 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2470 dbxout_type (TREE_TYPE (parms
), 0, 0);
2471 dbxout_finish_symbol (parms
);
2473 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2474 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
2476 /* Parm was passed via invisible reference, with the reference
2477 living on the stack. DECL_RTL looks like
2478 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
2479 could look like (MEM (MEM (REG))). */
2480 const char *decl_name
= (DECL_NAME (parms
)
2481 ? IDENTIFIER_POINTER (DECL_NAME (parms
))
2483 if (GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 0)) == REG
)
2484 current_sym_value
= 0;
2487 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
2488 current_sym_addr
= 0;
2491 fprintf (asmfile
, "%s\"%s:v", ASM_STABS_OP
, decl_name
);
2492 dbxout_type (TREE_TYPE (parms
), 0, 0);
2493 dbxout_finish_symbol (parms
);
2495 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2496 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
2497 /* ??? A constant address for a parm can happen
2498 when the reg it lives in is equiv to a constant in memory.
2499 Should make this not happen, after 2.4. */
2500 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
2502 /* Parm was passed in registers but lives on the stack. */
2504 current_sym_code
= N_PSYM
;
2505 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2506 in which case we want the value of that CONST_INT,
2508 in which case we use a value of zero. */
2509 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
)
2510 current_sym_value
= 0;
2513 = INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
2515 current_sym_addr
= 0;
2517 /* Make a big endian correction if the mode of the type of the
2518 parameter is not the same as the mode of the rtl. */
2519 if (BYTES_BIG_ENDIAN
2520 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
2521 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
2523 current_sym_value
+=
2524 GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
2525 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
)));
2529 if (DECL_NAME (parms
))
2532 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2534 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2535 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2536 DBX_MEMPARM_STABS_LETTER
);
2540 current_sym_nchars
= 8;
2541 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2542 DBX_MEMPARM_STABS_LETTER
);
2546 = DEBUGGER_ARG_OFFSET (current_sym_value
,
2547 XEXP (DECL_RTL (parms
), 0));
2548 dbxout_type (TREE_TYPE (parms
), 0, 0);
2549 dbxout_finish_symbol (parms
);
2554 /* Output definitions for the places where parms live during the function,
2555 when different from where they were passed, when the parms were passed
2558 It is not useful to do this for parms passed in registers
2559 that live during the function in different registers, because it is
2560 impossible to look in the passed register for the passed value,
2561 so we use the within-the-function register to begin with.
2563 PARMS is a chain of PARM_DECL nodes. */
2566 dbxout_reg_parms (parms
)
2569 for (; parms
; parms
= TREE_CHAIN (parms
))
2570 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
2572 dbxout_prepare_symbol (parms
);
2574 /* Report parms that live in registers during the function
2575 but were passed in memory. */
2576 if (GET_CODE (DECL_RTL (parms
)) == REG
2577 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2578 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2579 0, DECL_RTL (parms
));
2580 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
2581 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2582 0, DECL_RTL (parms
));
2583 /* Report parms that live in memory but not where they were passed. */
2584 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2585 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
2586 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2587 0, DECL_RTL (parms
));
2591 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2592 output definitions of those names, in raw form */
2600 putc (',', asmfile
);
2601 dbxout_type (TREE_VALUE (args
), 0, 0);
2603 args
= TREE_CHAIN (args
);
2607 /* Given a chain of ..._TYPE nodes,
2608 find those which have typedef names and output those names.
2609 This is to ensure those types get output. */
2612 dbxout_types (types
)
2613 register tree types
;
2617 if (TYPE_NAME (types
)
2618 && TREE_CODE (TYPE_NAME (types
)) == TYPE_DECL
2619 && ! TREE_ASM_WRITTEN (TYPE_NAME (types
)))
2620 dbxout_symbol (TYPE_NAME (types
), 1);
2621 types
= TREE_CHAIN (types
);
2625 /* Output everything about a symbol block (a BLOCK node
2626 that represents a scope level),
2627 including recursive output of contained blocks.
2629 BLOCK is the BLOCK node.
2630 DEPTH is its depth within containing symbol blocks.
2631 ARGS is usually zero; but for the outermost block of the
2632 body of a function, it is a chain of PARM_DECLs for the function parameters.
2633 We output definitions of all the register parms
2634 as if they were local variables of that block.
2636 If -g1 was used, we count blocks just the same, but output nothing
2637 except for the outermost block.
2639 Actually, BLOCK may be several blocks chained together.
2640 We handle them all in sequence. */
2643 dbxout_block (block
, depth
, args
)
2644 register tree block
;
2650 #if DBX_BLOCKS_FUNCTION_RELATIVE
2651 const char *begin_label
;
2652 if (current_function_func_begin_label
!= NULL_TREE
)
2653 begin_label
= IDENTIFIER_POINTER (current_function_func_begin_label
);
2655 begin_label
= XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0);
2660 /* Ignore blocks never expanded or otherwise marked as real. */
2661 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
2665 #ifdef DBX_LBRAC_FIRST
2668 /* In dbx format, the syms of a block come before the N_LBRAC.
2669 If nothing is output, we don't need the N_LBRAC, either. */
2671 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2672 did_output
= dbxout_syms (BLOCK_VARS (block
));
2674 dbxout_reg_parms (args
);
2677 /* Now output an N_LBRAC symbol to represent the beginning of
2678 the block. Use the block's tree-walk order to generate
2679 the assembler symbols LBBn and LBEn
2680 that final will define around the code in this block. */
2681 if (depth
> 0 && did_output
)
2684 blocknum
= BLOCK_NUMBER (block
);
2685 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
2687 if (BLOCK_HANDLER_BLOCK (block
))
2689 /* A catch block. Must precede N_LBRAC. */
2690 tree decl
= BLOCK_VARS (block
);
2693 #ifdef DBX_OUTPUT_CATCH
2694 DBX_OUTPUT_CATCH (asmfile
, decl
, buf
);
2696 fprintf (asmfile
, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP
,
2697 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
2698 assemble_name (asmfile
, buf
);
2699 fprintf (asmfile
, "\n");
2701 decl
= TREE_CHAIN (decl
);
2705 #ifdef DBX_OUTPUT_LBRAC
2706 DBX_OUTPUT_LBRAC (asmfile
, buf
);
2708 fprintf (asmfile
, "%s%d,0,0,", ASM_STABN_OP
, N_LBRAC
);
2709 assemble_name (asmfile
, buf
);
2710 #if DBX_BLOCKS_FUNCTION_RELATIVE
2711 fputc ('-', asmfile
);
2712 assemble_name (asmfile
, begin_label
);
2714 fprintf (asmfile
, "\n");
2718 #ifdef DBX_LBRAC_FIRST
2719 /* On some weird machines, the syms of a block
2720 come after the N_LBRAC. */
2721 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2722 dbxout_syms (BLOCK_VARS (block
));
2724 dbxout_reg_parms (args
);
2727 /* Output the subblocks. */
2728 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
2730 /* Refer to the marker for the end of the block. */
2731 if (depth
> 0 && did_output
)
2734 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
2735 #ifdef DBX_OUTPUT_RBRAC
2736 DBX_OUTPUT_RBRAC (asmfile
, buf
);
2738 fprintf (asmfile
, "%s%d,0,0,", ASM_STABN_OP
, N_RBRAC
);
2739 assemble_name (asmfile
, buf
);
2740 #if DBX_BLOCKS_FUNCTION_RELATIVE
2741 fputc ('-', asmfile
);
2742 assemble_name (asmfile
, begin_label
);
2744 fprintf (asmfile
, "\n");
2748 block
= BLOCK_CHAIN (block
);
2752 /* Output the information about a function and its arguments and result.
2753 Usually this follows the function's code,
2754 but on some systems, it comes before. */
2757 dbxout_really_begin_function (decl
)
2760 dbxout_symbol (decl
, 0);
2761 dbxout_parms (DECL_ARGUMENTS (decl
));
2762 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
2763 dbxout_symbol (DECL_RESULT (decl
), 1);
2766 /* Called at beginning of output of function definition. */
2769 dbxout_begin_function (decl
)
2770 tree decl ATTRIBUTE_UNUSED
;
2772 #ifdef DBX_FUNCTION_FIRST
2773 dbxout_really_begin_function (decl
);
2777 /* Output dbx data for a function definition.
2778 This includes a definition of the function name itself (a symbol),
2779 definitions of the parameters (locating them in the parameter list)
2780 and then output the block that makes up the function's body
2781 (including all the auto variables of the function). */
2784 dbxout_function (decl
)
2787 #ifndef DBX_FUNCTION_FIRST
2788 dbxout_really_begin_function (decl
);
2790 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
2791 #ifdef DBX_OUTPUT_FUNCTION_END
2792 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
2794 #if defined(ASM_OUTPUT_SECTION_NAME)
2795 if (use_gnu_debug_info_extensions
2796 #if defined(NO_DBX_FUNCTION_END)
2797 && ! NO_DBX_FUNCTION_END
2800 dbxout_function_end ();
2803 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */