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 ".stabs"
96 #define ASM_STABN_OP ".stabn"
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)
637 || ! host_integerp (DECL_SIZE (tem
), 1)))
638 /* Omit here the nameless fields that are used to skip bits. */
639 || DECL_IGNORED_P (tem
))
642 else if (TREE_CODE (tem
) != CONST_DECL
)
644 /* Continue the line if necessary,
645 but not before the first field. */
646 if (tem
!= TYPE_FIELDS (type
))
649 if (use_gnu_debug_info_extensions
650 && flag_minimal_debug
651 && TREE_CODE (tem
) == FIELD_DECL
652 && DECL_VIRTUAL_P (tem
)
653 && DECL_ASSEMBLER_NAME (tem
))
655 have_used_extensions
= 1;
656 CHARS (3 + IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (tem
)));
657 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
)), asmfile
);
658 dbxout_type (DECL_FCONTEXT (tem
), 0, 0);
659 fprintf (asmfile
, ":");
660 dbxout_type (TREE_TYPE (tem
), 0, 0);
661 fputc (',', asmfile
);
662 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
663 int_bit_position (tem
));
664 fputc (';', asmfile
);
670 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem
)));
671 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem
)));
675 fprintf (asmfile
, ":");
679 if (use_gnu_debug_info_extensions
680 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
681 || TREE_CODE (tem
) != FIELD_DECL
))
683 have_used_extensions
= 1;
685 putc ((TREE_PRIVATE (tem
) ? '0'
686 : TREE_PROTECTED (tem
) ? '1' : '2'),
691 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
692 && DECL_BIT_FIELD_TYPE (tem
))
693 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0, 0);
695 if (TREE_CODE (tem
) == VAR_DECL
)
697 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
700 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
));
701 have_used_extensions
= 1;
702 fprintf (asmfile
, ":%s;", name
);
703 CHARS (strlen (name
));
706 /* If TEM is non-static, GDB won't understand it. */
707 fprintf (asmfile
, ",0,0;");
711 fputc (',', asmfile
);
712 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
713 int_bit_position (tem
));
714 fputc (',', asmfile
);
715 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
716 tree_low_cst (DECL_SIZE (tem
), 1));
717 fputc (';', asmfile
);
724 /* Subroutine of `dbxout_type_methods'. Output debug info about the
725 method described DECL. DEBUG_NAME is an encoding of the method's
726 type signature. ??? We may be able to do without DEBUG_NAME altogether
730 dbxout_type_method_1 (decl
, debug_name
)
732 const char *debug_name
;
736 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
738 else /* it's a METHOD_TYPE. */
740 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
741 /* A for normal functions.
742 B for `const' member functions.
743 C for `volatile' member functions.
744 D for `const volatile' member functions. */
745 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
747 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
750 if (DECL_VINDEX (decl
))
756 fprintf (asmfile
, ":%s;%c%c%c", debug_name
,
757 TREE_PRIVATE (decl
) ? '0'
758 : TREE_PROTECTED (decl
) ? '1' : '2', c1
, c2
);
759 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
)) + 6
760 - (debug_name
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
762 if (DECL_VINDEX (decl
) && host_integerp (DECL_VINDEX (decl
), 0))
764 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
765 tree_low_cst (DECL_VINDEX (decl
), 0));
766 fputc (';', asmfile
);
767 dbxout_type (DECL_CONTEXT (decl
), 0, 0);
768 fprintf (asmfile
, ";");
773 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
777 dbxout_type_methods (type
)
780 /* C++: put out the method names and their parameter lists */
781 tree methods
= TYPE_METHODS (type
);
783 register tree fndecl
;
785 char formatted_type_identifier_length
[16];
786 register int type_identifier_length
;
788 if (methods
== NULL_TREE
)
791 type_encoding
= DECL_NAME (TYPE_NAME (type
));
794 /* C++: Template classes break some assumptions made by this code about
795 the class names, constructor names, and encodings for assembler
796 label names. For now, disable output of dbx info for them. */
798 const char *ptr
= IDENTIFIER_POINTER (type_encoding
);
799 /* This should use index. (mrs) */
800 while (*ptr
&& *ptr
!= '<') ptr
++;
811 type_identifier_length
= IDENTIFIER_LENGTH (type_encoding
);
813 sprintf(formatted_type_identifier_length
, "%d", type_identifier_length
);
815 if (TREE_CODE (methods
) != TREE_VEC
)
817 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
818 fndecl
= TREE_VEC_ELT (methods
, 0);
820 fndecl
= TREE_VEC_ELT (methods
, 1);
824 tree name
= DECL_NAME (fndecl
);
827 /* Group together all the methods for the same operation.
828 These differ in the types of the arguments. */
829 for (last
= NULL_TREE
;
830 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
831 fndecl
= TREE_CHAIN (fndecl
))
832 /* Output the name of the field (after overloading), as
833 well as the name of the field before overloading, along
834 with its parameter list */
836 /* This is the "mangled" name of the method.
837 It encodes the argument types. */
838 const char *debug_name
=
839 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
));
840 int show_arg_types
= 0;
846 if (DECL_IGNORED_P (fndecl
))
849 if (flag_minimal_debug
)
853 /* We can't optimize a method which uses an anonymous
854 class, because the debugger will not be able to
855 associate the arbitrary class name with the actual
857 #ifndef NO_DOLLAR_IN_LABEL
862 if (strchr (debug_name
, marker
))
864 /* Detect ordinary methods because their mangled names
865 start with the operation name. */
866 else if (!strncmp (IDENTIFIER_POINTER (name
), debug_name
,
867 IDENTIFIER_LENGTH (name
)))
869 debug_name
+= IDENTIFIER_LENGTH (name
);
870 if (debug_name
[0] == '_' && debug_name
[1] == '_')
872 const char *method_name
= debug_name
+ 2;
873 const char *length_ptr
=
874 formatted_type_identifier_length
;
875 /* Get past const and volatile qualifiers. */
876 while (*method_name
== 'C' || *method_name
== 'V')
878 /* Skip digits for length of type_encoding. */
879 while (*method_name
== *length_ptr
&& *length_ptr
)
880 length_ptr
++, method_name
++;
881 if (! strncmp (method_name
,
882 IDENTIFIER_POINTER (type_encoding
),
883 type_identifier_length
))
884 method_name
+= type_identifier_length
;
885 debug_name
= method_name
;
888 /* Detect constructors by their style of name mangling. */
889 else if (debug_name
[0] == '_' && debug_name
[1] == '_')
891 const char *ctor_name
= debug_name
+ 2;
892 const char *length_ptr
= formatted_type_identifier_length
;
893 while (*ctor_name
== 'C' || *ctor_name
== 'V')
895 /* Skip digits for length of type_encoding. */
896 while (*ctor_name
== *length_ptr
&& *length_ptr
)
897 length_ptr
++, ctor_name
++;
898 if (!strncmp (IDENTIFIER_POINTER (type_encoding
), ctor_name
,
899 type_identifier_length
))
900 debug_name
= ctor_name
+ type_identifier_length
;
902 /* The other alternative is a destructor. */
906 /* Output the operation name just once, for the first method
910 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (name
));
911 CHARS (IDENTIFIER_LENGTH (name
) + 2);
916 dbxout_type (TREE_TYPE (fndecl
), 0, show_arg_types
);
918 dbxout_type_method_1 (fndecl
, debug_name
);
928 /* Emit a "range" type specification, which has the form:
929 "r<index type>;<lower bound>;<upper bound>;".
930 TYPE is an INTEGER_TYPE. */
933 dbxout_range_type (type
)
936 fprintf (asmfile
, "r");
937 if (TREE_TYPE (type
))
938 dbxout_type (TREE_TYPE (type
), 0, 0);
939 else if (TREE_CODE (type
) != INTEGER_TYPE
)
940 dbxout_type (type
, 0, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
943 /* Traditionally, we made sure 'int' was type 1, and builtin types
944 were defined to be sub-ranges of int. Unfortunately, this
945 does not allow us to distinguish true sub-ranges from integer
946 types. So, instead we define integer (non-sub-range) types as
947 sub-ranges of themselves. This matters for Chill. If this isn't
948 a subrange type, then we want to define it in terms of itself.
949 However, in C, this may be an anonymous integer type, and we don't
950 want to emit debug info referring to it. Just calling
951 dbxout_type_index won't work anyways, because the type hasn't been
952 defined yet. We make this work for both cases by checked to see
953 whether this is a defined type, referring to it if it is, and using
955 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
956 dbxout_type_index (type
);
958 dbxout_type_index (integer_type_node
);
961 if (TYPE_MIN_VALUE (type
) != 0
962 && host_integerp (TYPE_MIN_VALUE (type
), 0))
964 fputc (';', asmfile
);
965 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
966 tree_low_cst (TYPE_MIN_VALUE (type
), 0));
969 fprintf (asmfile
, ";0");
971 if (TYPE_MAX_VALUE (type
) != 0
972 && host_integerp (TYPE_MAX_VALUE (type
), 0))
974 fputc (';', asmfile
);
975 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
976 tree_low_cst (TYPE_MAX_VALUE (type
), 0));
977 fputc (';', asmfile
);
980 fprintf (asmfile
, ";-1;");
983 /* Output a reference to a type. If the type has not yet been
984 described in the dbx output, output its definition now.
985 For a type already defined, just refer to its definition
986 using the type number.
988 If FULL is nonzero, and the type has been described only with
989 a forward-reference, output the definition now.
990 If FULL is zero in this case, just refer to the forward-reference
991 using the number previously allocated.
993 If SHOW_ARG_TYPES is nonzero, we output a description of the argument
994 types for a METHOD_TYPE. */
997 dbxout_type (type
, full
, show_arg_types
)
1003 static int anonymous_type_number
= 0;
1005 /* If there was an input error and we don't really have a type,
1006 avoid crashing and write something that is at least valid
1007 by assuming `int'. */
1008 if (type
== error_mark_node
)
1009 type
= integer_type_node
;
1012 /* Try to find the "main variant" with the same name but not const
1013 or volatile. (Since stabs does not distinguish const and volatile,
1014 there is no need to make them separate types. But types with
1015 different names are usefully distinguished.) */
1017 for (tem
= TYPE_MAIN_VARIANT (type
); tem
; tem
= TYPE_NEXT_VARIANT (tem
))
1018 if (!TYPE_READONLY (tem
) && !TYPE_VOLATILE (tem
)
1019 && TYPE_NAME (tem
) == TYPE_NAME (type
))
1024 if (TYPE_NAME (type
)
1025 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1026 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1030 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1032 /* Type has no dbx number assigned. Assign next available number. */
1033 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1035 /* Make sure type vector is long enough to record about this type. */
1037 if (next_type_number
== typevec_len
)
1040 = (struct typeinfo
*) xrealloc (typevec
,
1041 typevec_len
* 2 * sizeof typevec
[0]);
1042 bzero ((char *) (typevec
+ typevec_len
),
1043 typevec_len
* sizeof typevec
[0]);
1047 #ifdef DBX_USE_BINCL
1048 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1049 = current_file
->file_number
;
1050 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1051 = current_file
->next_type_number
++;
1055 /* Output the number of this type, to refer to it. */
1056 dbxout_type_index (type
);
1058 #ifdef DBX_TYPE_DEFINED
1059 if (DBX_TYPE_DEFINED (type
))
1063 /* If this type's definition has been output or is now being output,
1066 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1071 /* If we have already had a cross reference,
1072 and either that's all we want or that's the best we could do,
1073 don't repeat the cross reference.
1074 Sun dbx crashes if we do. */
1075 if (! full
|| !COMPLETE_TYPE_P (type
)
1076 /* No way in DBX fmt to describe a variable size. */
1077 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1085 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1086 leave the type-number completely undefined rather than output
1087 a cross-reference. If we have already used GNU debug info extensions,
1088 then it is OK to output a cross reference. This is necessary to get
1089 proper C++ debug output. */
1090 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1091 || TREE_CODE (type
) == QUAL_UNION_TYPE
1092 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1093 && ! use_gnu_debug_info_extensions
)
1094 /* We must use the same test here as we use twice below when deciding
1095 whether to emit a cross-reference. */
1096 if ((TYPE_NAME (type
) != 0
1097 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1098 && DECL_IGNORED_P (TYPE_NAME (type
)))
1100 || !COMPLETE_TYPE_P (type
)
1101 /* No way in DBX fmt to describe a variable size. */
1102 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1104 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1109 /* Output a definition now. */
1111 fprintf (asmfile
, "=");
1114 /* Mark it as defined, so that if it is self-referent
1115 we will not get into an infinite recursion of definitions. */
1117 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1119 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1120 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1122 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0, 0);
1126 switch (TREE_CODE (type
))
1130 /* For a void type, just define it as itself; ie, "5=5".
1131 This makes us consider it defined
1132 without saying what it is. The debugger will make it
1133 a void type when the reference is seen, and nothing will
1134 ever override that default. */
1135 dbxout_type_index (type
);
1139 if (type
== char_type_node
&& ! TREE_UNSIGNED (type
))
1141 /* Output the type `char' as a subrange of itself!
1142 I don't understand this definition, just copied it
1143 from the output of pcc.
1144 This used to use `r2' explicitly and we used to
1145 take care to make sure that `char' was type number 2. */
1146 fprintf (asmfile
, "r");
1147 dbxout_type_index (type
);
1148 fprintf (asmfile
, ";0;127;");
1151 /* If this is a subtype of another integer type, always prefer to
1152 write it as a subtype. */
1153 else if (TREE_TYPE (type
) != 0
1154 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_CST
)
1155 dbxout_range_type (type
);
1159 /* If the size is non-standard, say what it is if we can use
1162 if (use_gnu_debug_info_extensions
1163 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1164 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1166 /* If we can use GDB extensions and the size is wider than a
1167 long (the size used by GDB to read them) or we may have
1168 trouble writing the bounds the usual way, write them in
1169 octal. Note the test is for the *target's* size of "long",
1170 not that of the host. The host test is just to make sure we
1171 can write it out in case the host wide int is narrower than the
1174 /* For unsigned types, we use octal if they are the same size or
1175 larger. This is because we print the bounds as signed decimal,
1176 and hence they can't span same size unsigned types. */
1178 if (use_gnu_debug_info_extensions
1179 && TYPE_MIN_VALUE (type
) != 0
1180 && TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
1181 && TYPE_MAX_VALUE (type
) != 0
1182 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
1183 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
1184 || (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
)
1185 && TREE_UNSIGNED (type
))
1186 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
1187 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
1188 && TREE_UNSIGNED (type
))))
1190 fprintf (asmfile
, "r");
1191 dbxout_type_index (type
);
1192 fprintf (asmfile
, ";");
1193 print_int_cst_octal (TYPE_MIN_VALUE (type
));
1194 fprintf (asmfile
, ";");
1195 print_int_cst_octal (TYPE_MAX_VALUE (type
));
1196 fprintf (asmfile
, ";");
1200 /* Output other integer types as subranges of `int'. */
1201 dbxout_range_type (type
);
1208 /* This used to say `r1' and we used to take care
1209 to make sure that `int' was type number 1. */
1210 fprintf (asmfile
, "r");
1211 dbxout_type_index (integer_type_node
);
1212 fputc (';', asmfile
);
1213 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1214 fputs (";0;", asmfile
);
1219 if (use_gnu_debug_info_extensions
)
1221 fputs ("@s", asmfile
);
1222 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1223 BITS_PER_UNIT
* int_size_in_bytes (type
));
1224 fputs (";-20;", asmfile
);
1228 /* Output the type `char' as a subrange of itself.
1229 That is what pcc seems to do. */
1230 fprintf (asmfile
, "r");
1231 dbxout_type_index (char_type_node
);
1232 fprintf (asmfile
, ";0;%d;", TREE_UNSIGNED (type
) ? 255 : 127);
1238 if (use_gnu_debug_info_extensions
)
1240 fputs ("@s", asmfile
);
1241 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1242 BITS_PER_UNIT
* int_size_in_bytes (type
));
1243 fputs (";-16;", asmfile
);
1245 else /* Define as enumeral type (False, True) */
1246 fprintf (asmfile
, "eFalse:0,True:1,;");
1251 putc ('d', asmfile
);
1253 dbxout_type (TREE_TYPE (type
), 0, 0);
1257 /* Differs from the REAL_TYPE by its new data type number */
1259 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1261 fprintf (asmfile
, "r");
1262 dbxout_type_index (type
);
1263 fputc (';', asmfile
);
1264 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1265 int_size_in_bytes (TREE_TYPE (type
)));
1266 fputs (";0;", asmfile
);
1267 CHARS (12); /* The number is probably incorrect here. */
1271 /* Output a complex integer type as a structure,
1272 pending some other way to do it. */
1273 fputc ('s', asmfile
);
1274 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1276 fprintf (asmfile
, "real:");
1278 dbxout_type (TREE_TYPE (type
), 0, 0);
1279 fprintf (asmfile
, ",%d,%d;",
1280 0, TYPE_PRECISION (TREE_TYPE (type
)));
1282 fprintf (asmfile
, "imag:");
1284 dbxout_type (TREE_TYPE (type
), 0, 0);
1285 fprintf (asmfile
, ",%d,%d;;",
1286 TYPE_PRECISION (TREE_TYPE (type
)),
1287 TYPE_PRECISION (TREE_TYPE (type
)));
1293 if (use_gnu_debug_info_extensions
)
1295 have_used_extensions
= 1;
1296 fputs ("@s", asmfile
);
1297 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1298 BITS_PER_UNIT
* int_size_in_bytes (type
));
1299 fputc (';', asmfile
);
1300 /* Check if a bitstring type, which in Chill is
1301 different from a [power]set. */
1302 if (TYPE_STRING_FLAG (type
))
1303 fprintf (asmfile
, "@S;");
1305 putc ('S', asmfile
);
1307 dbxout_type (TYPE_DOMAIN (type
), 0, 0);
1311 /* Make arrays of packed bits look like bitstrings for chill. */
1312 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
1314 have_used_extensions
= 1;
1315 fputs ("@s", asmfile
);
1316 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1317 BITS_PER_UNIT
* int_size_in_bytes (type
));
1318 fputc (';', asmfile
);
1319 fprintf (asmfile
, "@S;");
1320 putc ('S', asmfile
);
1322 dbxout_type (TYPE_DOMAIN (type
), 0, 0);
1325 /* Output "a" followed by a range type definition
1326 for the index type of the array
1327 followed by a reference to the target-type.
1328 ar1;0;N;M for a C array of type M and size N+1. */
1329 /* Check if a character string type, which in Chill is
1330 different from an array of characters. */
1331 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
1333 have_used_extensions
= 1;
1334 fprintf (asmfile
, "@S;");
1336 tem
= TYPE_DOMAIN (type
);
1339 fprintf (asmfile
, "ar");
1340 dbxout_type_index (integer_type_node
);
1341 fprintf (asmfile
, ";0;-1;");
1345 fprintf (asmfile
, "a");
1346 dbxout_range_type (tem
);
1349 dbxout_type (TREE_TYPE (type
), 0, 0);
1354 case QUAL_UNION_TYPE
:
1356 int i
, n_baseclasses
= 0;
1358 if (TYPE_BINFO (type
) != 0
1359 && TREE_CODE (TYPE_BINFO (type
)) == TREE_VEC
1360 && TYPE_BINFO_BASETYPES (type
) != 0)
1361 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
1363 /* Output a structure type. We must use the same test here as we
1364 use in the DBX_NO_XREFS case above. */
1365 if ((TYPE_NAME (type
) != 0
1366 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1367 && DECL_IGNORED_P (TYPE_NAME (type
)))
1369 || !COMPLETE_TYPE_P (type
)
1370 /* No way in DBX fmt to describe a variable size. */
1371 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1373 /* If the type is just a cross reference, output one
1374 and mark the type as partially described.
1375 If it later becomes defined, we will output
1376 its real definition.
1377 If the type has a name, don't nest its definition within
1378 another type's definition; instead, output an xref
1379 and let the definition come when the name is defined. */
1380 fputs ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu", asmfile
);
1382 #if 0 /* This assertion is legitimately false in C++. */
1383 /* We shouldn't be outputting a reference to a type before its
1384 definition unless the type has a tag name.
1385 A typedef name without a tag name should be impossible. */
1386 if (TREE_CODE (TYPE_NAME (type
)) != IDENTIFIER_NODE
)
1389 if (TYPE_NAME (type
) != 0)
1390 dbxout_type_name (type
);
1392 fprintf (asmfile
, "$$%d", anonymous_type_number
++);
1393 fprintf (asmfile
, ":");
1394 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1398 /* Identify record or union, and print its size. */
1399 fputc (((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u'), asmfile
);
1400 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1401 int_size_in_bytes (type
));
1403 if (use_gnu_debug_info_extensions
)
1407 have_used_extensions
= 1;
1408 fprintf (asmfile
, "!%d,", n_baseclasses
);
1412 for (i
= 0; i
< n_baseclasses
; i
++)
1414 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)), i
);
1416 if (use_gnu_debug_info_extensions
)
1418 have_used_extensions
= 1;
1419 putc (TREE_VIA_VIRTUAL (child
) ? '1' : '0', asmfile
);
1420 putc (TREE_VIA_PUBLIC (child
) ? '2' : '0', asmfile
);
1421 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1422 (tree_low_cst (BINFO_OFFSET (child
), 0)
1424 fputc (',', asmfile
);
1426 dbxout_type (BINFO_TYPE (child
), 0, 0);
1427 putc (';', asmfile
);
1431 /* Print out the base class information with fields
1432 which have the same names at the types they hold. */
1433 dbxout_type_name (BINFO_TYPE (child
));
1434 putc (':', asmfile
);
1435 dbxout_type (BINFO_TYPE (child
), full
, 0);
1436 fputc (',', asmfile
);
1437 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1438 tree_low_cst (BINFO_OFFSET (child
), 0)
1440 fputc (',', asmfile
);
1441 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1442 (tree_low_cst (DECL_SIZE (TYPE_NAME
1443 (BINFO_TYPE (child
))), 0)
1445 fputc (';', asmfile
);
1453 /* Write out the field declarations. */
1454 dbxout_type_fields (type
);
1455 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1457 have_used_extensions
= 1;
1458 dbxout_type_methods (type
);
1461 putc (';', asmfile
);
1463 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1464 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1465 && TYPE_VFIELD (type
))
1467 have_used_extensions
= 1;
1469 /* Tell GDB+ that it may keep reading. */
1470 putc ('~', asmfile
);
1472 /* We need to write out info about what field this class
1473 uses as its "main" vtable pointer field, because if this
1474 field is inherited from a base class, GDB cannot necessarily
1475 figure out which field it's using in time. */
1476 if (TYPE_VFIELD (type
))
1478 putc ('%', asmfile
);
1479 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0, 0);
1481 putc (';', asmfile
);
1487 /* We must use the same test here as we use in the DBX_NO_XREFS case
1488 above. We simplify it a bit since an enum will never have a variable
1490 if ((TYPE_NAME (type
) != 0
1491 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1492 && DECL_IGNORED_P (TYPE_NAME (type
)))
1494 || !COMPLETE_TYPE_P (type
))
1496 fprintf (asmfile
, "xe");
1498 dbxout_type_name (type
);
1499 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1500 fprintf (asmfile
, ":");
1503 #ifdef DBX_OUTPUT_ENUM
1504 DBX_OUTPUT_ENUM (asmfile
, type
);
1506 if (use_gnu_debug_info_extensions
1507 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1508 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1509 putc ('e', asmfile
);
1511 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1513 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)));
1514 if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == 0)
1515 fprintf (asmfile
, HOST_WIDE_INT_PRINT_UNSIGNED
,
1516 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1517 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == -1
1518 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (TREE_VALUE (tem
)) < 0)
1519 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1520 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1522 print_int_cst_octal (TREE_VALUE (tem
));
1523 fprintf (asmfile
, ",");
1524 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)));
1525 if (TREE_CHAIN (tem
) != 0)
1530 putc (';', asmfile
);
1536 putc ('*', asmfile
);
1538 dbxout_type (TREE_TYPE (type
), 0, 0);
1542 if (use_gnu_debug_info_extensions
)
1544 have_used_extensions
= 1;
1545 putc ('#', asmfile
);
1547 if (flag_minimal_debug
&& !show_arg_types
)
1549 /* Normally, just output the return type.
1550 The argument types are encoded in the method name. */
1551 putc ('#', asmfile
);
1553 dbxout_type (TREE_TYPE (type
), 0, 0);
1554 putc (';', asmfile
);
1559 /* When outputting destructors, we need to write
1560 the argument types out longhand. */
1561 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0, 0);
1562 putc (',', asmfile
);
1564 dbxout_type (TREE_TYPE (type
), 0, 0);
1565 dbxout_args (TYPE_ARG_TYPES (type
));
1566 putc (';', asmfile
);
1572 /* Treat it as a function type. */
1573 dbxout_type (TREE_TYPE (type
), 0, 0);
1578 if (use_gnu_debug_info_extensions
)
1580 have_used_extensions
= 1;
1581 putc ('@', asmfile
);
1583 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0, 0);
1584 putc (',', asmfile
);
1586 dbxout_type (TREE_TYPE (type
), 0, 0);
1590 /* Should print as an int, because it is really
1592 dbxout_type (integer_type_node
, 0, 0);
1596 case REFERENCE_TYPE
:
1597 if (use_gnu_debug_info_extensions
)
1598 have_used_extensions
= 1;
1599 putc (use_gnu_debug_info_extensions
? '&' : '*', asmfile
);
1601 dbxout_type (TREE_TYPE (type
), 0, 0);
1605 putc ('f', asmfile
);
1607 dbxout_type (TREE_TYPE (type
), 0, 0);
1615 /* Print the value of integer constant C, in octal,
1616 handling double precision. */
1619 print_int_cst_octal (c
)
1622 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (c
);
1623 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (c
);
1624 int excess
= (3 - (HOST_BITS_PER_WIDE_INT
% 3));
1625 unsigned int width
= TYPE_PRECISION (TREE_TYPE (c
));
1627 /* GDB wants constants with no extra leading "1" bits, so
1628 we need to remove any sign-extension that might be
1630 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
1632 else if (width
> HOST_BITS_PER_WIDE_INT
)
1633 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
1634 else if (width
== HOST_BITS_PER_WIDE_INT
)
1637 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
1639 fprintf (asmfile
, "0");
1643 print_octal (high
, HOST_BITS_PER_WIDE_INT
/ 3);
1644 print_octal (low
, HOST_BITS_PER_WIDE_INT
/ 3);
1648 unsigned HOST_WIDE_INT beg
= high
>> excess
;
1649 unsigned HOST_WIDE_INT middle
1650 = ((high
& (((HOST_WIDE_INT
) 1 << excess
) - 1)) << (3 - excess
)
1651 | (low
>> (HOST_BITS_PER_WIDE_INT
/ 3 * 3)));
1652 unsigned HOST_WIDE_INT end
1653 = low
& (((unsigned HOST_WIDE_INT
) 1
1654 << (HOST_BITS_PER_WIDE_INT
/ 3 * 3))
1657 fprintf (asmfile
, "%o%01o", (int) beg
, (int) middle
);
1658 print_octal (end
, HOST_BITS_PER_WIDE_INT
/ 3);
1663 print_octal (value
, digits
)
1664 unsigned HOST_WIDE_INT value
;
1669 for (i
= digits
- 1; i
>= 0; i
--)
1670 fprintf (asmfile
, "%01o", (int) ((value
>> (3 * i
)) & 7));
1673 /* Output the name of type TYPE, with no punctuation.
1674 Such names can be set up either by typedef declarations
1675 or by struct, enum and union tags. */
1678 dbxout_type_name (type
)
1682 if (TYPE_NAME (type
) == 0)
1684 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
1686 t
= TYPE_NAME (type
);
1688 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1690 t
= DECL_NAME (TYPE_NAME (type
));
1695 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
1696 CHARS (IDENTIFIER_LENGTH (t
));
1699 /* Output a .stabs for the symbol defined by DECL,
1700 which must be a ..._DECL node in the normal namespace.
1701 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1702 LOCAL is nonzero if the scope is less than the entire file.
1703 Return 1 if a stabs might have been emitted. */
1706 dbxout_symbol (decl
, local
)
1708 int local ATTRIBUTE_UNUSED
;
1710 tree type
= TREE_TYPE (decl
);
1711 tree context
= NULL_TREE
;
1714 /* Cast avoids warning in old compilers. */
1715 current_sym_code
= (STAB_CODE_TYPE
) 0;
1716 current_sym_value
= 0;
1717 current_sym_addr
= 0;
1719 /* Ignore nameless syms, but don't ignore type tags. */
1721 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
1722 || DECL_IGNORED_P (decl
))
1725 dbxout_prepare_symbol (decl
);
1727 /* The output will always start with the symbol name,
1728 so always count that in the length-output-so-far. */
1730 if (DECL_NAME (decl
) != 0)
1731 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
1733 switch (TREE_CODE (decl
))
1736 /* Enum values are defined by defining the enum type. */
1740 if (DECL_RTL (decl
) == 0)
1742 if (DECL_EXTERNAL (decl
))
1744 /* Don't mention a nested function under its parent. */
1745 context
= decl_function_context (decl
);
1746 if (context
== current_function_decl
)
1748 if (GET_CODE (DECL_RTL (decl
)) != MEM
1749 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
1753 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
1754 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1755 TREE_PUBLIC (decl
) ? 'F' : 'f');
1758 current_sym_code
= N_FUN
;
1759 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1761 if (TREE_TYPE (type
))
1762 dbxout_type (TREE_TYPE (type
), 0, 0);
1764 dbxout_type (void_type_node
, 0, 0);
1766 /* For a nested function, when that function is compiled,
1767 mention the containing function name
1768 as well as (since dbx wants it) our own assembler-name. */
1770 fprintf (asmfile
, ",%s,%s",
1771 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1772 IDENTIFIER_POINTER (DECL_NAME (context
)));
1774 dbxout_finish_symbol (decl
);
1779 /* This seems all wrong. Outputting most kinds of types gives no name
1780 at all. A true definition gives no name; a cross-ref for a
1781 structure can give the tag name, but not a type name.
1782 It seems that no typedef name is defined by outputting a type. */
1784 /* If this typedef name was defined by outputting the type,
1785 don't duplicate it. */
1786 if (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
== TYPE_DEFINED
1787 && TYPE_NAME (TREE_TYPE (decl
)) == decl
)
1790 /* Don't output the same typedef twice.
1791 And don't output what language-specific stuff doesn't want output. */
1792 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
1801 if (DECL_NAME (decl
))
1803 /* Nonzero means we must output a tag as well as a typedef. */
1806 /* Handle the case of a C++ structure or union
1807 where the TYPE_NAME is a TYPE_DECL
1808 which gives both a typedef name and a tag. */
1809 /* dbx requires the tag first and the typedef second. */
1810 if ((TREE_CODE (type
) == RECORD_TYPE
1811 || TREE_CODE (type
) == UNION_TYPE
1812 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1813 && TYPE_NAME (type
) == decl
1814 && !(use_gnu_debug_info_extensions
&& have_used_extensions
)
1815 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
1816 /* Distinguish the implicit typedefs of C++
1817 from explicit ones that might be found in C. */
1818 && DECL_ARTIFICIAL (decl
))
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 (TYPE_SIZE is
1868 zero). This prevents 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_FIELD_CONTEXT (decl
) == NULL_TREE
1941 || TREE_CODE (DECL_FIELD_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 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
)
2019 offset
+= SUBREG_WORD (value
);
2020 value
= SUBREG_REG (value
);
2022 if (GET_CODE (value
) == REG
)
2024 regno
= REGNO (value
);
2025 if (regno
>= FIRST_PSEUDO_REGISTER
)
2029 alter_subreg (home
);
2032 /* The kind-of-variable letter depends on where
2033 the variable is and on the scope of its name:
2034 G and N_GSYM for static storage and global scope,
2035 S for static storage and file scope,
2036 V for static storage and local scope,
2037 for those two, use N_LCSYM if data is in bss segment,
2038 N_STSYM if in data segment, N_FUN otherwise.
2039 (We used N_FUN originally, then changed to N_STSYM
2040 to please GDB. However, it seems that confused ld.
2041 Now GDB has been fixed to like N_FUN, says Kingdon.)
2042 no letter at all, and N_LSYM, for auto variable,
2043 r and N_RSYM for register variable. */
2045 if (GET_CODE (home
) == MEM
2046 && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2048 if (TREE_PUBLIC (decl
))
2051 current_sym_code
= N_GSYM
;
2055 current_sym_addr
= XEXP (home
, 0);
2057 letter
= decl_function_context (decl
) ? 'V' : 'S';
2059 /* This should be the same condition as in assemble_variable, but
2060 we don't have access to dont_output_data here. So, instead,
2061 we rely on the fact that error_mark_node initializers always
2062 end up in bss for C++ and never end up in bss for C. */
2063 if (DECL_INITIAL (decl
) == 0
2064 || (!strcmp (lang_identify (), "cplusplus")
2065 && DECL_INITIAL (decl
) == error_mark_node
))
2066 current_sym_code
= N_LCSYM
;
2067 else if (DECL_IN_TEXT_SECTION (decl
))
2068 /* This is not quite right, but it's the closest
2069 of all the codes that Unix defines. */
2070 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
2073 /* Ultrix `as' seems to need this. */
2074 #ifdef DBX_STATIC_STAB_DATA_SECTION
2077 current_sym_code
= N_STSYM
;
2081 else if (regno
>= 0)
2084 current_sym_code
= N_RSYM
;
2085 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
2087 else if (GET_CODE (home
) == MEM
2088 && (GET_CODE (XEXP (home
, 0)) == MEM
2089 || (GET_CODE (XEXP (home
, 0)) == REG
2090 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
2091 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
2092 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2093 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
2096 /* If the value is indirect by memory or by a register
2097 that isn't the frame pointer
2098 then it means the object is variable-sized and address through
2099 that register or stack slot. DBX has no way to represent this
2100 so all we can do is output the variable as a pointer.
2101 If it's not a parameter, ignore it.
2102 (VAR_DECLs like this can be made by integrate.c.) */
2104 if (GET_CODE (XEXP (home
, 0)) == REG
)
2107 current_sym_code
= N_RSYM
;
2108 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
2112 current_sym_code
= N_LSYM
;
2113 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2114 We want the value of that CONST_INT. */
2116 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
2119 /* Effectively do build_pointer_type, but don't cache this type,
2120 since it might be temporary whereas the type it points to
2121 might have been saved for inlining. */
2122 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2123 type
= make_node (POINTER_TYPE
);
2124 TREE_TYPE (type
) = TREE_TYPE (decl
);
2126 else if (GET_CODE (home
) == MEM
2127 && GET_CODE (XEXP (home
, 0)) == REG
)
2129 current_sym_code
= N_LSYM
;
2130 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2132 else if (GET_CODE (home
) == MEM
2133 && GET_CODE (XEXP (home
, 0)) == PLUS
2134 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
2136 current_sym_code
= N_LSYM
;
2137 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2138 We want the value of that CONST_INT. */
2139 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2141 else if (GET_CODE (home
) == MEM
2142 && GET_CODE (XEXP (home
, 0)) == CONST
)
2144 /* Handle an obscure case which can arise when optimizing and
2145 when there are few available registers. (This is *always*
2146 the case for i386/i486 targets). The RTL looks like
2147 (MEM (CONST ...)) even though this variable is a local `auto'
2148 or a local `register' variable. In effect, what has happened
2149 is that the reload pass has seen that all assignments and
2150 references for one such a local variable can be replaced by
2151 equivalent assignments and references to some static storage
2152 variable, thereby avoiding the need for a register. In such
2153 cases we're forced to lie to debuggers and tell them that
2154 this variable was itself `static'. */
2155 current_sym_code
= N_LCSYM
;
2157 current_sym_addr
= XEXP (XEXP (home
, 0), 0);
2159 else if (GET_CODE (home
) == CONCAT
)
2161 tree subtype
= TREE_TYPE (type
);
2163 /* If the variable's storage is in two parts,
2164 output each as a separate stab with a modified name. */
2165 if (WORDS_BIG_ENDIAN
)
2166 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
2168 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
2170 /* Cast avoids warning in old compilers. */
2171 current_sym_code
= (STAB_CODE_TYPE
) 0;
2172 current_sym_value
= 0;
2173 current_sym_addr
= 0;
2174 dbxout_prepare_symbol (decl
);
2176 if (WORDS_BIG_ENDIAN
)
2177 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
2179 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
2183 /* Address might be a MEM, when DECL is a variable-sized object.
2184 Or it might be const0_rtx, meaning previous passes
2185 want us to ignore this variable. */
2188 /* Ok, start a symtab entry and output the variable name. */
2191 #ifdef DBX_STATIC_BLOCK_START
2192 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
2195 dbxout_symbol_name (decl
, suffix
, letter
);
2196 dbxout_type (type
, 0, 0);
2197 dbxout_finish_symbol (decl
);
2199 #ifdef DBX_STATIC_BLOCK_END
2200 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
2205 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2206 Then output LETTER to indicate the kind of location the symbol has. */
2209 dbxout_symbol_name (decl
, suffix
, letter
)
2214 /* One slight hitch: if this is a VAR_DECL which is a static
2215 class member, we must put out the mangled name instead of the
2216 DECL_NAME. Note also that static member (variable) names DO NOT begin
2217 with underscores in .stabs directives. */
2218 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2221 fprintf (asmfile
, "%s \"%s%s:", ASM_STABS_OP
, name
,
2222 (suffix
? suffix
: ""));
2224 if (letter
) putc (letter
, asmfile
);
2228 dbxout_prepare_symbol (decl
)
2229 tree decl ATTRIBUTE_UNUSED
;
2232 const char *filename
= DECL_SOURCE_FILE (decl
);
2234 dbxout_source_file (asmfile
, filename
);
2239 dbxout_finish_symbol (sym
)
2242 #ifdef DBX_FINISH_SYMBOL
2243 DBX_FINISH_SYMBOL (sym
);
2246 if (use_gnu_debug_info_extensions
&& sym
!= 0)
2247 line
= DECL_SOURCE_LINE (sym
);
2249 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
2250 if (current_sym_addr
)
2251 output_addr_const (asmfile
, current_sym_addr
);
2253 fprintf (asmfile
, "%d", current_sym_value
);
2254 putc ('\n', asmfile
);
2258 /* Output definitions of all the decls in a chain. Return non-zero if
2259 anything was output */
2268 result
+= dbxout_symbol (syms
, 1);
2269 syms
= TREE_CHAIN (syms
);
2274 /* The following two functions output definitions of function parameters.
2275 Each parameter gets a definition locating it in the parameter list.
2276 Each parameter that is a register variable gets a second definition
2277 locating it in the register.
2279 Printing or argument lists in gdb uses the definitions that
2280 locate in the parameter list. But reference to the variable in
2281 expressions uses preferentially the definition as a register. */
2283 /* Output definitions, referring to storage in the parmlist,
2284 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2287 dbxout_parms (parms
)
2290 for (; parms
; parms
= TREE_CHAIN (parms
))
2291 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
2293 dbxout_prepare_symbol (parms
);
2295 /* Perform any necessary register eliminations on the parameter's rtl,
2296 so that the debugging output will be accurate. */
2297 DECL_INCOMING_RTL (parms
)
2298 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
2299 DECL_RTL (parms
) = eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
);
2300 #ifdef LEAF_REG_REMAP
2301 if (current_function_uses_only_leaf_regs
)
2303 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
2304 leaf_renumber_regs_insn (DECL_RTL (parms
));
2308 if (PARM_PASSED_IN_MEMORY (parms
))
2310 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
2312 /* ??? Here we assume that the parm address is indexed
2313 off the frame pointer or arg pointer.
2314 If that is not true, we produce meaningless results,
2315 but do not crash. */
2316 if (GET_CODE (addr
) == PLUS
2317 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
2318 current_sym_value
= INTVAL (XEXP (addr
, 1));
2320 current_sym_value
= 0;
2322 current_sym_code
= N_PSYM
;
2323 current_sym_addr
= 0;
2326 if (DECL_NAME (parms
))
2328 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2330 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2331 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2332 DBX_MEMPARM_STABS_LETTER
);
2336 current_sym_nchars
= 8;
2337 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2338 DBX_MEMPARM_STABS_LETTER
);
2341 /* It is quite tempting to use:
2343 dbxout_type (TREE_TYPE (parms), 0, 0);
2345 as the next statement, rather than using DECL_ARG_TYPE(), so
2346 that gcc reports the actual type of the parameter, rather
2347 than the promoted type. This certainly makes GDB's life
2348 easier, at least for some ports. The change is a bad idea
2349 however, since GDB expects to be able access the type without
2350 performing any conversions. So for example, if we were
2351 passing a float to an unprototyped function, gcc will store a
2352 double on the stack, but if we emit a stab saying the type is a
2353 float, then gdb will only read in a single value, and this will
2354 produce an erropneous value. */
2355 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
2356 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
2357 dbxout_finish_symbol (parms
);
2359 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
2362 char regparm_letter
;
2364 /* Parm passed in registers and lives in registers or nowhere. */
2366 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2367 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2368 current_sym_addr
= 0;
2370 /* If parm lives in a register, use that register;
2371 pretend the parm was passed there. It would be more consistent
2372 to describe the register where the parm was passed,
2373 but in practice that register usually holds something else.
2375 If we use DECL_RTL, then we must use the declared type of
2376 the variable, not the type that it arrived in. */
2377 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2379 best_rtl
= DECL_RTL (parms
);
2380 parm_type
= TREE_TYPE (parms
);
2382 /* If the parm lives nowhere, use the register where it was
2383 passed. It is also better to use the declared type here. */
2386 best_rtl
= DECL_INCOMING_RTL (parms
);
2387 parm_type
= TREE_TYPE (parms
);
2389 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
2392 if (DECL_NAME (parms
))
2394 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2395 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2396 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2401 current_sym_nchars
= 8;
2402 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2406 dbxout_type (parm_type
, 0, 0);
2407 dbxout_finish_symbol (parms
);
2409 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2410 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
2411 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
2412 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
2413 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2414 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
2418 /* Parm was passed via invisible reference.
2419 That is, its address was passed in a register.
2420 Output it as if it lived in that register.
2421 The debugger will know from the type
2422 that it was actually passed by invisible reference. */
2424 char regparm_letter
;
2425 /* Parm passed in registers and lives in registers or nowhere. */
2427 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2428 if (use_gnu_debug_info_extensions
)
2429 regparm_letter
= GDB_INV_REF_REGPARM_STABS_LETTER
;
2431 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2433 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2434 If it is an unallocated pseudo-reg, then use the register where
2435 it was passed instead. */
2436 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
2437 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
2439 current_sym_value
= REGNO (DECL_INCOMING_RTL (parms
));
2441 current_sym_addr
= 0;
2444 if (DECL_NAME (parms
))
2446 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2448 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2449 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2454 current_sym_nchars
= 8;
2455 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2459 dbxout_type (TREE_TYPE (parms
), 0, 0);
2460 dbxout_finish_symbol (parms
);
2462 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2463 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
2464 /* ??? A constant address for a parm can happen
2465 when the reg it lives in is equiv to a constant in memory.
2466 Should make this not happen, after 2.4. */
2467 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
2469 /* Parm was passed in registers but lives on the stack. */
2470 int aux_sym_value
= 0;
2472 current_sym_code
= N_PSYM
;
2473 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2474 in which case we want the value of that CONST_INT,
2475 or (MEM (REG ...)) or (MEM (MEM ...)),
2476 in which case we use a value of zero. */
2477 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
)
2478 current_sym_value
= 0;
2479 else if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
2481 /* Remember the location on the stack the parm is moved to */
2483 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
2484 current_sym_value
= 0;
2488 = INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
2490 current_sym_addr
= 0;
2492 /* Make a big endian correction if the mode of the type of the
2493 parameter is not the same as the mode of the rtl. */
2494 if (BYTES_BIG_ENDIAN
2495 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
2496 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
2498 current_sym_value
+=
2499 GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
2500 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
)));
2504 if (DECL_NAME (parms
))
2507 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2509 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2510 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2511 DBX_MEMPARM_STABS_LETTER
);
2515 current_sym_nchars
= 8;
2516 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2517 DBX_MEMPARM_STABS_LETTER
);
2521 = DEBUGGER_ARG_OFFSET (current_sym_value
,
2522 XEXP (DECL_RTL (parms
), 0));
2523 dbxout_type (TREE_TYPE (parms
), 0, 0);
2524 dbxout_finish_symbol (parms
);
2525 if (aux_sym_value
!= 0)
2527 /* Generate an entry for the stack location */
2529 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
,
2530 IDENTIFIER_POINTER (DECL_NAME (parms
)));
2531 current_sym_value
= aux_sym_value
;
2532 current_sym_code
= N_LSYM
;
2533 dbxout_type (build_reference_type (TREE_TYPE (parms
)), 0, 0);
2534 dbxout_finish_symbol (parms
);
2540 /* Output definitions for the places where parms live during the function,
2541 when different from where they were passed, when the parms were passed
2544 It is not useful to do this for parms passed in registers
2545 that live during the function in different registers, because it is
2546 impossible to look in the passed register for the passed value,
2547 so we use the within-the-function register to begin with.
2549 PARMS is a chain of PARM_DECL nodes. */
2552 dbxout_reg_parms (parms
)
2555 for (; parms
; parms
= TREE_CHAIN (parms
))
2556 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
2558 dbxout_prepare_symbol (parms
);
2560 /* Report parms that live in registers during the function
2561 but were passed in memory. */
2562 if (GET_CODE (DECL_RTL (parms
)) == REG
2563 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2564 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2565 0, DECL_RTL (parms
));
2566 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
2567 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2568 0, DECL_RTL (parms
));
2569 /* Report parms that live in memory but not where they were passed. */
2570 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2571 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
2572 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2573 0, DECL_RTL (parms
));
2577 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2578 output definitions of those names, in raw form */
2586 putc (',', asmfile
);
2587 dbxout_type (TREE_VALUE (args
), 0, 0);
2589 args
= TREE_CHAIN (args
);
2593 /* Given a chain of ..._TYPE nodes,
2594 find those which have typedef names and output those names.
2595 This is to ensure those types get output. */
2598 dbxout_types (types
)
2599 register tree types
;
2603 if (TYPE_NAME (types
)
2604 && TREE_CODE (TYPE_NAME (types
)) == TYPE_DECL
2605 && ! TREE_ASM_WRITTEN (TYPE_NAME (types
)))
2606 dbxout_symbol (TYPE_NAME (types
), 1);
2607 types
= TREE_CHAIN (types
);
2611 /* Output everything about a symbol block (a BLOCK node
2612 that represents a scope level),
2613 including recursive output of contained blocks.
2615 BLOCK is the BLOCK node.
2616 DEPTH is its depth within containing symbol blocks.
2617 ARGS is usually zero; but for the outermost block of the
2618 body of a function, it is a chain of PARM_DECLs for the function parameters.
2619 We output definitions of all the register parms
2620 as if they were local variables of that block.
2622 If -g1 was used, we count blocks just the same, but output nothing
2623 except for the outermost block.
2625 Actually, BLOCK may be several blocks chained together.
2626 We handle them all in sequence. */
2629 dbxout_block (block
, depth
, args
)
2630 register tree block
;
2637 #if DBX_BLOCKS_FUNCTION_RELATIVE
2638 const char *begin_label
;
2639 if (current_function_func_begin_label
!= NULL_TREE
)
2640 begin_label
= IDENTIFIER_POINTER (current_function_func_begin_label
);
2642 begin_label
= XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0);
2647 /* Ignore blocks never expanded or otherwise marked as real. */
2648 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
2650 #ifndef DBX_LBRAC_FIRST
2651 /* In dbx format, the syms of a block come before the N_LBRAC.
2652 If nothing is output, we don't need the N_LBRAC, either. */
2654 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2655 ignored
= dbxout_syms (BLOCK_VARS (block
));
2657 dbxout_reg_parms (args
);
2660 /* Now output an N_LBRAC symbol to represent the beginning of
2661 the block. Use the block's tree-walk order to generate
2662 the assembler symbols LBBn and LBEn
2663 that final will define around the code in this block. */
2664 if (depth
> 0 && !ignored
)
2667 blocknum
= BLOCK_NUMBER (block
);
2668 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
2670 if (BLOCK_HANDLER_BLOCK (block
))
2672 /* A catch block. Must precede N_LBRAC. */
2673 tree decl
= BLOCK_VARS (block
);
2676 #ifdef DBX_OUTPUT_CATCH
2677 DBX_OUTPUT_CATCH (asmfile
, decl
, buf
);
2679 fprintf (asmfile
, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP
,
2680 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
2681 assemble_name (asmfile
, buf
);
2682 fprintf (asmfile
, "\n");
2684 decl
= TREE_CHAIN (decl
);
2688 #ifdef DBX_OUTPUT_LBRAC
2689 DBX_OUTPUT_LBRAC (asmfile
, buf
);
2691 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_LBRAC
);
2692 assemble_name (asmfile
, buf
);
2693 #if DBX_BLOCKS_FUNCTION_RELATIVE
2694 fputc ('-', asmfile
);
2695 assemble_name (asmfile
, begin_label
);
2697 fprintf (asmfile
, "\n");
2701 #ifdef DBX_LBRAC_FIRST
2702 /* On some weird machines, the syms of a block
2703 come after the N_LBRAC. */
2704 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2705 dbxout_syms (BLOCK_VARS (block
));
2707 dbxout_reg_parms (args
);
2710 /* Output the subblocks. */
2711 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
2713 /* Refer to the marker for the end of the block. */
2714 if (depth
> 0 && !ignored
)
2717 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
2718 #ifdef DBX_OUTPUT_RBRAC
2719 DBX_OUTPUT_RBRAC (asmfile
, buf
);
2721 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_RBRAC
);
2722 assemble_name (asmfile
, buf
);
2723 #if DBX_BLOCKS_FUNCTION_RELATIVE
2724 fputc ('-', asmfile
);
2725 assemble_name (asmfile
, begin_label
);
2727 fprintf (asmfile
, "\n");
2731 block
= BLOCK_CHAIN (block
);
2735 /* Output the information about a function and its arguments and result.
2736 Usually this follows the function's code,
2737 but on some systems, it comes before. */
2740 dbxout_really_begin_function (decl
)
2743 dbxout_symbol (decl
, 0);
2744 dbxout_parms (DECL_ARGUMENTS (decl
));
2745 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
2746 dbxout_symbol (DECL_RESULT (decl
), 1);
2749 /* Called at beginning of output of function definition. */
2752 dbxout_begin_function (decl
)
2753 tree decl ATTRIBUTE_UNUSED
;
2755 #ifdef DBX_FUNCTION_FIRST
2756 dbxout_really_begin_function (decl
);
2760 /* Output dbx data for a function definition.
2761 This includes a definition of the function name itself (a symbol),
2762 definitions of the parameters (locating them in the parameter list)
2763 and then output the block that makes up the function's body
2764 (including all the auto variables of the function). */
2767 dbxout_function (decl
)
2770 #ifndef DBX_FUNCTION_FIRST
2771 dbxout_really_begin_function (decl
);
2773 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
2774 #ifdef DBX_OUTPUT_FUNCTION_END
2775 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
2777 #if defined(ASM_OUTPUT_SECTION_NAME)
2778 if (use_gnu_debug_info_extensions
2779 #if defined(NO_DBX_FUNCTION_END)
2780 && ! NO_DBX_FUNCTION_END
2783 dbxout_function_end ();
2786 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */