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 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"
81 #include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions. */
87 #ifdef XCOFF_DEBUGGING_INFO
92 #define ASM_STABS_OP "\t.stabs\t"
96 #define ASM_STABN_OP "\t.stabn\t"
99 #ifndef DBX_TYPE_DECL_STABS_CODE
100 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
103 #ifndef DBX_STATIC_CONST_VAR_CODE
104 #define DBX_STATIC_CONST_VAR_CODE N_FUN
107 #ifndef DBX_REGPARM_STABS_CODE
108 #define DBX_REGPARM_STABS_CODE N_RSYM
111 #ifndef DBX_REGPARM_STABS_LETTER
112 #define DBX_REGPARM_STABS_LETTER 'P'
115 /* This is used for parameters passed by invisible reference in a register. */
116 #ifndef GDB_INV_REF_REGPARM_STABS_LETTER
117 #define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
120 #ifndef DBX_MEMPARM_STABS_LETTER
121 #define DBX_MEMPARM_STABS_LETTER 'p'
124 #ifndef FILE_NAME_JOINER
125 #define FILE_NAME_JOINER "/"
128 /* Nonzero means if the type has methods, only output debugging
129 information if methods are actually written to the asm file. This
130 optimization only works if the debugger can detect the special C++
133 #define MINIMAL_DEBUG 1
135 #ifdef NO_DOLLAR_IN_LABEL
136 #ifdef NO_DOT_IN_LABEL
138 #define MINIMAL_DEBUG 0
142 /* Typical USG systems don't have stab.h, and they also have
143 no use for DBX-format debugging info. */
145 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
147 static int flag_minimal_debug
= MINIMAL_DEBUG
;
149 /* Nonzero if we have actually used any of the GDB extensions
150 to the debugging format. The idea is that we use them for the
151 first time only if there's a strong reason, but once we have done that,
152 we use them whenever convenient. */
154 static int have_used_extensions
= 0;
156 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
157 for the N_SO filename stabs label. */
159 static int source_label_number
= 1;
161 #ifdef DEBUG_SYMS_TEXT
162 #define FORCE_TEXT text_section ();
167 /* If there is a system stab.h, use it. Otherwise, use our own. */
168 /* ??? This is supposed to describe the target's stab format, so using
169 the host HAVE_STAB_H appears to be wrong. For now, we use our own file
170 when cross compiling. */
171 #if defined (USG) || !defined (HAVE_STAB_H) || defined (CROSS_COMPILE)
172 #include "gstab.h" /* If doing DBX on sysV, use our own stab.h. */
176 /* This is a GNU extension we need to reference in this file. */
183 #define STAB_CODE_TYPE enum __stab_debug_code
185 #define STAB_CODE_TYPE int
188 /* 1 if PARM is passed to this function in memory. */
190 #define PARM_PASSED_IN_MEMORY(PARM) \
191 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
193 /* A C expression for the integer offset value of an automatic variable
194 (N_LSYM) having address X (an RTX). */
195 #ifndef DEBUGGER_AUTO_OFFSET
196 #define DEBUGGER_AUTO_OFFSET(X) \
197 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
200 /* A C expression for the integer offset value of an argument (N_PSYM)
201 having address X (an RTX). The nominal offset is OFFSET. */
202 #ifndef DEBUGGER_ARG_OFFSET
203 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
206 /* Stream for writing to assembler file. */
208 static FILE *asmfile
;
210 /* Last source file name mentioned in a NOTE insn. */
212 static const char *lastfile
;
214 /* Current working directory. */
216 static const char *cwd
;
218 enum typestatus
{TYPE_UNSEEN
, TYPE_XREF
, TYPE_DEFINED
};
220 /* Structure recording information about a C data type.
221 The status element says whether we have yet output
222 the definition of the type. TYPE_XREF says we have
223 output it as a cross-reference only.
224 The file_number and type_number elements are used if DBX_USE_BINCL
229 enum typestatus status
;
236 /* Vector recording information about C data types.
237 When we first notice a data type (a tree node),
238 we assign it a number using next_type_number.
239 That is its index in this vector. */
241 struct typeinfo
*typevec
;
243 /* Number of elements of space allocated in `typevec'. */
245 static int typevec_len
;
247 /* In dbx output, each type gets a unique number.
248 This is the number for the next type output.
249 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
251 static int next_type_number
;
255 /* When using N_BINCL in dbx output, each type number is actually a
256 pair of the file number and the type number within the file.
257 This is a stack of input files. */
261 struct dbx_file
*next
;
263 int next_type_number
;
266 /* This is the top of the stack. */
268 static struct dbx_file
*current_file
;
270 /* This is the next file number to use. */
272 static int next_file_number
;
274 #endif /* DBX_USE_BINCL */
276 /* These variables are for dbxout_symbol to communicate to
277 dbxout_finish_symbol.
278 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
279 current_sym_value and current_sym_addr are two ways to address the
280 value to store in the symtab entry.
281 current_sym_addr if nonzero represents the value as an rtx.
282 If that is zero, current_sym_value is used. This is used
283 when the value is an offset (such as for auto variables,
284 register variables and parms). */
286 static STAB_CODE_TYPE current_sym_code
;
287 static int current_sym_value
;
288 static rtx current_sym_addr
;
290 /* Number of chars of symbol-description generated so far for the
291 current symbol. Used by CHARS and CONTIN. */
293 static int current_sym_nchars
;
295 /* Report having output N chars of the current symbol-description. */
297 #define CHARS(N) (current_sym_nchars += (N))
299 /* Break the current symbol-description, generating a continuation,
300 if it has become long. */
302 #ifndef DBX_CONTIN_LENGTH
303 #define DBX_CONTIN_LENGTH 80
306 #if DBX_CONTIN_LENGTH > 0
308 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
310 #define CONTIN do { } while (0)
313 #if defined(ASM_OUTPUT_SECTION_NAME)
314 static void dbxout_function_end
PARAMS ((void));
316 static void dbxout_typedefs
PARAMS ((tree
));
317 static void dbxout_type_index
PARAMS ((tree
));
318 #if DBX_CONTIN_LENGTH > 0
319 static void dbxout_continue
PARAMS ((void));
321 static void dbxout_type_fields
PARAMS ((tree
));
322 static void dbxout_type_method_1
PARAMS ((tree
, const char *));
323 static void dbxout_type_methods
PARAMS ((tree
));
324 static void dbxout_range_type
PARAMS ((tree
));
325 static void dbxout_type
PARAMS ((tree
, int, int));
326 static void print_int_cst_octal
PARAMS ((tree
));
327 static void print_octal
PARAMS ((unsigned HOST_WIDE_INT
, int));
328 static void dbxout_type_name
PARAMS ((tree
));
329 static int dbxout_symbol_location
PARAMS ((tree
, tree
, const char *, rtx
));
330 static void dbxout_symbol_name
PARAMS ((tree
, const char *, int));
331 static void dbxout_prepare_symbol
PARAMS ((tree
));
332 static void dbxout_finish_symbol
PARAMS ((tree
));
333 static void dbxout_block
PARAMS ((tree
, int, tree
));
334 static void dbxout_really_begin_function
PARAMS ((tree
));
336 #if defined(ASM_OUTPUT_SECTION_NAME)
338 dbxout_function_end ()
340 static int scope_labelno
= 0;
341 char lscope_label_name
[100];
342 /* Convert Ltext into the appropriate format for local labels in case
343 the system doesn't insert underscores in front of user generated
345 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
346 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Lscope", scope_labelno
);
349 /* By convention, GCC will mark the end of a function with an N_FUN
350 symbol and an empty string. */
351 fprintf (asmfile
, "%s \"\",%d,0,0,", ASM_STABS_OP
, N_FUN
);
352 assemble_name (asmfile
, lscope_label_name
);
353 fputc ('-', asmfile
);
354 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
355 fprintf (asmfile
, "\n");
357 #endif /* ! NO_DBX_FUNCTION_END */
359 /* At the beginning of compilation, start writing the symbol table.
360 Initialize `typevec' and output the standard data types of C. */
363 dbxout_init (asm_file
, input_file_name
, syms
)
365 const char *input_file_name
;
368 char ltext_label_name
[100];
373 typevec
= (struct typeinfo
*) xcalloc (typevec_len
, sizeof typevec
[0]);
375 /* Convert Ltext into the appropriate format for local labels in case
376 the system doesn't insert underscores in front of user generated
378 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
380 /* Put the current working directory in an N_SO symbol. */
381 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
382 but GDB always does. */
383 if (use_gnu_debug_info_extensions
)
386 if (!cwd
&& (cwd
= getpwd ()) && (!*cwd
|| cwd
[strlen (cwd
) - 1] != '/'))
388 char *wdslash
= xmalloc (strlen (cwd
) + sizeof (FILE_NAME_JOINER
));
389 sprintf (wdslash
, "%s%s", cwd
, FILE_NAME_JOINER
);
394 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
395 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile
, cwd
);
396 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
397 fprintf (asmfile
, "%s ", ASM_STABS_OP
);
398 output_quoted_string (asmfile
, cwd
);
399 fprintf (asmfile
, ",%d,0,0,%s\n", N_SO
, <ext_label_name
[1]);
400 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
404 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
405 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
406 would give us an N_SOL, and we want an N_SO. */
407 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile
, input_file_name
);
408 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
409 /* We include outputting `Ltext:' here,
410 because that gives you a way to override it. */
411 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
412 fprintf (asmfile
, "%s ", ASM_STABS_OP
);
413 output_quoted_string (asmfile
, input_file_name
);
414 fprintf (asmfile
, ",%d,0,0,%s\n",
415 N_SO
, <ext_label_name
[1]);
417 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Ltext", 0);
418 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
420 /* Possibly output something to inform GDB that this compilation was by
421 GCC. It's easier for GDB to parse it when after the N_SO's. This
422 is used in Solaris 2. */
423 #ifdef ASM_IDENTIFY_GCC_AFTER_SOURCE
424 ASM_IDENTIFY_GCC_AFTER_SOURCE (asmfile
);
427 lastfile
= input_file_name
;
429 next_type_number
= 1;
432 current_file
= (struct dbx_file
*) xmalloc (sizeof *current_file
);
433 current_file
->next
= NULL
;
434 current_file
->file_number
= 0;
435 current_file
->next_type_number
= 1;
436 next_file_number
= 1;
439 /* Make sure that types `int' and `char' have numbers 1 and 2.
440 Definitions of other integer types will refer to those numbers.
441 (Actually it should no longer matter what their numbers are.
442 Also, if any types with tags have been defined, dbxout_symbol
443 will output them first, so the numbers won't be 1 and 2. That
444 happens in C++. So it's a good thing it should no longer matter). */
446 #ifdef DBX_OUTPUT_STANDARD_TYPES
447 DBX_OUTPUT_STANDARD_TYPES (syms
);
449 dbxout_symbol (TYPE_NAME (integer_type_node
), 0);
450 dbxout_symbol (TYPE_NAME (char_type_node
), 0);
453 /* Get all permanent types that have typedef names,
454 and output them all, except for those already output. */
456 dbxout_typedefs (syms
);
458 ggc_add_string_root ((char **) &lastfile
, 1);
461 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
462 in the reverse order from that which is found in SYMS. */
465 dbxout_typedefs (syms
)
470 dbxout_typedefs (TREE_CHAIN (syms
));
471 if (TREE_CODE (syms
) == TYPE_DECL
)
473 tree type
= TREE_TYPE (syms
);
475 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
476 && COMPLETE_TYPE_P (type
)
477 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
478 dbxout_symbol (TYPE_NAME (type
), 0);
483 /* Change to reading from a new source file. Generate a N_BINCL stab. */
486 dbxout_start_new_source_file (filename
)
487 const char *filename ATTRIBUTE_UNUSED
;
490 struct dbx_file
*n
= (struct dbx_file
*) xmalloc (sizeof *n
);
492 n
->next
= current_file
;
493 n
->file_number
= next_file_number
++;
494 n
->next_type_number
= 1;
496 fprintf (asmfile
, "%s ", ASM_STABS_OP
);
497 output_quoted_string (asmfile
, filename
);
498 fprintf (asmfile
, ",%d,0,0,0\n", N_BINCL
);
502 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
505 dbxout_resume_previous_source_file ()
508 struct dbx_file
*next
;
510 fprintf (asmfile
, "%s %d,0,0,0\n", ASM_STABN_OP
, N_EINCL
);
511 next
= current_file
->next
;
517 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
520 dbxout_source_file (file
, filename
)
522 const char *filename
;
524 char ltext_label_name
[100];
526 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
528 #ifdef DBX_OUTPUT_SOURCE_FILENAME
529 DBX_OUTPUT_SOURCE_FILENAME (file
, filename
);
531 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext",
532 source_label_number
);
533 fprintf (file
, "%s ", ASM_STABS_OP
);
534 output_quoted_string (file
, filename
);
535 fprintf (file
, ",%d,0,0,%s\n", N_SOL
, <ext_label_name
[1]);
536 if (current_function_decl
!= NULL_TREE
537 && DECL_SECTION_NAME (current_function_decl
) != NULL_TREE
)
538 ; /* Don't change section amid function. */
541 ASM_OUTPUT_INTERNAL_LABEL (file
, "Ltext", source_label_number
);
542 source_label_number
++;
548 /* Output a line number symbol entry into output stream FILE,
549 for source file FILENAME and line number LINENO. */
552 dbxout_source_line (file
, filename
, lineno
)
554 const char *filename
;
557 dbxout_source_file (file
, filename
);
559 #ifdef ASM_OUTPUT_SOURCE_LINE
560 ASM_OUTPUT_SOURCE_LINE (file
, lineno
);
562 fprintf (file
, "\t%s %d,0,%d\n", ASM_STABD_OP
, N_SLINE
, lineno
);
566 /* At the end of compilation, finish writing the symbol table.
567 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
571 dbxout_finish (file
, filename
)
572 FILE *file ATTRIBUTE_UNUSED
;
573 const char *filename ATTRIBUTE_UNUSED
;
575 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
576 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file
, filename
);
577 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
580 /* Output the index of a type. */
583 dbxout_type_index (type
)
586 #ifndef DBX_USE_BINCL
587 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
590 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
591 fprintf (asmfile
, "(%d,%d)", t
->file_number
, t
->type_number
);
596 #if DBX_CONTIN_LENGTH > 0
597 /* Continue a symbol-description that gets too big.
598 End one symbol table entry with a double-backslash
599 and start a new one, eventually producing something like
600 .stabs "start......\\",code,0,value
601 .stabs "...rest",code,0,value */
606 #ifdef DBX_CONTIN_CHAR
607 fprintf (asmfile
, "%c", DBX_CONTIN_CHAR
);
609 fprintf (asmfile
, "\\\\");
611 dbxout_finish_symbol (NULL_TREE
);
612 fprintf (asmfile
, "%s \"", ASM_STABS_OP
);
613 current_sym_nchars
= 0;
615 #endif /* DBX_CONTIN_LENGTH > 0 */
617 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
618 This must be a separate function because anonymous unions require
622 dbxout_type_fields (type
)
627 /* Output the name, type, position (in bits), size (in bits) of each
628 field that we can support. */
629 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
631 /* Omit here local type decls until we know how to support them. */
632 if (TREE_CODE (tem
) == TYPE_DECL
633 /* Omit fields whose position or size are variable or too large to
635 || (TREE_CODE (tem
) == FIELD_DECL
636 && (! host_integerp (bit_position (tem
), 0)
638 || ! host_integerp (DECL_SIZE (tem
), 1)))
639 /* Omit here the nameless fields that are used to skip bits. */
640 || DECL_IGNORED_P (tem
))
643 else if (TREE_CODE (tem
) != CONST_DECL
)
645 /* Continue the line if necessary,
646 but not before the first field. */
647 if (tem
!= TYPE_FIELDS (type
))
650 if (use_gnu_debug_info_extensions
651 && flag_minimal_debug
652 && TREE_CODE (tem
) == FIELD_DECL
653 && DECL_VIRTUAL_P (tem
)
654 && DECL_ASSEMBLER_NAME (tem
))
656 have_used_extensions
= 1;
657 CHARS (3 + IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (tem
)));
658 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
)), asmfile
);
659 dbxout_type (DECL_FCONTEXT (tem
), 0, 0);
660 fprintf (asmfile
, ":");
661 dbxout_type (TREE_TYPE (tem
), 0, 0);
662 fputc (',', asmfile
);
663 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
664 int_bit_position (tem
));
665 fputc (';', asmfile
);
671 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem
)));
672 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem
)));
676 fprintf (asmfile
, ":");
680 if (use_gnu_debug_info_extensions
681 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
682 || TREE_CODE (tem
) != FIELD_DECL
))
684 have_used_extensions
= 1;
686 putc ((TREE_PRIVATE (tem
) ? '0'
687 : TREE_PROTECTED (tem
) ? '1' : '2'),
692 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
693 && DECL_BIT_FIELD_TYPE (tem
))
694 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0, 0);
696 if (TREE_CODE (tem
) == VAR_DECL
)
698 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
701 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
));
702 have_used_extensions
= 1;
703 fprintf (asmfile
, ":%s;", name
);
704 CHARS (strlen (name
));
707 /* If TEM is non-static, GDB won't understand it. */
708 fprintf (asmfile
, ",0,0;");
712 fputc (',', asmfile
);
713 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
714 int_bit_position (tem
));
715 fputc (',', asmfile
);
716 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
717 tree_low_cst (DECL_SIZE (tem
), 1));
718 fputc (';', asmfile
);
725 /* Subroutine of `dbxout_type_methods'. Output debug info about the
726 method described DECL. DEBUG_NAME is an encoding of the method's
727 type signature. ??? We may be able to do without DEBUG_NAME altogether
731 dbxout_type_method_1 (decl
, debug_name
)
733 const char *debug_name
;
737 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
739 else /* it's a METHOD_TYPE. */
741 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
742 /* A for normal functions.
743 B for `const' member functions.
744 C for `volatile' member functions.
745 D for `const volatile' member functions. */
746 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
748 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
751 if (DECL_VINDEX (decl
))
757 fprintf (asmfile
, ":%s;%c%c%c", debug_name
,
758 TREE_PRIVATE (decl
) ? '0'
759 : TREE_PROTECTED (decl
) ? '1' : '2', c1
, c2
);
760 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
)) + 6
761 - (debug_name
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
763 if (DECL_VINDEX (decl
) && host_integerp (DECL_VINDEX (decl
), 0))
765 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
766 tree_low_cst (DECL_VINDEX (decl
), 0));
767 fputc (';', asmfile
);
768 dbxout_type (DECL_CONTEXT (decl
), 0, 0);
769 fprintf (asmfile
, ";");
774 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
778 dbxout_type_methods (type
)
781 /* C++: put out the method names and their parameter lists */
782 tree methods
= TYPE_METHODS (type
);
784 register tree fndecl
;
786 char formatted_type_identifier_length
[16];
787 register int type_identifier_length
;
789 if (methods
== NULL_TREE
)
792 type_encoding
= DECL_NAME (TYPE_NAME (type
));
795 /* C++: Template classes break some assumptions made by this code about
796 the class names, constructor names, and encodings for assembler
797 label names. For now, disable output of dbx info for them. */
799 const char *ptr
= IDENTIFIER_POINTER (type_encoding
);
800 /* This should use index. (mrs) */
801 while (*ptr
&& *ptr
!= '<') ptr
++;
812 type_identifier_length
= IDENTIFIER_LENGTH (type_encoding
);
814 sprintf(formatted_type_identifier_length
, "%d", type_identifier_length
);
816 if (TREE_CODE (methods
) != TREE_VEC
)
818 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
819 fndecl
= TREE_VEC_ELT (methods
, 0);
821 fndecl
= TREE_VEC_ELT (methods
, 1);
825 tree name
= DECL_NAME (fndecl
);
828 /* Group together all the methods for the same operation.
829 These differ in the types of the arguments. */
830 for (last
= NULL_TREE
;
831 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
832 fndecl
= TREE_CHAIN (fndecl
))
833 /* Output the name of the field (after overloading), as
834 well as the name of the field before overloading, along
835 with its parameter list */
837 /* This is the "mangled" name of the method.
838 It encodes the argument types. */
839 const char *debug_name
=
840 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
));
841 int show_arg_types
= 0;
847 if (DECL_IGNORED_P (fndecl
))
850 if (flag_minimal_debug
)
854 /* We can't optimize a method which uses an anonymous
855 class, because the debugger will not be able to
856 associate the arbitrary class name with the actual
858 #ifndef NO_DOLLAR_IN_LABEL
863 if (strchr (debug_name
, marker
))
865 /* Detect ordinary methods because their mangled names
866 start with the operation name. */
867 else if (!strncmp (IDENTIFIER_POINTER (name
), debug_name
,
868 IDENTIFIER_LENGTH (name
)))
870 debug_name
+= IDENTIFIER_LENGTH (name
);
871 if (debug_name
[0] == '_' && debug_name
[1] == '_')
873 const char *method_name
= debug_name
+ 2;
874 const char *length_ptr
=
875 formatted_type_identifier_length
;
876 /* Get past const and volatile qualifiers. */
877 while (*method_name
== 'C' || *method_name
== 'V')
879 /* Skip digits for length of type_encoding. */
880 while (*method_name
== *length_ptr
&& *length_ptr
)
881 length_ptr
++, method_name
++;
882 if (! strncmp (method_name
,
883 IDENTIFIER_POINTER (type_encoding
),
884 type_identifier_length
))
885 method_name
+= type_identifier_length
;
886 debug_name
= method_name
;
889 /* Detect constructors by their style of name mangling. */
890 else if (debug_name
[0] == '_' && debug_name
[1] == '_')
892 const char *ctor_name
= debug_name
+ 2;
893 const char *length_ptr
= formatted_type_identifier_length
;
894 while (*ctor_name
== 'C' || *ctor_name
== 'V')
896 /* Skip digits for length of type_encoding. */
897 while (*ctor_name
== *length_ptr
&& *length_ptr
)
898 length_ptr
++, ctor_name
++;
899 if (!strncmp (IDENTIFIER_POINTER (type_encoding
), ctor_name
,
900 type_identifier_length
))
901 debug_name
= ctor_name
+ type_identifier_length
;
903 /* The other alternative is a destructor. */
907 /* Output the operation name just once, for the first method
911 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (name
));
912 CHARS (IDENTIFIER_LENGTH (name
) + 2);
917 dbxout_type (TREE_TYPE (fndecl
), 0, show_arg_types
);
919 dbxout_type_method_1 (fndecl
, debug_name
);
929 /* Emit a "range" type specification, which has the form:
930 "r<index type>;<lower bound>;<upper bound>;".
931 TYPE is an INTEGER_TYPE. */
934 dbxout_range_type (type
)
937 fprintf (asmfile
, "r");
938 if (TREE_TYPE (type
))
939 dbxout_type (TREE_TYPE (type
), 0, 0);
940 else if (TREE_CODE (type
) != INTEGER_TYPE
)
941 dbxout_type (type
, 0, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
944 /* Traditionally, we made sure 'int' was type 1, and builtin types
945 were defined to be sub-ranges of int. Unfortunately, this
946 does not allow us to distinguish true sub-ranges from integer
947 types. So, instead we define integer (non-sub-range) types as
948 sub-ranges of themselves. This matters for Chill. If this isn't
949 a subrange type, then we want to define it in terms of itself.
950 However, in C, this may be an anonymous integer type, and we don't
951 want to emit debug info referring to it. Just calling
952 dbxout_type_index won't work anyways, because the type hasn't been
953 defined yet. We make this work for both cases by checked to see
954 whether this is a defined type, referring to it if it is, and using
956 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
957 dbxout_type_index (type
);
959 dbxout_type_index (integer_type_node
);
962 if (TYPE_MIN_VALUE (type
) != 0
963 && host_integerp (TYPE_MIN_VALUE (type
), 0))
965 fputc (';', asmfile
);
966 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
967 tree_low_cst (TYPE_MIN_VALUE (type
), 0));
970 fprintf (asmfile
, ";0");
972 if (TYPE_MAX_VALUE (type
) != 0
973 && host_integerp (TYPE_MAX_VALUE (type
), 0))
975 fputc (';', asmfile
);
976 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
977 tree_low_cst (TYPE_MAX_VALUE (type
), 0));
978 fputc (';', asmfile
);
981 fprintf (asmfile
, ";-1;");
984 /* Output a reference to a type. If the type has not yet been
985 described in the dbx output, output its definition now.
986 For a type already defined, just refer to its definition
987 using the type number.
989 If FULL is nonzero, and the type has been described only with
990 a forward-reference, output the definition now.
991 If FULL is zero in this case, just refer to the forward-reference
992 using the number previously allocated.
994 If SHOW_ARG_TYPES is nonzero, we output a description of the argument
995 types for a METHOD_TYPE. */
998 dbxout_type (type
, full
, show_arg_types
)
1004 static int anonymous_type_number
= 0;
1006 if (TREE_CODE (type
) == VECTOR_TYPE
)
1007 type
= TYPE_DEBUG_REPRESENTATION_TYPE (type
);
1009 /* If there was an input error and we don't really have a type,
1010 avoid crashing and write something that is at least valid
1011 by assuming `int'. */
1012 if (type
== error_mark_node
)
1013 type
= integer_type_node
;
1016 /* Try to find the "main variant" with the same name but not const
1017 or volatile. (Since stabs does not distinguish const and volatile,
1018 there is no need to make them separate types. But types with
1019 different names are usefully distinguished.) */
1021 for (tem
= TYPE_MAIN_VARIANT (type
); tem
; tem
= TYPE_NEXT_VARIANT (tem
))
1022 if (!TYPE_READONLY (tem
) && !TYPE_VOLATILE (tem
)
1023 && TYPE_NAME (tem
) == TYPE_NAME (type
))
1028 if (TYPE_NAME (type
)
1029 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1030 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1034 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1036 /* Type has no dbx number assigned. Assign next available number. */
1037 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1039 /* Make sure type vector is long enough to record about this type. */
1041 if (next_type_number
== typevec_len
)
1044 = (struct typeinfo
*) xrealloc (typevec
,
1045 typevec_len
* 2 * sizeof typevec
[0]);
1046 bzero ((char *) (typevec
+ typevec_len
),
1047 typevec_len
* sizeof typevec
[0]);
1051 #ifdef DBX_USE_BINCL
1052 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1053 = current_file
->file_number
;
1054 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1055 = current_file
->next_type_number
++;
1059 /* Output the number of this type, to refer to it. */
1060 dbxout_type_index (type
);
1062 #ifdef DBX_TYPE_DEFINED
1063 if (DBX_TYPE_DEFINED (type
))
1067 /* If this type's definition has been output or is now being output,
1070 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1075 /* If we have already had a cross reference,
1076 and either that's all we want or that's the best we could do,
1077 don't repeat the cross reference.
1078 Sun dbx crashes if we do. */
1079 if (! full
|| !COMPLETE_TYPE_P (type
)
1080 /* No way in DBX fmt to describe a variable size. */
1081 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1089 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1090 leave the type-number completely undefined rather than output
1091 a cross-reference. If we have already used GNU debug info extensions,
1092 then it is OK to output a cross reference. This is necessary to get
1093 proper C++ debug output. */
1094 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1095 || TREE_CODE (type
) == QUAL_UNION_TYPE
1096 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1097 && ! use_gnu_debug_info_extensions
)
1098 /* We must use the same test here as we use twice below when deciding
1099 whether to emit a cross-reference. */
1100 if ((TYPE_NAME (type
) != 0
1101 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1102 && DECL_IGNORED_P (TYPE_NAME (type
)))
1104 || !COMPLETE_TYPE_P (type
)
1105 /* No way in DBX fmt to describe a variable size. */
1106 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1108 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1113 /* Output a definition now. */
1115 fprintf (asmfile
, "=");
1118 /* Mark it as defined, so that if it is self-referent
1119 we will not get into an infinite recursion of definitions. */
1121 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1123 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1124 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1126 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0, 0);
1130 switch (TREE_CODE (type
))
1134 /* For a void type, just define it as itself; ie, "5=5".
1135 This makes us consider it defined
1136 without saying what it is. The debugger will make it
1137 a void type when the reference is seen, and nothing will
1138 ever override that default. */
1139 dbxout_type_index (type
);
1143 if (type
== char_type_node
&& ! TREE_UNSIGNED (type
))
1145 /* Output the type `char' as a subrange of itself!
1146 I don't understand this definition, just copied it
1147 from the output of pcc.
1148 This used to use `r2' explicitly and we used to
1149 take care to make sure that `char' was type number 2. */
1150 fprintf (asmfile
, "r");
1151 dbxout_type_index (type
);
1152 fprintf (asmfile
, ";0;127;");
1155 /* If this is a subtype of another integer type, always prefer to
1156 write it as a subtype. */
1157 else if (TREE_TYPE (type
) != 0
1158 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_CST
)
1159 dbxout_range_type (type
);
1163 /* If the size is non-standard, say what it is if we can use
1166 if (use_gnu_debug_info_extensions
1167 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1168 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1170 /* If we can use GDB extensions and the size is wider than a
1171 long (the size used by GDB to read them) or we may have
1172 trouble writing the bounds the usual way, write them in
1173 octal. Note the test is for the *target's* size of "long",
1174 not that of the host. The host test is just to make sure we
1175 can write it out in case the host wide int is narrower than the
1178 /* For unsigned types, we use octal if they are the same size or
1179 larger. This is because we print the bounds as signed decimal,
1180 and hence they can't span same size unsigned types. */
1182 if (use_gnu_debug_info_extensions
1183 && TYPE_MIN_VALUE (type
) != 0
1184 && TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
1185 && TYPE_MAX_VALUE (type
) != 0
1186 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
1187 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
1188 || (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
)
1189 && TREE_UNSIGNED (type
))
1190 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
1191 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
1192 && TREE_UNSIGNED (type
))))
1194 fprintf (asmfile
, "r");
1195 dbxout_type_index (type
);
1196 fprintf (asmfile
, ";");
1197 print_int_cst_octal (TYPE_MIN_VALUE (type
));
1198 fprintf (asmfile
, ";");
1199 print_int_cst_octal (TYPE_MAX_VALUE (type
));
1200 fprintf (asmfile
, ";");
1204 /* Output other integer types as subranges of `int'. */
1205 dbxout_range_type (type
);
1212 /* This used to say `r1' and we used to take care
1213 to make sure that `int' was type number 1. */
1214 fprintf (asmfile
, "r");
1215 dbxout_type_index (integer_type_node
);
1216 fputc (';', asmfile
);
1217 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1218 fputs (";0;", asmfile
);
1223 if (use_gnu_debug_info_extensions
)
1225 fputs ("@s", asmfile
);
1226 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1227 BITS_PER_UNIT
* int_size_in_bytes (type
));
1228 fputs (";-20;", asmfile
);
1232 /* Output the type `char' as a subrange of itself.
1233 That is what pcc seems to do. */
1234 fprintf (asmfile
, "r");
1235 dbxout_type_index (char_type_node
);
1236 fprintf (asmfile
, ";0;%d;", TREE_UNSIGNED (type
) ? 255 : 127);
1242 if (use_gnu_debug_info_extensions
)
1244 fputs ("@s", asmfile
);
1245 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1246 BITS_PER_UNIT
* int_size_in_bytes (type
));
1247 fputs (";-16;", asmfile
);
1249 else /* Define as enumeral type (False, True) */
1250 fprintf (asmfile
, "eFalse:0,True:1,;");
1255 putc ('d', asmfile
);
1257 dbxout_type (TREE_TYPE (type
), 0, 0);
1261 /* Differs from the REAL_TYPE by its new data type number */
1263 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1265 fprintf (asmfile
, "r");
1266 dbxout_type_index (type
);
1267 fputc (';', asmfile
);
1268 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1269 2 * int_size_in_bytes (TREE_TYPE (type
)));
1270 fputs (";0;", asmfile
);
1271 CHARS (12); /* The number is probably incorrect here. */
1275 /* Output a complex integer type as a structure,
1276 pending some other way to do it. */
1277 fputc ('s', asmfile
);
1278 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1280 fprintf (asmfile
, "real:");
1282 dbxout_type (TREE_TYPE (type
), 0, 0);
1283 fprintf (asmfile
, ",%d,%d;",
1284 0, TYPE_PRECISION (TREE_TYPE (type
)));
1286 fprintf (asmfile
, "imag:");
1288 dbxout_type (TREE_TYPE (type
), 0, 0);
1289 fprintf (asmfile
, ",%d,%d;;",
1290 TYPE_PRECISION (TREE_TYPE (type
)),
1291 TYPE_PRECISION (TREE_TYPE (type
)));
1297 if (use_gnu_debug_info_extensions
)
1299 have_used_extensions
= 1;
1300 fputs ("@s", asmfile
);
1301 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1302 BITS_PER_UNIT
* int_size_in_bytes (type
));
1303 fputc (';', asmfile
);
1304 /* Check if a bitstring type, which in Chill is
1305 different from a [power]set. */
1306 if (TYPE_STRING_FLAG (type
))
1307 fprintf (asmfile
, "@S;");
1309 putc ('S', asmfile
);
1311 dbxout_type (TYPE_DOMAIN (type
), 0, 0);
1315 /* Make arrays of packed bits look like bitstrings for chill. */
1316 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
1318 have_used_extensions
= 1;
1319 fputs ("@s", asmfile
);
1320 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1321 BITS_PER_UNIT
* int_size_in_bytes (type
));
1322 fputc (';', asmfile
);
1323 fprintf (asmfile
, "@S;");
1324 putc ('S', asmfile
);
1326 dbxout_type (TYPE_DOMAIN (type
), 0, 0);
1329 /* Output "a" followed by a range type definition
1330 for the index type of the array
1331 followed by a reference to the target-type.
1332 ar1;0;N;M for a C array of type M and size N+1. */
1333 /* Check if a character string type, which in Chill is
1334 different from an array of characters. */
1335 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
1337 have_used_extensions
= 1;
1338 fprintf (asmfile
, "@S;");
1340 tem
= TYPE_DOMAIN (type
);
1343 fprintf (asmfile
, "ar");
1344 dbxout_type_index (integer_type_node
);
1345 fprintf (asmfile
, ";0;-1;");
1349 fprintf (asmfile
, "a");
1350 dbxout_range_type (tem
);
1353 dbxout_type (TREE_TYPE (type
), 0, 0);
1358 case QUAL_UNION_TYPE
:
1360 int i
, n_baseclasses
= 0;
1362 if (TYPE_BINFO (type
) != 0
1363 && TREE_CODE (TYPE_BINFO (type
)) == TREE_VEC
1364 && TYPE_BINFO_BASETYPES (type
) != 0)
1365 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
1367 /* Output a structure type. We must use the same test here as we
1368 use in the DBX_NO_XREFS case above. */
1369 if ((TYPE_NAME (type
) != 0
1370 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1371 && DECL_IGNORED_P (TYPE_NAME (type
)))
1373 || !COMPLETE_TYPE_P (type
)
1374 /* No way in DBX fmt to describe a variable size. */
1375 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1377 /* If the type is just a cross reference, output one
1378 and mark the type as partially described.
1379 If it later becomes defined, we will output
1380 its real definition.
1381 If the type has a name, don't nest its definition within
1382 another type's definition; instead, output an xref
1383 and let the definition come when the name is defined. */
1384 fputs ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu", asmfile
);
1386 #if 0 /* This assertion is legitimately false in C++. */
1387 /* We shouldn't be outputting a reference to a type before its
1388 definition unless the type has a tag name.
1389 A typedef name without a tag name should be impossible. */
1390 if (TREE_CODE (TYPE_NAME (type
)) != IDENTIFIER_NODE
)
1393 if (TYPE_NAME (type
) != 0)
1394 dbxout_type_name (type
);
1396 fprintf (asmfile
, "$$%d", anonymous_type_number
++);
1397 fprintf (asmfile
, ":");
1398 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1402 /* Identify record or union, and print its size. */
1403 fputc (((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u'), asmfile
);
1404 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1405 int_size_in_bytes (type
));
1407 if (use_gnu_debug_info_extensions
)
1411 have_used_extensions
= 1;
1412 fprintf (asmfile
, "!%d,", n_baseclasses
);
1416 for (i
= 0; i
< n_baseclasses
; i
++)
1418 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)), i
);
1420 if (use_gnu_debug_info_extensions
)
1422 have_used_extensions
= 1;
1423 putc (TREE_VIA_VIRTUAL (child
) ? '1' : '0', asmfile
);
1424 putc (TREE_VIA_PUBLIC (child
) ? '2' : '0', asmfile
);
1425 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1426 (tree_low_cst (BINFO_OFFSET (child
), 0)
1428 fputc (',', asmfile
);
1430 dbxout_type (BINFO_TYPE (child
), 0, 0);
1431 putc (';', asmfile
);
1435 /* Print out the base class information with fields
1436 which have the same names at the types they hold. */
1437 dbxout_type_name (BINFO_TYPE (child
));
1438 putc (':', asmfile
);
1439 dbxout_type (BINFO_TYPE (child
), full
, 0);
1440 fputc (',', asmfile
);
1441 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1442 tree_low_cst (BINFO_OFFSET (child
), 0)
1444 fputc (',', asmfile
);
1445 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1446 (tree_low_cst (DECL_SIZE (TYPE_NAME
1447 (BINFO_TYPE (child
))), 0)
1449 fputc (';', asmfile
);
1457 /* Write out the field declarations. */
1458 dbxout_type_fields (type
);
1459 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1461 have_used_extensions
= 1;
1462 dbxout_type_methods (type
);
1465 putc (';', asmfile
);
1467 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1468 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1469 && TYPE_VFIELD (type
))
1471 have_used_extensions
= 1;
1473 /* Tell GDB+ that it may keep reading. */
1474 putc ('~', asmfile
);
1476 /* We need to write out info about what field this class
1477 uses as its "main" vtable pointer field, because if this
1478 field is inherited from a base class, GDB cannot necessarily
1479 figure out which field it's using in time. */
1480 if (TYPE_VFIELD (type
))
1482 putc ('%', asmfile
);
1483 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0, 0);
1485 putc (';', asmfile
);
1491 /* We must use the same test here as we use in the DBX_NO_XREFS case
1492 above. We simplify it a bit since an enum will never have a variable
1494 if ((TYPE_NAME (type
) != 0
1495 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1496 && DECL_IGNORED_P (TYPE_NAME (type
)))
1498 || !COMPLETE_TYPE_P (type
))
1500 fprintf (asmfile
, "xe");
1502 dbxout_type_name (type
);
1503 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1504 fprintf (asmfile
, ":");
1507 #ifdef DBX_OUTPUT_ENUM
1508 DBX_OUTPUT_ENUM (asmfile
, type
);
1510 if (use_gnu_debug_info_extensions
1511 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1512 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1513 putc ('e', asmfile
);
1515 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1517 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)));
1518 if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == 0)
1519 fprintf (asmfile
, HOST_WIDE_INT_PRINT_UNSIGNED
,
1520 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1521 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == -1
1522 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (TREE_VALUE (tem
)) < 0)
1523 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1524 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1526 print_int_cst_octal (TREE_VALUE (tem
));
1527 fprintf (asmfile
, ",");
1528 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)));
1529 if (TREE_CHAIN (tem
) != 0)
1534 putc (';', asmfile
);
1540 putc ('*', asmfile
);
1542 dbxout_type (TREE_TYPE (type
), 0, 0);
1546 if (use_gnu_debug_info_extensions
)
1548 have_used_extensions
= 1;
1549 putc ('#', asmfile
);
1551 if (flag_minimal_debug
&& !show_arg_types
)
1553 /* Normally, just output the return type.
1554 The argument types are encoded in the method name. */
1555 putc ('#', asmfile
);
1557 dbxout_type (TREE_TYPE (type
), 0, 0);
1558 putc (';', asmfile
);
1563 /* When outputting destructors, we need to write
1564 the argument types out longhand. */
1565 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0, 0);
1566 putc (',', asmfile
);
1568 dbxout_type (TREE_TYPE (type
), 0, 0);
1569 dbxout_args (TYPE_ARG_TYPES (type
));
1570 putc (';', asmfile
);
1576 /* Treat it as a function type. */
1577 dbxout_type (TREE_TYPE (type
), 0, 0);
1582 if (use_gnu_debug_info_extensions
)
1584 have_used_extensions
= 1;
1585 putc ('@', asmfile
);
1587 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0, 0);
1588 putc (',', asmfile
);
1590 dbxout_type (TREE_TYPE (type
), 0, 0);
1594 /* Should print as an int, because it is really
1596 dbxout_type (integer_type_node
, 0, 0);
1600 case REFERENCE_TYPE
:
1601 if (use_gnu_debug_info_extensions
)
1602 have_used_extensions
= 1;
1603 putc (use_gnu_debug_info_extensions
? '&' : '*', asmfile
);
1605 dbxout_type (TREE_TYPE (type
), 0, 0);
1609 putc ('f', asmfile
);
1611 dbxout_type (TREE_TYPE (type
), 0, 0);
1619 /* Print the value of integer constant C, in octal,
1620 handling double precision. */
1623 print_int_cst_octal (c
)
1626 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (c
);
1627 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (c
);
1628 int excess
= (3 - (HOST_BITS_PER_WIDE_INT
% 3));
1629 unsigned int width
= TYPE_PRECISION (TREE_TYPE (c
));
1631 /* GDB wants constants with no extra leading "1" bits, so
1632 we need to remove any sign-extension that might be
1634 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
1636 else if (width
> HOST_BITS_PER_WIDE_INT
)
1637 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
1638 else if (width
== HOST_BITS_PER_WIDE_INT
)
1641 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
1643 fprintf (asmfile
, "0");
1647 print_octal (high
, HOST_BITS_PER_WIDE_INT
/ 3);
1648 print_octal (low
, HOST_BITS_PER_WIDE_INT
/ 3);
1652 unsigned HOST_WIDE_INT beg
= high
>> excess
;
1653 unsigned HOST_WIDE_INT middle
1654 = ((high
& (((HOST_WIDE_INT
) 1 << excess
) - 1)) << (3 - excess
)
1655 | (low
>> (HOST_BITS_PER_WIDE_INT
/ 3 * 3)));
1656 unsigned HOST_WIDE_INT end
1657 = low
& (((unsigned HOST_WIDE_INT
) 1
1658 << (HOST_BITS_PER_WIDE_INT
/ 3 * 3))
1661 fprintf (asmfile
, "%o%01o", (int) beg
, (int) middle
);
1662 print_octal (end
, HOST_BITS_PER_WIDE_INT
/ 3);
1667 print_octal (value
, digits
)
1668 unsigned HOST_WIDE_INT value
;
1673 for (i
= digits
- 1; i
>= 0; i
--)
1674 fprintf (asmfile
, "%01o", (int) ((value
>> (3 * i
)) & 7));
1677 /* Output the name of type TYPE, with no punctuation.
1678 Such names can be set up either by typedef declarations
1679 or by struct, enum and union tags. */
1682 dbxout_type_name (type
)
1686 if (TYPE_NAME (type
) == 0)
1688 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
1690 t
= TYPE_NAME (type
);
1692 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1694 t
= DECL_NAME (TYPE_NAME (type
));
1699 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
1700 CHARS (IDENTIFIER_LENGTH (t
));
1703 /* Output a .stabs for the symbol defined by DECL,
1704 which must be a ..._DECL node in the normal namespace.
1705 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1706 LOCAL is nonzero if the scope is less than the entire file.
1707 Return 1 if a stabs might have been emitted. */
1710 dbxout_symbol (decl
, local
)
1712 int local ATTRIBUTE_UNUSED
;
1714 tree type
= TREE_TYPE (decl
);
1715 tree context
= NULL_TREE
;
1718 /* Cast avoids warning in old compilers. */
1719 current_sym_code
= (STAB_CODE_TYPE
) 0;
1720 current_sym_value
= 0;
1721 current_sym_addr
= 0;
1723 /* Ignore nameless syms, but don't ignore type tags. */
1725 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
1726 || DECL_IGNORED_P (decl
))
1729 dbxout_prepare_symbol (decl
);
1731 /* The output will always start with the symbol name,
1732 so always count that in the length-output-so-far. */
1734 if (DECL_NAME (decl
) != 0)
1735 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
1737 switch (TREE_CODE (decl
))
1740 /* Enum values are defined by defining the enum type. */
1744 if (DECL_RTL (decl
) == 0)
1746 if (DECL_EXTERNAL (decl
))
1748 /* Don't mention a nested function under its parent. */
1749 context
= decl_function_context (decl
);
1750 if (context
== current_function_decl
)
1752 if (GET_CODE (DECL_RTL (decl
)) != MEM
1753 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
1757 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
1758 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1759 TREE_PUBLIC (decl
) ? 'F' : 'f');
1762 current_sym_code
= N_FUN
;
1763 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1765 if (TREE_TYPE (type
))
1766 dbxout_type (TREE_TYPE (type
), 0, 0);
1768 dbxout_type (void_type_node
, 0, 0);
1770 /* For a nested function, when that function is compiled,
1771 mention the containing function name
1772 as well as (since dbx wants it) our own assembler-name. */
1774 fprintf (asmfile
, ",%s,%s",
1775 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1776 IDENTIFIER_POINTER (DECL_NAME (context
)));
1778 dbxout_finish_symbol (decl
);
1783 /* This seems all wrong. Outputting most kinds of types gives no name
1784 at all. A true definition gives no name; a cross-ref for a
1785 structure can give the tag name, but not a type name.
1786 It seems that no typedef name is defined by outputting a type. */
1788 /* If this typedef name was defined by outputting the type,
1789 don't duplicate it. */
1790 if (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
== TYPE_DEFINED
1791 && TYPE_NAME (TREE_TYPE (decl
)) == decl
)
1794 /* Don't output the same typedef twice.
1795 And don't output what language-specific stuff doesn't want output. */
1796 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
1805 if (DECL_NAME (decl
))
1807 /* Nonzero means we must output a tag as well as a typedef. */
1810 /* Handle the case of a C++ structure or union
1811 where the TYPE_NAME is a TYPE_DECL
1812 which gives both a typedef name and a tag. */
1813 /* dbx requires the tag first and the typedef second. */
1814 if ((TREE_CODE (type
) == RECORD_TYPE
1815 || TREE_CODE (type
) == UNION_TYPE
1816 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1817 && TYPE_NAME (type
) == decl
1818 && !(use_gnu_debug_info_extensions
&& have_used_extensions
)
1819 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
1820 /* Distinguish the implicit typedefs of C++
1821 from explicit ones that might be found in C. */
1822 && DECL_ARTIFICIAL (decl
))
1824 tree name
= TYPE_NAME (type
);
1825 if (TREE_CODE (name
) == TYPE_DECL
)
1826 name
= DECL_NAME (name
);
1828 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1829 current_sym_value
= 0;
1830 current_sym_addr
= 0;
1831 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1833 fprintf (asmfile
, "%s \"%s:T", ASM_STABS_OP
,
1834 IDENTIFIER_POINTER (name
));
1835 dbxout_type (type
, 1, 0);
1836 dbxout_finish_symbol (NULL_TREE
);
1839 /* Output typedef name. */
1840 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
,
1841 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1843 /* Short cut way to output a tag also. */
1844 if ((TREE_CODE (type
) == RECORD_TYPE
1845 || TREE_CODE (type
) == UNION_TYPE
1846 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1847 && TYPE_NAME (type
) == decl
1848 /* Distinguish the implicit typedefs of C++
1849 from explicit ones that might be found in C. */
1850 && DECL_ARTIFICIAL (decl
))
1852 if (use_gnu_debug_info_extensions
&& have_used_extensions
)
1854 putc ('T', asmfile
);
1855 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
1857 #if 0 /* Now we generate the tag for this case up above. */
1863 putc ('t', asmfile
);
1864 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1866 dbxout_type (type
, 1, 0);
1867 dbxout_finish_symbol (decl
);
1871 /* Don't output a tag if this is an incomplete type (TYPE_SIZE is
1872 zero). This prevents the sun4 Sun OS 4.x dbx from crashing. */
1874 if (tag_needed
&& TYPE_NAME (type
) != 0
1875 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
1876 || (DECL_NAME (TYPE_NAME (type
)) != 0))
1877 && COMPLETE_TYPE_P (type
)
1878 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1880 /* For a TYPE_DECL with no name, but the type has a name,
1882 This is what represents `struct foo' with no typedef. */
1883 /* In C++, the name of a type is the corresponding typedef.
1884 In C, it is an IDENTIFIER_NODE. */
1885 tree name
= TYPE_NAME (type
);
1886 if (TREE_CODE (name
) == TYPE_DECL
)
1887 name
= DECL_NAME (name
);
1889 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1890 current_sym_value
= 0;
1891 current_sym_addr
= 0;
1892 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1894 fprintf (asmfile
, "%s \"%s:T", ASM_STABS_OP
,
1895 IDENTIFIER_POINTER (name
));
1896 dbxout_type (type
, 1, 0);
1897 dbxout_finish_symbol (NULL_TREE
);
1901 /* If an enum type has no name, it cannot be referred to,
1902 but we must output it anyway, since the enumeration constants
1903 can be referred to. */
1904 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
1906 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1907 current_sym_value
= 0;
1908 current_sym_addr
= 0;
1909 current_sym_nchars
= 2;
1911 /* Some debuggers fail when given NULL names, so give this a
1912 harmless name of ` '. */
1913 fprintf (asmfile
, "%s \" :T", ASM_STABS_OP
);
1914 dbxout_type (type
, 1, 0);
1915 dbxout_finish_symbol (NULL_TREE
);
1918 /* Prevent duplicate output of a typedef. */
1919 TREE_ASM_WRITTEN (decl
) = 1;
1924 /* Parm decls go in their own separate chains
1925 and are output by dbxout_reg_parms and dbxout_parms. */
1929 /* Named return value, treat like a VAR_DECL. */
1931 if (DECL_RTL (decl
) == 0)
1933 /* Don't mention a variable that is external.
1934 Let the file that defines it describe it. */
1935 if (DECL_EXTERNAL (decl
))
1938 /* If the variable is really a constant
1939 and not written in memory, inform the debugger. */
1940 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
1941 && DECL_INITIAL (decl
) != 0
1942 && host_integerp (DECL_INITIAL (decl
), 0)
1943 && ! TREE_ASM_WRITTEN (decl
)
1944 && (DECL_CONTEXT (decl
) == NULL_TREE
1945 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
))
1947 if (TREE_PUBLIC (decl
) == 0)
1949 /* The sun4 assembler does not grok this. */
1950 const char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1952 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
1953 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
1955 HOST_WIDE_INT ival
= tree_low_cst (DECL_INITIAL (decl
), 0);
1956 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1957 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile
, name
, ival
);
1959 fprintf (asmfile
, "%s \"%s:c=i", ASM_STABS_OP
, name
);
1961 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, ival
);
1962 fprintf (asmfile
, "\",0x%x,0,0,0\n", N_LSYM
);
1966 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
1968 /* don't know how to do this yet. */
1972 /* else it is something we handle like a normal variable. */
1975 DECL_RTL (decl
) = eliminate_regs (DECL_RTL (decl
), 0, NULL_RTX
);
1976 #ifdef LEAF_REG_REMAP
1977 if (current_function_uses_only_leaf_regs
)
1978 leaf_renumber_regs_insn (DECL_RTL (decl
));
1981 result
= dbxout_symbol_location (decl
, type
, 0, DECL_RTL (decl
));
1990 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1991 Add SUFFIX to its name, if SUFFIX is not 0.
1992 Describe the variable as residing in HOME
1993 (usually HOME is DECL_RTL (DECL), but not always).
1994 Returns 1 if the stab was really emitted. */
1997 dbxout_symbol_location (decl
, type
, suffix
, home
)
2005 /* Don't mention a variable at all
2006 if it was completely optimized into nothingness.
2008 If the decl was from an inline function, then its rtl
2009 is not identically the rtl that was used in this
2010 particular compilation. */
2011 if (GET_CODE (home
) == REG
)
2013 regno
= REGNO (home
);
2014 if (regno
>= FIRST_PSEUDO_REGISTER
)
2017 else if (GET_CODE (home
) == SUBREG
)
2021 while (GET_CODE (value
) == SUBREG
)
2023 offset
+= SUBREG_WORD (value
);
2024 value
= SUBREG_REG (value
);
2026 if (GET_CODE (value
) == REG
)
2028 regno
= REGNO (value
);
2029 if (regno
>= FIRST_PSEUDO_REGISTER
)
2033 alter_subreg (home
);
2036 /* The kind-of-variable letter depends on where
2037 the variable is and on the scope of its name:
2038 G and N_GSYM for static storage and global scope,
2039 S for static storage and file scope,
2040 V for static storage and local scope,
2041 for those two, use N_LCSYM if data is in bss segment,
2042 N_STSYM if in data segment, N_FUN otherwise.
2043 (We used N_FUN originally, then changed to N_STSYM
2044 to please GDB. However, it seems that confused ld.
2045 Now GDB has been fixed to like N_FUN, says Kingdon.)
2046 no letter at all, and N_LSYM, for auto variable,
2047 r and N_RSYM for register variable. */
2049 if (GET_CODE (home
) == MEM
2050 && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2052 if (TREE_PUBLIC (decl
))
2055 current_sym_code
= N_GSYM
;
2059 current_sym_addr
= XEXP (home
, 0);
2061 letter
= decl_function_context (decl
) ? 'V' : 'S';
2063 /* This should be the same condition as in assemble_variable, but
2064 we don't have access to dont_output_data here. So, instead,
2065 we rely on the fact that error_mark_node initializers always
2066 end up in bss for C++ and never end up in bss for C. */
2067 if (DECL_INITIAL (decl
) == 0
2068 || (!strcmp (lang_identify (), "cplusplus")
2069 && DECL_INITIAL (decl
) == error_mark_node
))
2070 current_sym_code
= N_LCSYM
;
2071 else if (DECL_IN_TEXT_SECTION (decl
))
2072 /* This is not quite right, but it's the closest
2073 of all the codes that Unix defines. */
2074 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
2077 /* Ultrix `as' seems to need this. */
2078 #ifdef DBX_STATIC_STAB_DATA_SECTION
2081 current_sym_code
= N_STSYM
;
2085 else if (regno
>= 0)
2088 current_sym_code
= N_RSYM
;
2089 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
2091 else if (GET_CODE (home
) == MEM
2092 && (GET_CODE (XEXP (home
, 0)) == MEM
2093 || (GET_CODE (XEXP (home
, 0)) == REG
2094 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
2095 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
2096 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2097 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
2100 /* If the value is indirect by memory or by a register
2101 that isn't the frame pointer
2102 then it means the object is variable-sized and address through
2103 that register or stack slot. DBX has no way to represent this
2104 so all we can do is output the variable as a pointer.
2105 If it's not a parameter, ignore it.
2106 (VAR_DECLs like this can be made by integrate.c.) */
2108 if (GET_CODE (XEXP (home
, 0)) == REG
)
2111 current_sym_code
= N_RSYM
;
2112 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
2116 current_sym_code
= N_LSYM
;
2117 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2118 We want the value of that CONST_INT. */
2120 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
2123 /* Effectively do build_pointer_type, but don't cache this type,
2124 since it might be temporary whereas the type it points to
2125 might have been saved for inlining. */
2126 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2127 type
= make_node (POINTER_TYPE
);
2128 TREE_TYPE (type
) = TREE_TYPE (decl
);
2130 else if (GET_CODE (home
) == MEM
2131 && GET_CODE (XEXP (home
, 0)) == REG
)
2133 current_sym_code
= N_LSYM
;
2134 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2136 else if (GET_CODE (home
) == MEM
2137 && GET_CODE (XEXP (home
, 0)) == PLUS
2138 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
2140 current_sym_code
= N_LSYM
;
2141 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2142 We want the value of that CONST_INT. */
2143 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2145 else if (GET_CODE (home
) == MEM
2146 && GET_CODE (XEXP (home
, 0)) == CONST
)
2148 /* Handle an obscure case which can arise when optimizing and
2149 when there are few available registers. (This is *always*
2150 the case for i386/i486 targets). The RTL looks like
2151 (MEM (CONST ...)) even though this variable is a local `auto'
2152 or a local `register' variable. In effect, what has happened
2153 is that the reload pass has seen that all assignments and
2154 references for one such a local variable can be replaced by
2155 equivalent assignments and references to some static storage
2156 variable, thereby avoiding the need for a register. In such
2157 cases we're forced to lie to debuggers and tell them that
2158 this variable was itself `static'. */
2159 current_sym_code
= N_LCSYM
;
2161 current_sym_addr
= XEXP (XEXP (home
, 0), 0);
2163 else if (GET_CODE (home
) == CONCAT
)
2165 tree subtype
= TREE_TYPE (type
);
2167 /* If the variable's storage is in two parts,
2168 output each as a separate stab with a modified name. */
2169 if (WORDS_BIG_ENDIAN
)
2170 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
2172 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
2174 /* Cast avoids warning in old compilers. */
2175 current_sym_code
= (STAB_CODE_TYPE
) 0;
2176 current_sym_value
= 0;
2177 current_sym_addr
= 0;
2178 dbxout_prepare_symbol (decl
);
2180 if (WORDS_BIG_ENDIAN
)
2181 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
2183 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
2187 /* Address might be a MEM, when DECL is a variable-sized object.
2188 Or it might be const0_rtx, meaning previous passes
2189 want us to ignore this variable. */
2192 /* Ok, start a symtab entry and output the variable name. */
2195 #ifdef DBX_STATIC_BLOCK_START
2196 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
2199 dbxout_symbol_name (decl
, suffix
, letter
);
2200 dbxout_type (type
, 0, 0);
2201 dbxout_finish_symbol (decl
);
2203 #ifdef DBX_STATIC_BLOCK_END
2204 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
2209 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2210 Then output LETTER to indicate the kind of location the symbol has. */
2213 dbxout_symbol_name (decl
, suffix
, letter
)
2220 if (DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
)))
2221 /* One slight hitch: if this is a VAR_DECL which is a static
2222 class member, we must put out the mangled name instead of the
2223 DECL_NAME. Note also that static member (variable) names DO NOT begin
2224 with underscores in .stabs directives. */
2225 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2227 /* ...but if we're function-local, we don't want to include the junk
2228 added by ASM_FORMAT_PRIVATE_NAME. */
2229 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
2233 fprintf (asmfile
, "%s \"%s%s:", ASM_STABS_OP
, name
,
2234 (suffix
? suffix
: ""));
2236 if (letter
) putc (letter
, asmfile
);
2240 dbxout_prepare_symbol (decl
)
2241 tree decl ATTRIBUTE_UNUSED
;
2244 const char *filename
= DECL_SOURCE_FILE (decl
);
2246 dbxout_source_file (asmfile
, filename
);
2251 dbxout_finish_symbol (sym
)
2254 #ifdef DBX_FINISH_SYMBOL
2255 DBX_FINISH_SYMBOL (sym
);
2258 if (use_gnu_debug_info_extensions
&& sym
!= 0)
2259 line
= DECL_SOURCE_LINE (sym
);
2261 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
2262 if (current_sym_addr
)
2263 output_addr_const (asmfile
, current_sym_addr
);
2265 fprintf (asmfile
, "%d", current_sym_value
);
2266 putc ('\n', asmfile
);
2270 /* Output definitions of all the decls in a chain. Return non-zero if
2271 anything was output */
2280 result
+= dbxout_symbol (syms
, 1);
2281 syms
= TREE_CHAIN (syms
);
2286 /* The following two functions output definitions of function parameters.
2287 Each parameter gets a definition locating it in the parameter list.
2288 Each parameter that is a register variable gets a second definition
2289 locating it in the register.
2291 Printing or argument lists in gdb uses the definitions that
2292 locate in the parameter list. But reference to the variable in
2293 expressions uses preferentially the definition as a register. */
2295 /* Output definitions, referring to storage in the parmlist,
2296 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2299 dbxout_parms (parms
)
2302 for (; parms
; parms
= TREE_CHAIN (parms
))
2303 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
2305 dbxout_prepare_symbol (parms
);
2307 /* Perform any necessary register eliminations on the parameter's rtl,
2308 so that the debugging output will be accurate. */
2309 DECL_INCOMING_RTL (parms
)
2310 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
2311 DECL_RTL (parms
) = eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
);
2312 #ifdef LEAF_REG_REMAP
2313 if (current_function_uses_only_leaf_regs
)
2315 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
2316 leaf_renumber_regs_insn (DECL_RTL (parms
));
2320 if (PARM_PASSED_IN_MEMORY (parms
))
2322 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
2324 /* ??? Here we assume that the parm address is indexed
2325 off the frame pointer or arg pointer.
2326 If that is not true, we produce meaningless results,
2327 but do not crash. */
2328 if (GET_CODE (addr
) == PLUS
2329 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
2330 current_sym_value
= INTVAL (XEXP (addr
, 1));
2332 current_sym_value
= 0;
2334 current_sym_code
= N_PSYM
;
2335 current_sym_addr
= 0;
2338 if (DECL_NAME (parms
))
2340 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2342 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2343 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2344 DBX_MEMPARM_STABS_LETTER
);
2348 current_sym_nchars
= 8;
2349 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2350 DBX_MEMPARM_STABS_LETTER
);
2353 /* It is quite tempting to use:
2355 dbxout_type (TREE_TYPE (parms), 0, 0);
2357 as the next statement, rather than using DECL_ARG_TYPE(), so
2358 that gcc reports the actual type of the parameter, rather
2359 than the promoted type. This certainly makes GDB's life
2360 easier, at least for some ports. The change is a bad idea
2361 however, since GDB expects to be able access the type without
2362 performing any conversions. So for example, if we were
2363 passing a float to an unprototyped function, gcc will store a
2364 double on the stack, but if we emit a stab saying the type is a
2365 float, then gdb will only read in a single value, and this will
2366 produce an erropneous value. */
2367 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
2368 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
2369 dbxout_finish_symbol (parms
);
2371 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
2374 char regparm_letter
;
2376 /* Parm passed in registers and lives in registers or nowhere. */
2378 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2379 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2380 current_sym_addr
= 0;
2382 /* If parm lives in a register, use that register;
2383 pretend the parm was passed there. It would be more consistent
2384 to describe the register where the parm was passed,
2385 but in practice that register usually holds something else.
2387 If we use DECL_RTL, then we must use the declared type of
2388 the variable, not the type that it arrived in. */
2389 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2391 best_rtl
= DECL_RTL (parms
);
2392 parm_type
= TREE_TYPE (parms
);
2394 /* If the parm lives nowhere, use the register where it was
2395 passed. It is also better to use the declared type here. */
2398 best_rtl
= DECL_INCOMING_RTL (parms
);
2399 parm_type
= TREE_TYPE (parms
);
2401 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
2404 if (DECL_NAME (parms
))
2406 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2407 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2408 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2413 current_sym_nchars
= 8;
2414 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2418 dbxout_type (parm_type
, 0, 0);
2419 dbxout_finish_symbol (parms
);
2421 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2422 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
2423 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
2424 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
2425 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2426 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
2430 /* Parm was passed via invisible reference.
2431 That is, its address was passed in a register.
2432 Output it as if it lived in that register.
2433 The debugger will know from the type
2434 that it was actually passed by invisible reference. */
2436 char regparm_letter
;
2437 /* Parm passed in registers and lives in registers or nowhere. */
2439 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2440 if (use_gnu_debug_info_extensions
)
2441 regparm_letter
= GDB_INV_REF_REGPARM_STABS_LETTER
;
2443 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2445 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2446 If it is an unallocated pseudo-reg, then use the register where
2447 it was passed instead. */
2448 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
2449 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
2451 current_sym_value
= REGNO (DECL_INCOMING_RTL (parms
));
2453 current_sym_addr
= 0;
2456 if (DECL_NAME (parms
))
2458 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2460 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2461 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2466 current_sym_nchars
= 8;
2467 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2471 dbxout_type (TREE_TYPE (parms
), 0, 0);
2472 dbxout_finish_symbol (parms
);
2474 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2475 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
2476 /* ??? A constant address for a parm can happen
2477 when the reg it lives in is equiv to a constant in memory.
2478 Should make this not happen, after 2.4. */
2479 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
2481 /* Parm was passed in registers but lives on the stack. */
2482 int aux_sym_value
= 0;
2484 current_sym_code
= N_PSYM
;
2485 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2486 in which case we want the value of that CONST_INT,
2487 or (MEM (REG ...)) or (MEM (MEM ...)),
2488 in which case we use a value of zero. */
2489 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
)
2490 current_sym_value
= 0;
2491 else if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
2493 /* Remember the location on the stack the parm is moved to */
2495 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
2496 current_sym_value
= 0;
2500 = INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
2502 current_sym_addr
= 0;
2504 /* Make a big endian correction if the mode of the type of the
2505 parameter is not the same as the mode of the rtl. */
2506 if (BYTES_BIG_ENDIAN
2507 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
2508 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
2510 current_sym_value
+=
2511 GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
2512 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
)));
2516 if (DECL_NAME (parms
))
2519 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2521 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2522 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2523 DBX_MEMPARM_STABS_LETTER
);
2527 current_sym_nchars
= 8;
2528 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2529 DBX_MEMPARM_STABS_LETTER
);
2533 = DEBUGGER_ARG_OFFSET (current_sym_value
,
2534 XEXP (DECL_RTL (parms
), 0));
2535 dbxout_type (TREE_TYPE (parms
), 0, 0);
2536 dbxout_finish_symbol (parms
);
2537 if (aux_sym_value
!= 0)
2539 /* Generate an entry for the stack location */
2541 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
,
2542 IDENTIFIER_POINTER (DECL_NAME (parms
)));
2543 current_sym_value
= aux_sym_value
;
2544 current_sym_code
= N_LSYM
;
2545 dbxout_type (build_reference_type (TREE_TYPE (parms
)), 0, 0);
2546 dbxout_finish_symbol (parms
);
2552 /* Output definitions for the places where parms live during the function,
2553 when different from where they were passed, when the parms were passed
2556 It is not useful to do this for parms passed in registers
2557 that live during the function in different registers, because it is
2558 impossible to look in the passed register for the passed value,
2559 so we use the within-the-function register to begin with.
2561 PARMS is a chain of PARM_DECL nodes. */
2564 dbxout_reg_parms (parms
)
2567 for (; parms
; parms
= TREE_CHAIN (parms
))
2568 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
2570 dbxout_prepare_symbol (parms
);
2572 /* Report parms that live in registers during the function
2573 but were passed in memory. */
2574 if (GET_CODE (DECL_RTL (parms
)) == REG
2575 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2576 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2577 0, DECL_RTL (parms
));
2578 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
2579 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2580 0, DECL_RTL (parms
));
2581 /* Report parms that live in memory but not where they were passed. */
2582 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2583 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
2584 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2585 0, DECL_RTL (parms
));
2589 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2590 output definitions of those names, in raw form */
2598 putc (',', asmfile
);
2599 dbxout_type (TREE_VALUE (args
), 0, 0);
2601 args
= TREE_CHAIN (args
);
2605 /* Given a chain of ..._TYPE nodes,
2606 find those which have typedef names and output those names.
2607 This is to ensure those types get output. */
2610 dbxout_types (types
)
2611 register tree types
;
2615 if (TYPE_NAME (types
)
2616 && TREE_CODE (TYPE_NAME (types
)) == TYPE_DECL
2617 && ! TREE_ASM_WRITTEN (TYPE_NAME (types
)))
2618 dbxout_symbol (TYPE_NAME (types
), 1);
2619 types
= TREE_CHAIN (types
);
2623 /* Output everything about a symbol block (a BLOCK node
2624 that represents a scope level),
2625 including recursive output of contained blocks.
2627 BLOCK is the BLOCK node.
2628 DEPTH is its depth within containing symbol blocks.
2629 ARGS is usually zero; but for the outermost block of the
2630 body of a function, it is a chain of PARM_DECLs for the function parameters.
2631 We output definitions of all the register parms
2632 as if they were local variables of that block.
2634 If -g1 was used, we count blocks just the same, but output nothing
2635 except for the outermost block.
2637 Actually, BLOCK may be several blocks chained together.
2638 We handle them all in sequence. */
2641 dbxout_block (block
, depth
, args
)
2642 register tree block
;
2649 #if DBX_BLOCKS_FUNCTION_RELATIVE
2650 const char *begin_label
;
2651 if (current_function_func_begin_label
!= NULL_TREE
)
2652 begin_label
= IDENTIFIER_POINTER (current_function_func_begin_label
);
2654 begin_label
= XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0);
2659 /* Ignore blocks never expanded or otherwise marked as real. */
2660 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
2662 #ifndef DBX_LBRAC_FIRST
2663 /* In dbx format, the syms of a block come before the N_LBRAC.
2664 If nothing is output, we don't need the N_LBRAC, either. */
2666 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2667 ignored
= dbxout_syms (BLOCK_VARS (block
));
2669 dbxout_reg_parms (args
);
2672 /* Now output an N_LBRAC symbol to represent the beginning of
2673 the block. Use the block's tree-walk order to generate
2674 the assembler symbols LBBn and LBEn
2675 that final will define around the code in this block. */
2676 if (depth
> 0 && !ignored
)
2679 blocknum
= BLOCK_NUMBER (block
);
2680 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
2682 if (BLOCK_HANDLER_BLOCK (block
))
2684 /* A catch block. Must precede N_LBRAC. */
2685 tree decl
= BLOCK_VARS (block
);
2688 #ifdef DBX_OUTPUT_CATCH
2689 DBX_OUTPUT_CATCH (asmfile
, decl
, buf
);
2691 fprintf (asmfile
, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP
,
2692 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
2693 assemble_name (asmfile
, buf
);
2694 fprintf (asmfile
, "\n");
2696 decl
= TREE_CHAIN (decl
);
2700 #ifdef DBX_OUTPUT_LBRAC
2701 DBX_OUTPUT_LBRAC (asmfile
, buf
);
2703 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_LBRAC
);
2704 assemble_name (asmfile
, buf
);
2705 #if DBX_BLOCKS_FUNCTION_RELATIVE
2706 fputc ('-', asmfile
);
2707 assemble_name (asmfile
, begin_label
);
2709 fprintf (asmfile
, "\n");
2713 #ifdef DBX_LBRAC_FIRST
2714 /* On some weird machines, the syms of a block
2715 come after the N_LBRAC. */
2716 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2717 dbxout_syms (BLOCK_VARS (block
));
2719 dbxout_reg_parms (args
);
2722 /* Output the subblocks. */
2723 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
2725 /* Refer to the marker for the end of the block. */
2726 if (depth
> 0 && !ignored
)
2729 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
2730 #ifdef DBX_OUTPUT_RBRAC
2731 DBX_OUTPUT_RBRAC (asmfile
, buf
);
2733 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_RBRAC
);
2734 assemble_name (asmfile
, buf
);
2735 #if DBX_BLOCKS_FUNCTION_RELATIVE
2736 fputc ('-', asmfile
);
2737 assemble_name (asmfile
, begin_label
);
2739 fprintf (asmfile
, "\n");
2743 block
= BLOCK_CHAIN (block
);
2747 /* Output the information about a function and its arguments and result.
2748 Usually this follows the function's code,
2749 but on some systems, it comes before. */
2752 dbxout_really_begin_function (decl
)
2755 dbxout_symbol (decl
, 0);
2756 dbxout_parms (DECL_ARGUMENTS (decl
));
2757 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
2758 dbxout_symbol (DECL_RESULT (decl
), 1);
2761 /* Called at beginning of output of function definition. */
2764 dbxout_begin_function (decl
)
2765 tree decl ATTRIBUTE_UNUSED
;
2767 #ifdef DBX_FUNCTION_FIRST
2768 dbxout_really_begin_function (decl
);
2772 /* Output dbx data for a function definition.
2773 This includes a definition of the function name itself (a symbol),
2774 definitions of the parameters (locating them in the parameter list)
2775 and then output the block that makes up the function's body
2776 (including all the auto variables of the function). */
2779 dbxout_function (decl
)
2782 #ifndef DBX_FUNCTION_FIRST
2783 dbxout_really_begin_function (decl
);
2785 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
2786 #ifdef DBX_OUTPUT_FUNCTION_END
2787 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
2789 #if defined(ASM_OUTPUT_SECTION_NAME)
2790 if (use_gnu_debug_info_extensions
2791 #if defined(NO_DBX_FUNCTION_END)
2792 && ! NO_DBX_FUNCTION_END
2795 dbxout_function_end ();
2798 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */