1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* Output dbx-format symbol table data.
24 This consists of many symbol table entries, each of them
25 a .stabs assembler pseudo-op with four operands:
26 a "name" which is really a description of one symbol and its type,
27 a "code", which is a symbol defined in stab.h whose name starts with N_,
28 an unused operand always 0,
29 and a "value" which is an address or an offset.
30 The name is enclosed in doublequote characters.
32 Each function, variable, typedef, and structure tag
33 has a symbol table entry to define it.
34 The beginning and end of each level of name scoping within
35 a function are also marked by special symbol table entries.
37 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
38 and a data type number. The data type number may be followed by
39 "=" and a type definition; normally this will happen the first time
40 the type number is mentioned. The type definition may refer to
41 other types by number, and those type numbers may be followed
42 by "=" and nested definitions.
44 This can make the "name" quite long.
45 When a name is more than 80 characters, we split the .stabs pseudo-op
46 into two .stabs pseudo-ops, both sharing the same "code" and "value".
47 The first one is marked as continued with a double-backslash at the
50 The kind-of-symbol letter distinguished function names from global
51 variables from file-scope variables from parameters from auto
52 variables in memory from typedef names from register variables.
55 The "code" is mostly redundant with the kind-of-symbol letter
56 that goes in the "name", but not entirely: for symbols located
57 in static storage, the "code" says which segment the address is in,
58 which controls how it is relocated.
60 The "value" for a symbol in static storage
61 is the core address of the symbol (actually, the assembler
62 label for the symbol). For a symbol located in a stack slot
63 it is the stack offset; for one in a register, the register number.
64 For a typedef symbol, it is zero.
66 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
67 output while in the text section.
69 For more on data type definitions, see `dbxout_type'. */
78 #include "insn-config.h"
80 #include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions. */
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 /* GDB needs to know that the stabs were generated by GCC. We emit an
129 N_OPT stab at the beginning of the source file to indicate this.
130 The string is historical, and different on a very few targets. */
131 #ifndef STABS_GCC_MARKER
132 #define STABS_GCC_MARKER "gcc2_compiled."
135 /* Typical USG systems don't have stab.h, and they also have
136 no use for DBX-format debugging info. */
138 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
140 /* Nonzero if we have actually used any of the GDB extensions
141 to the debugging format. The idea is that we use them for the
142 first time only if there's a strong reason, but once we have done that,
143 we use them whenever convenient. */
145 static int have_used_extensions
= 0;
147 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
148 for the N_SO filename stabs label. */
150 static int source_label_number
= 1;
152 #ifdef DEBUG_SYMS_TEXT
153 #define FORCE_TEXT text_section ();
160 #define STAB_CODE_TYPE enum __stab_debug_code
162 /* 1 if PARM is passed to this function in memory. */
164 #define PARM_PASSED_IN_MEMORY(PARM) \
165 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
167 /* A C expression for the integer offset value of an automatic variable
168 (N_LSYM) having address X (an RTX). */
169 #ifndef DEBUGGER_AUTO_OFFSET
170 #define DEBUGGER_AUTO_OFFSET(X) \
171 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
174 /* A C expression for the integer offset value of an argument (N_PSYM)
175 having address X (an RTX). The nominal offset is OFFSET. */
176 #ifndef DEBUGGER_ARG_OFFSET
177 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
180 /* Stream for writing to assembler file. */
182 static FILE *asmfile
;
184 /* Last source file name mentioned in a NOTE insn. */
186 static const char *lastfile
;
188 /* Current working directory. */
190 static const char *cwd
;
192 enum typestatus
{TYPE_UNSEEN
, TYPE_XREF
, TYPE_DEFINED
};
194 /* Structure recording information about a C data type.
195 The status element says whether we have yet output
196 the definition of the type. TYPE_XREF says we have
197 output it as a cross-reference only.
198 The file_number and type_number elements are used if DBX_USE_BINCL
203 enum typestatus status
;
210 /* Vector recording information about C data types.
211 When we first notice a data type (a tree node),
212 we assign it a number using next_type_number.
213 That is its index in this vector. */
215 struct typeinfo
*typevec
;
217 /* Number of elements of space allocated in `typevec'. */
219 static int typevec_len
;
221 /* In dbx output, each type gets a unique number.
222 This is the number for the next type output.
223 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
225 static int next_type_number
;
229 /* When using N_BINCL in dbx output, each type number is actually a
230 pair of the file number and the type number within the file.
231 This is a stack of input files. */
235 struct dbx_file
*next
;
237 int next_type_number
;
240 /* This is the top of the stack. */
242 static struct dbx_file
*current_file
;
244 /* This is the next file number to use. */
246 static int next_file_number
;
248 #endif /* DBX_USE_BINCL */
250 /* These variables are for dbxout_symbol to communicate to
251 dbxout_finish_symbol.
252 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
253 current_sym_value and current_sym_addr are two ways to address the
254 value to store in the symtab entry.
255 current_sym_addr if nonzero represents the value as an rtx.
256 If that is zero, current_sym_value is used. This is used
257 when the value is an offset (such as for auto variables,
258 register variables and parms). */
260 static STAB_CODE_TYPE current_sym_code
;
261 static int current_sym_value
;
262 static rtx current_sym_addr
;
264 /* Number of chars of symbol-description generated so far for the
265 current symbol. Used by CHARS and CONTIN. */
267 static int current_sym_nchars
;
269 /* Report having output N chars of the current symbol-description. */
271 #define CHARS(N) (current_sym_nchars += (N))
273 /* Break the current symbol-description, generating a continuation,
274 if it has become long. */
276 #ifndef DBX_CONTIN_LENGTH
277 #define DBX_CONTIN_LENGTH 80
280 #if DBX_CONTIN_LENGTH > 0
282 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
284 #define CONTIN do { } while (0)
287 static void dbxout_init
PARAMS ((const char *));
288 static void dbxout_finish
PARAMS ((const char *));
289 static void dbxout_start_source_file
PARAMS ((unsigned, const char *));
290 static void dbxout_end_source_file
PARAMS ((unsigned));
291 static void dbxout_source_line
PARAMS ((const char *, rtx
));
292 #if defined(ASM_OUTPUT_SECTION_NAME)
293 static void dbxout_function_end
PARAMS ((void));
295 static void dbxout_typedefs
PARAMS ((tree
));
296 static void dbxout_type_index
PARAMS ((tree
));
297 #if DBX_CONTIN_LENGTH > 0
298 static void dbxout_continue
PARAMS ((void));
300 static void dbxout_type_fields
PARAMS ((tree
));
301 static void dbxout_type_method_1
PARAMS ((tree
, const char *));
302 static void dbxout_type_methods
PARAMS ((tree
));
303 static void dbxout_range_type
PARAMS ((tree
));
304 static void dbxout_type
PARAMS ((tree
, int));
305 static void print_int_cst_octal
PARAMS ((tree
));
306 static void print_octal
PARAMS ((unsigned HOST_WIDE_INT
, int));
307 static void dbxout_type_name
PARAMS ((tree
));
308 static int dbxout_symbol_location
PARAMS ((tree
, tree
, const char *, rtx
));
309 static void dbxout_symbol_name
PARAMS ((tree
, const char *, int));
310 static void dbxout_prepare_symbol
PARAMS ((tree
));
311 static void dbxout_finish_symbol
PARAMS ((tree
));
312 static void dbxout_block
PARAMS ((tree
, int, tree
));
313 static void dbxout_really_begin_function
PARAMS ((tree
));
315 /* The debug hooks structure. */
316 #if defined (DBX_DEBUGGING_INFO)
318 static void dbxout_begin_block
PARAMS ((unsigned, unsigned));
319 static void dbxout_end_block
PARAMS ((unsigned, unsigned));
321 struct gcc_debug_hooks dbx_debug_hooks
=
325 debug_nothing_int_charstar
,
326 debug_nothing_int_charstar
,
327 dbxout_start_source_file
,
328 dbxout_end_source_file
,
332 debug_nothing_void
, /* end_epilogue */
333 debug_nothing_int
/* end function */
335 #endif /* DBX_DEBUGGING_INFO */
337 #if defined (XCOFF_DEBUGGING_INFO)
338 struct gcc_debug_hooks xcoff_debug_hooks
=
342 debug_nothing_int_charstar
,
343 debug_nothing_int_charstar
,
344 dbxout_start_source_file
,
345 dbxout_end_source_file
,
346 xcoffout_begin_block
,
348 xcoffout_source_line
,
349 xcoffout_end_epilogue
,
350 xcoffout_end_function
352 #endif /* XCOFF_DEBUGGING_INFO */
354 #if defined(ASM_OUTPUT_SECTION_NAME)
356 dbxout_function_end ()
358 static int scope_labelno
= 0;
359 char lscope_label_name
[100];
360 /* Convert Ltext into the appropriate format for local labels in case
361 the system doesn't insert underscores in front of user generated
363 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
364 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Lscope", scope_labelno
);
367 /* By convention, GCC will mark the end of a function with an N_FUN
368 symbol and an empty string. */
369 fprintf (asmfile
, "%s\"\",%d,0,0,", ASM_STABS_OP
, N_FUN
);
370 assemble_name (asmfile
, lscope_label_name
);
371 fputc ('-', asmfile
);
372 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
373 fprintf (asmfile
, "\n");
375 #endif /* ! NO_DBX_FUNCTION_END */
377 /* At the beginning of compilation, start writing the symbol table.
378 Initialize `typevec' and output the standard data types of C. */
381 dbxout_init (input_file_name
)
382 const char *input_file_name
;
384 char ltext_label_name
[100];
385 tree syms
= getdecls ();
387 asmfile
= asm_out_file
;
390 typevec
= (struct typeinfo
*) xcalloc (typevec_len
, sizeof typevec
[0]);
392 /* Convert Ltext into the appropriate format for local labels in case
393 the system doesn't insert underscores in front of user generated
395 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
397 /* Put the current working directory in an N_SO symbol. */
398 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
399 but GDB always does. */
400 if (use_gnu_debug_info_extensions
)
403 if (!cwd
&& (cwd
= getpwd ()) && (!*cwd
|| cwd
[strlen (cwd
) - 1] != '/'))
404 cwd
= concat (cwd
, FILE_NAME_JOINER
, NULL
);
407 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
408 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile
, cwd
);
409 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
410 fprintf (asmfile
, "%s", ASM_STABS_OP
);
411 output_quoted_string (asmfile
, cwd
);
412 fprintf (asmfile
, ",%d,0,0,%s\n", N_SO
, <ext_label_name
[1]);
413 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
417 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
418 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
419 would give us an N_SOL, and we want an N_SO. */
420 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile
, input_file_name
);
421 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
422 /* We include outputting `Ltext:' here,
423 because that gives you a way to override it. */
424 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
425 fprintf (asmfile
, "%s", ASM_STABS_OP
);
426 output_quoted_string (asmfile
, input_file_name
);
427 fprintf (asmfile
, ",%d,0,0,%s\n",
428 N_SO
, <ext_label_name
[1]);
430 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Ltext", 0);
431 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
433 #ifdef DBX_OUTPUT_GCC_MARKER
434 DBX_OUTPUT_GCC_MARKER (asmfile
);
436 /* Emit an N_OPT stab to indicate that this file was compiled by GCC. */
437 fprintf (asmfile
, "%s\"%s\",%d,0,0,0\n",
438 ASM_STABS_OP
, STABS_GCC_MARKER
, N_OPT
);
441 lastfile
= input_file_name
;
443 next_type_number
= 1;
446 current_file
= (struct dbx_file
*) xmalloc (sizeof *current_file
);
447 current_file
->next
= NULL
;
448 current_file
->file_number
= 0;
449 current_file
->next_type_number
= 1;
450 next_file_number
= 1;
453 /* Make sure that types `int' and `char' have numbers 1 and 2.
454 Definitions of other integer types will refer to those numbers.
455 (Actually it should no longer matter what their numbers are.
456 Also, if any types with tags have been defined, dbxout_symbol
457 will output them first, so the numbers won't be 1 and 2. That
458 happens in C++. So it's a good thing it should no longer matter). */
460 #ifdef DBX_OUTPUT_STANDARD_TYPES
461 DBX_OUTPUT_STANDARD_TYPES (syms
);
463 dbxout_symbol (TYPE_NAME (integer_type_node
), 0);
464 dbxout_symbol (TYPE_NAME (char_type_node
), 0);
467 /* Get all permanent types that have typedef names,
468 and output them all, except for those already output. */
470 dbxout_typedefs (syms
);
473 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
474 in the reverse order from that which is found in SYMS. */
477 dbxout_typedefs (syms
)
482 dbxout_typedefs (TREE_CHAIN (syms
));
483 if (TREE_CODE (syms
) == TYPE_DECL
)
485 tree type
= TREE_TYPE (syms
);
487 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
488 && COMPLETE_TYPE_P (type
)
489 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
490 dbxout_symbol (TYPE_NAME (type
), 0);
495 /* Change to reading from a new source file. Generate a N_BINCL stab. */
498 dbxout_start_source_file (line
, filename
)
499 unsigned int line ATTRIBUTE_UNUSED
;
500 const char *filename ATTRIBUTE_UNUSED
;
503 struct dbx_file
*n
= (struct dbx_file
*) xmalloc (sizeof *n
);
505 n
->next
= current_file
;
506 n
->file_number
= next_file_number
++;
507 n
->next_type_number
= 1;
509 fprintf (asmfile
, "%s", ASM_STABS_OP
);
510 output_quoted_string (asmfile
, filename
);
511 fprintf (asmfile
, ",%d,0,0,0\n", N_BINCL
);
515 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
518 dbxout_end_source_file (line
)
519 unsigned int line ATTRIBUTE_UNUSED
;
522 struct dbx_file
*next
;
524 fprintf (asmfile
, "%s%d,0,0,0\n", ASM_STABN_OP
, N_EINCL
);
525 next
= current_file
->next
;
531 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
534 dbxout_source_file (file
, filename
)
536 const char *filename
;
538 char ltext_label_name
[100];
540 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
542 #ifdef DBX_OUTPUT_SOURCE_FILENAME
543 DBX_OUTPUT_SOURCE_FILENAME (file
, filename
);
545 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext",
546 source_label_number
);
547 fprintf (file
, "%s", ASM_STABS_OP
);
548 output_quoted_string (file
, filename
);
549 fprintf (file
, ",%d,0,0,%s\n", N_SOL
, <ext_label_name
[1]);
550 if (current_function_decl
!= NULL_TREE
551 && DECL_SECTION_NAME (current_function_decl
) != NULL_TREE
)
552 ; /* Don't change section amid function. */
555 ASM_OUTPUT_INTERNAL_LABEL (file
, "Ltext", source_label_number
);
556 source_label_number
++;
562 /* Output a line number symbol entry into output stream FILE,
563 for source file FILENAME and line number LINENO. */
566 dbxout_source_line (filename
, note
)
567 const char *filename
;
570 unsigned int lineno
= NOTE_LINE_NUMBER (note
);
572 dbxout_source_file (asmfile
, filename
);
574 #ifdef ASM_OUTPUT_SOURCE_LINE
575 ASM_OUTPUT_SOURCE_LINE (asmfile
, lineno
);
577 fprintf (asmfile
, "%s%d,0,%d\n", ASM_STABD_OP
, N_SLINE
, lineno
);
581 #if defined (DBX_DEBUGGING_INFO)
583 /* Describe the beginning of an internal block within a function. */
586 dbxout_begin_block (line
, n
)
587 unsigned int line ATTRIBUTE_UNUSED
;
590 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "LBB", n
);
593 /* Describe the end line-number of an internal block within a function. */
596 dbxout_end_block (line
, n
)
597 unsigned int line ATTRIBUTE_UNUSED
;
600 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "LBE", n
);
603 #endif /* DBX_DEBUGGING_INFO */
605 /* At the end of compilation, finish writing the symbol table.
606 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
610 dbxout_finish (filename
)
611 const char *filename ATTRIBUTE_UNUSED
;
613 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
614 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asmfile
, filename
);
615 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
618 /* Output the index of a type. */
621 dbxout_type_index (type
)
624 #ifndef DBX_USE_BINCL
625 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
628 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
629 fprintf (asmfile
, "(%d,%d)", t
->file_number
, t
->type_number
);
634 #if DBX_CONTIN_LENGTH > 0
635 /* Continue a symbol-description that gets too big.
636 End one symbol table entry with a double-backslash
637 and start a new one, eventually producing something like
638 .stabs "start......\\",code,0,value
639 .stabs "...rest",code,0,value */
644 #ifdef DBX_CONTIN_CHAR
645 fprintf (asmfile
, "%c", DBX_CONTIN_CHAR
);
647 fprintf (asmfile
, "\\\\");
649 dbxout_finish_symbol (NULL_TREE
);
650 fprintf (asmfile
, "%s\"", ASM_STABS_OP
);
651 current_sym_nchars
= 0;
653 #endif /* DBX_CONTIN_LENGTH > 0 */
655 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
656 This must be a separate function because anonymous unions require
660 dbxout_type_fields (type
)
665 /* Output the name, type, position (in bits), size (in bits) of each
666 field that we can support. */
667 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
669 /* Omit here local type decls until we know how to support them. */
670 if (TREE_CODE (tem
) == TYPE_DECL
671 /* Omit fields whose position or size are variable or too large to
673 || (TREE_CODE (tem
) == FIELD_DECL
674 && (! host_integerp (bit_position (tem
), 0)
676 || ! host_integerp (DECL_SIZE (tem
), 1)))
677 /* Omit here the nameless fields that are used to skip bits. */
678 || DECL_IGNORED_P (tem
))
681 else if (TREE_CODE (tem
) != CONST_DECL
)
683 /* Continue the line if necessary,
684 but not before the first field. */
685 if (tem
!= TYPE_FIELDS (type
))
690 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem
)));
691 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem
)));
695 fprintf (asmfile
, ":");
699 if (use_gnu_debug_info_extensions
700 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
701 || TREE_CODE (tem
) != FIELD_DECL
))
703 have_used_extensions
= 1;
705 putc ((TREE_PRIVATE (tem
) ? '0'
706 : TREE_PROTECTED (tem
) ? '1' : '2'),
711 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
712 && DECL_BIT_FIELD_TYPE (tem
))
713 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0);
715 if (TREE_CODE (tem
) == VAR_DECL
)
717 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
720 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
));
721 have_used_extensions
= 1;
722 fprintf (asmfile
, ":%s;", name
);
723 CHARS (strlen (name
));
726 /* If TEM is non-static, GDB won't understand it. */
727 fprintf (asmfile
, ",0,0;");
731 fputc (',', asmfile
);
732 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
733 int_bit_position (tem
));
734 fputc (',', asmfile
);
735 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
736 tree_low_cst (DECL_SIZE (tem
), 1));
737 fputc (';', asmfile
);
744 /* Subroutine of `dbxout_type_methods'. Output debug info about the
745 method described DECL. DEBUG_NAME is an encoding of the method's
746 type signature. ??? We may be able to do without DEBUG_NAME altogether
750 dbxout_type_method_1 (decl
, debug_name
)
752 const char *debug_name
;
756 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
758 else /* it's a METHOD_TYPE. */
760 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
761 /* A for normal functions.
762 B for `const' member functions.
763 C for `volatile' member functions.
764 D for `const volatile' member functions. */
765 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
767 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
770 if (DECL_VINDEX (decl
))
776 fprintf (asmfile
, ":%s;%c%c%c", debug_name
,
777 TREE_PRIVATE (decl
) ? '0'
778 : TREE_PROTECTED (decl
) ? '1' : '2', c1
, c2
);
779 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
)) + 6
780 - (debug_name
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
782 if (DECL_VINDEX (decl
) && host_integerp (DECL_VINDEX (decl
), 0))
784 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
785 tree_low_cst (DECL_VINDEX (decl
), 0));
786 fputc (';', asmfile
);
787 dbxout_type (DECL_CONTEXT (decl
), 0);
788 fprintf (asmfile
, ";");
793 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
797 dbxout_type_methods (type
)
800 /* C++: put out the method names and their parameter lists */
801 tree methods
= TYPE_METHODS (type
);
803 register tree fndecl
;
805 char formatted_type_identifier_length
[16];
806 register int type_identifier_length
;
808 if (methods
== NULL_TREE
)
811 type_encoding
= DECL_NAME (TYPE_NAME (type
));
814 /* C++: Template classes break some assumptions made by this code about
815 the class names, constructor names, and encodings for assembler
816 label names. For now, disable output of dbx info for them. */
818 const char *ptr
= IDENTIFIER_POINTER (type_encoding
);
819 /* This should use index. (mrs) */
820 while (*ptr
&& *ptr
!= '<') ptr
++;
831 type_identifier_length
= IDENTIFIER_LENGTH (type_encoding
);
833 sprintf (formatted_type_identifier_length
, "%d", type_identifier_length
);
835 if (TREE_CODE (methods
) != TREE_VEC
)
837 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
838 fndecl
= TREE_VEC_ELT (methods
, 0);
840 fndecl
= TREE_VEC_ELT (methods
, 1);
846 /* Group together all the methods for the same operation.
847 These differ in the types of the arguments. */
848 for (last
= NULL_TREE
;
849 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
850 fndecl
= TREE_CHAIN (fndecl
))
851 /* Output the name of the field (after overloading), as
852 well as the name of the field before overloading, along
853 with its parameter list */
855 /* This is the "mangled" name of the method.
856 It encodes the argument types. */
857 const char *debug_name
;
859 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
860 include TEMPLATE_DECLs.) The debugger doesn't know what
861 to do with such entities anyhow. */
862 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
866 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
));
872 /* Also ignore abstract methods; those are only interesting to
873 the DWARF backends. */
874 if (DECL_IGNORED_P (fndecl
) || DECL_ABSTRACT (fndecl
))
877 /* Redundantly output the plain name, since that's what gdb
881 tree name
= DECL_NAME (fndecl
);
882 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (name
));
883 CHARS (IDENTIFIER_LENGTH (name
) + 2);
887 dbxout_type (TREE_TYPE (fndecl
), 0);
889 dbxout_type_method_1 (fndecl
, debug_name
);
899 /* Emit a "range" type specification, which has the form:
900 "r<index type>;<lower bound>;<upper bound>;".
901 TYPE is an INTEGER_TYPE. */
904 dbxout_range_type (type
)
907 fprintf (asmfile
, "r");
908 if (TREE_TYPE (type
))
909 dbxout_type (TREE_TYPE (type
), 0);
910 else if (TREE_CODE (type
) != INTEGER_TYPE
)
911 dbxout_type (type
, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
914 /* Traditionally, we made sure 'int' was type 1, and builtin types
915 were defined to be sub-ranges of int. Unfortunately, this
916 does not allow us to distinguish true sub-ranges from integer
917 types. So, instead we define integer (non-sub-range) types as
918 sub-ranges of themselves. This matters for Chill. If this isn't
919 a subrange type, then we want to define it in terms of itself.
920 However, in C, this may be an anonymous integer type, and we don't
921 want to emit debug info referring to it. Just calling
922 dbxout_type_index won't work anyways, because the type hasn't been
923 defined yet. We make this work for both cases by checked to see
924 whether this is a defined type, referring to it if it is, and using
926 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
927 dbxout_type_index (type
);
929 dbxout_type_index (integer_type_node
);
932 if (TYPE_MIN_VALUE (type
) != 0
933 && host_integerp (TYPE_MIN_VALUE (type
), 0))
935 fputc (';', asmfile
);
936 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
937 tree_low_cst (TYPE_MIN_VALUE (type
), 0));
940 fprintf (asmfile
, ";0");
942 if (TYPE_MAX_VALUE (type
) != 0
943 && host_integerp (TYPE_MAX_VALUE (type
), 0))
945 fputc (';', asmfile
);
946 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
947 tree_low_cst (TYPE_MAX_VALUE (type
), 0));
948 fputc (';', asmfile
);
951 fprintf (asmfile
, ";-1;");
954 /* Output a reference to a type. If the type has not yet been
955 described in the dbx output, output its definition now.
956 For a type already defined, just refer to its definition
957 using the type number.
959 If FULL is nonzero, and the type has been described only with
960 a forward-reference, output the definition now.
961 If FULL is zero in this case, just refer to the forward-reference
962 using the number previously allocated. */
965 dbxout_type (type
, full
)
970 static int anonymous_type_number
= 0;
972 if (TREE_CODE (type
) == VECTOR_TYPE
)
973 type
= TYPE_DEBUG_REPRESENTATION_TYPE (type
);
975 /* If there was an input error and we don't really have a type,
976 avoid crashing and write something that is at least valid
977 by assuming `int'. */
978 if (type
== error_mark_node
)
979 type
= integer_type_node
;
982 /* Try to find the "main variant" with the same name but not const
983 or volatile. (Since stabs does not distinguish const and volatile,
984 there is no need to make them separate types. But types with
985 different names are usefully distinguished.) */
987 for (tem
= TYPE_MAIN_VARIANT (type
); tem
; tem
= TYPE_NEXT_VARIANT (tem
))
988 if (!TYPE_READONLY (tem
) && !TYPE_VOLATILE (tem
)
989 && TYPE_NAME (tem
) == TYPE_NAME (type
))
995 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
996 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1000 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1002 /* Type has no dbx number assigned. Assign next available number. */
1003 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1005 /* Make sure type vector is long enough to record about this type. */
1007 if (next_type_number
== typevec_len
)
1010 = (struct typeinfo
*) xrealloc (typevec
,
1011 typevec_len
* 2 * sizeof typevec
[0]);
1012 memset ((char *) (typevec
+ typevec_len
), 0,
1013 typevec_len
* sizeof typevec
[0]);
1017 #ifdef DBX_USE_BINCL
1018 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1019 = current_file
->file_number
;
1020 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1021 = current_file
->next_type_number
++;
1025 /* Output the number of this type, to refer to it. */
1026 dbxout_type_index (type
);
1028 #ifdef DBX_TYPE_DEFINED
1029 if (DBX_TYPE_DEFINED (type
))
1033 /* If this type's definition has been output or is now being output,
1036 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1041 /* If we have already had a cross reference,
1042 and either that's all we want or that's the best we could do,
1043 don't repeat the cross reference.
1044 Sun dbx crashes if we do. */
1045 if (! full
|| !COMPLETE_TYPE_P (type
)
1046 /* No way in DBX fmt to describe a variable size. */
1047 || ! host_integerp (TYPE_SIZE (type
), 1))
1055 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1056 leave the type-number completely undefined rather than output
1057 a cross-reference. If we have already used GNU debug info extensions,
1058 then it is OK to output a cross reference. This is necessary to get
1059 proper C++ debug output. */
1060 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1061 || TREE_CODE (type
) == QUAL_UNION_TYPE
1062 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1063 && ! use_gnu_debug_info_extensions
)
1064 /* We must use the same test here as we use twice below when deciding
1065 whether to emit a cross-reference. */
1066 if ((TYPE_NAME (type
) != 0
1067 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1068 && DECL_IGNORED_P (TYPE_NAME (type
)))
1070 || !COMPLETE_TYPE_P (type
)
1071 /* No way in DBX fmt to describe a variable size. */
1072 || ! host_integerp (TYPE_SIZE (type
), 1))
1074 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1079 /* Output a definition now. */
1081 fprintf (asmfile
, "=");
1084 /* Mark it as defined, so that if it is self-referent
1085 we will not get into an infinite recursion of definitions. */
1087 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1089 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1090 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1092 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0);
1096 switch (TREE_CODE (type
))
1100 /* For a void type, just define it as itself; ie, "5=5".
1101 This makes us consider it defined
1102 without saying what it is. The debugger will make it
1103 a void type when the reference is seen, and nothing will
1104 ever override that default. */
1105 dbxout_type_index (type
);
1109 if (type
== char_type_node
&& ! TREE_UNSIGNED (type
))
1111 /* Output the type `char' as a subrange of itself!
1112 I don't understand this definition, just copied it
1113 from the output of pcc.
1114 This used to use `r2' explicitly and we used to
1115 take care to make sure that `char' was type number 2. */
1116 fprintf (asmfile
, "r");
1117 dbxout_type_index (type
);
1118 fprintf (asmfile
, ";0;127;");
1121 /* If this is a subtype of another integer type, always prefer to
1122 write it as a subtype. */
1123 else if (TREE_TYPE (type
) != 0
1124 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
1125 dbxout_range_type (type
);
1129 /* If the size is non-standard, say what it is if we can use
1132 if (use_gnu_debug_info_extensions
1133 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1134 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1136 /* If we can use GDB extensions and the size is wider than a
1137 long (the size used by GDB to read them) or we may have
1138 trouble writing the bounds the usual way, write them in
1139 octal. Note the test is for the *target's* size of "long",
1140 not that of the host. The host test is just to make sure we
1141 can write it out in case the host wide int is narrower than the
1144 /* For unsigned types, we use octal if they are the same size or
1145 larger. This is because we print the bounds as signed decimal,
1146 and hence they can't span same size unsigned types. */
1148 if (use_gnu_debug_info_extensions
1149 && TYPE_MIN_VALUE (type
) != 0
1150 && TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
1151 && TYPE_MAX_VALUE (type
) != 0
1152 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
1153 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
1154 || ((TYPE_PRECISION (type
)
1155 == TYPE_PRECISION (integer_type_node
))
1156 && TREE_UNSIGNED (type
))
1157 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
1158 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
1159 && TREE_UNSIGNED (type
))))
1161 fprintf (asmfile
, "r");
1162 dbxout_type_index (type
);
1163 fprintf (asmfile
, ";");
1164 print_int_cst_octal (TYPE_MIN_VALUE (type
));
1165 fprintf (asmfile
, ";");
1166 print_int_cst_octal (TYPE_MAX_VALUE (type
));
1167 fprintf (asmfile
, ";");
1171 /* Output other integer types as subranges of `int'. */
1172 dbxout_range_type (type
);
1179 /* This used to say `r1' and we used to take care
1180 to make sure that `int' was type number 1. */
1181 fprintf (asmfile
, "r");
1182 dbxout_type_index (integer_type_node
);
1183 fputc (';', asmfile
);
1184 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1185 fputs (";0;", asmfile
);
1190 if (use_gnu_debug_info_extensions
)
1192 fputs ("@s", asmfile
);
1193 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1194 BITS_PER_UNIT
* int_size_in_bytes (type
));
1195 fputs (";-20;", asmfile
);
1199 /* Output the type `char' as a subrange of itself.
1200 That is what pcc seems to do. */
1201 fprintf (asmfile
, "r");
1202 dbxout_type_index (char_type_node
);
1203 fprintf (asmfile
, ";0;%d;", TREE_UNSIGNED (type
) ? 255 : 127);
1209 if (use_gnu_debug_info_extensions
)
1211 fputs ("@s", asmfile
);
1212 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1213 BITS_PER_UNIT
* int_size_in_bytes (type
));
1214 fputs (";-16;", asmfile
);
1216 else /* Define as enumeral type (False, True) */
1217 fprintf (asmfile
, "eFalse:0,True:1,;");
1222 putc ('d', asmfile
);
1224 dbxout_type (TREE_TYPE (type
), 0);
1228 /* Differs from the REAL_TYPE by its new data type number */
1230 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1232 fprintf (asmfile
, "r");
1233 dbxout_type_index (type
);
1234 fputc (';', asmfile
);
1235 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1236 2 * int_size_in_bytes (TREE_TYPE (type
)));
1237 fputs (";0;", asmfile
);
1238 CHARS (12); /* The number is probably incorrect here. */
1242 /* Output a complex integer type as a structure,
1243 pending some other way to do it. */
1244 fputc ('s', asmfile
);
1245 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1247 fprintf (asmfile
, "real:");
1249 dbxout_type (TREE_TYPE (type
), 0);
1250 fprintf (asmfile
, ",%d,%d;",
1251 0, TYPE_PRECISION (TREE_TYPE (type
)));
1253 fprintf (asmfile
, "imag:");
1255 dbxout_type (TREE_TYPE (type
), 0);
1256 fprintf (asmfile
, ",%d,%d;;",
1257 TYPE_PRECISION (TREE_TYPE (type
)),
1258 TYPE_PRECISION (TREE_TYPE (type
)));
1264 if (use_gnu_debug_info_extensions
)
1266 have_used_extensions
= 1;
1267 fputs ("@s", asmfile
);
1268 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1269 BITS_PER_UNIT
* int_size_in_bytes (type
));
1270 fputc (';', asmfile
);
1271 /* Check if a bitstring type, which in Chill is
1272 different from a [power]set. */
1273 if (TYPE_STRING_FLAG (type
))
1274 fprintf (asmfile
, "@S;");
1276 putc ('S', asmfile
);
1278 dbxout_type (TYPE_DOMAIN (type
), 0);
1282 /* Make arrays of packed bits look like bitstrings for chill. */
1283 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
1285 have_used_extensions
= 1;
1286 fputs ("@s", asmfile
);
1287 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1288 BITS_PER_UNIT
* int_size_in_bytes (type
));
1289 fputc (';', asmfile
);
1290 fprintf (asmfile
, "@S;");
1291 putc ('S', asmfile
);
1293 dbxout_type (TYPE_DOMAIN (type
), 0);
1296 /* Output "a" followed by a range type definition
1297 for the index type of the array
1298 followed by a reference to the target-type.
1299 ar1;0;N;M for a C array of type M and size N+1. */
1300 /* Check if a character string type, which in Chill is
1301 different from an array of characters. */
1302 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
1304 have_used_extensions
= 1;
1305 fprintf (asmfile
, "@S;");
1307 tem
= TYPE_DOMAIN (type
);
1310 fprintf (asmfile
, "ar");
1311 dbxout_type_index (integer_type_node
);
1312 fprintf (asmfile
, ";0;-1;");
1316 fprintf (asmfile
, "a");
1317 dbxout_range_type (tem
);
1320 dbxout_type (TREE_TYPE (type
), 0);
1325 case QUAL_UNION_TYPE
:
1327 int i
, n_baseclasses
= 0;
1329 if (TYPE_BINFO (type
) != 0
1330 && TREE_CODE (TYPE_BINFO (type
)) == TREE_VEC
1331 && TYPE_BINFO_BASETYPES (type
) != 0)
1332 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
1334 /* Output a structure type. We must use the same test here as we
1335 use in the DBX_NO_XREFS case above. */
1336 if ((TYPE_NAME (type
) != 0
1337 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1338 && DECL_IGNORED_P (TYPE_NAME (type
)))
1340 || !COMPLETE_TYPE_P (type
)
1341 /* No way in DBX fmt to describe a variable size. */
1342 || ! host_integerp (TYPE_SIZE (type
), 1))
1344 /* If the type is just a cross reference, output one
1345 and mark the type as partially described.
1346 If it later becomes defined, we will output
1347 its real definition.
1348 If the type has a name, don't nest its definition within
1349 another type's definition; instead, output an xref
1350 and let the definition come when the name is defined. */
1351 fputs ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu", asmfile
);
1353 #if 0 /* This assertion is legitimately false in C++. */
1354 /* We shouldn't be outputting a reference to a type before its
1355 definition unless the type has a tag name.
1356 A typedef name without a tag name should be impossible. */
1357 if (TREE_CODE (TYPE_NAME (type
)) != IDENTIFIER_NODE
)
1360 if (TYPE_NAME (type
) != 0)
1361 dbxout_type_name (type
);
1363 fprintf (asmfile
, "$$%d", anonymous_type_number
++);
1364 fprintf (asmfile
, ":");
1365 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1369 /* Identify record or union, and print its size. */
1370 fputc (((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u'), asmfile
);
1371 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1372 int_size_in_bytes (type
));
1374 if (use_gnu_debug_info_extensions
)
1378 have_used_extensions
= 1;
1379 fprintf (asmfile
, "!%d,", n_baseclasses
);
1383 for (i
= 0; i
< n_baseclasses
; i
++)
1385 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)), i
);
1387 if (use_gnu_debug_info_extensions
)
1389 have_used_extensions
= 1;
1390 putc (TREE_VIA_VIRTUAL (child
) ? '1' : '0', asmfile
);
1391 putc (TREE_VIA_PUBLIC (child
) ? '2' : '0', asmfile
);
1392 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1393 (tree_low_cst (BINFO_OFFSET (child
), 0)
1395 fputc (',', asmfile
);
1397 dbxout_type (BINFO_TYPE (child
), 0);
1398 putc (';', asmfile
);
1402 /* Print out the base class information with fields
1403 which have the same names at the types they hold. */
1404 dbxout_type_name (BINFO_TYPE (child
));
1405 putc (':', asmfile
);
1406 dbxout_type (BINFO_TYPE (child
), full
);
1407 fputc (',', asmfile
);
1408 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1409 tree_low_cst (BINFO_OFFSET (child
), 0)
1411 fputc (',', asmfile
);
1412 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1413 (tree_low_cst (DECL_SIZE (TYPE_NAME
1414 (BINFO_TYPE (child
))), 0)
1416 fputc (';', asmfile
);
1424 /* Write out the field declarations. */
1425 dbxout_type_fields (type
);
1426 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1428 have_used_extensions
= 1;
1429 dbxout_type_methods (type
);
1432 putc (';', asmfile
);
1434 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1435 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1436 && TYPE_VFIELD (type
))
1438 have_used_extensions
= 1;
1440 /* Tell GDB+ that it may keep reading. */
1441 putc ('~', asmfile
);
1443 /* We need to write out info about what field this class
1444 uses as its "main" vtable pointer field, because if this
1445 field is inherited from a base class, GDB cannot necessarily
1446 figure out which field it's using in time. */
1447 if (TYPE_VFIELD (type
))
1449 putc ('%', asmfile
);
1450 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0);
1452 putc (';', asmfile
);
1458 /* We must use the same test here as we use in the DBX_NO_XREFS case
1459 above. We simplify it a bit since an enum will never have a variable
1461 if ((TYPE_NAME (type
) != 0
1462 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1463 && DECL_IGNORED_P (TYPE_NAME (type
)))
1465 || !COMPLETE_TYPE_P (type
))
1467 fprintf (asmfile
, "xe");
1469 dbxout_type_name (type
);
1470 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1471 fprintf (asmfile
, ":");
1474 #ifdef DBX_OUTPUT_ENUM
1475 DBX_OUTPUT_ENUM (asmfile
, type
);
1477 if (use_gnu_debug_info_extensions
1478 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1479 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1480 putc ('e', asmfile
);
1482 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1484 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)));
1485 if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == 0)
1486 fprintf (asmfile
, HOST_WIDE_INT_PRINT_UNSIGNED
,
1487 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1488 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == -1
1489 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (TREE_VALUE (tem
)) < 0)
1490 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1491 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1493 print_int_cst_octal (TREE_VALUE (tem
));
1494 fprintf (asmfile
, ",");
1495 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)));
1496 if (TREE_CHAIN (tem
) != 0)
1501 putc (';', asmfile
);
1507 putc ('*', asmfile
);
1509 dbxout_type (TREE_TYPE (type
), 0);
1513 if (use_gnu_debug_info_extensions
)
1515 have_used_extensions
= 1;
1516 putc ('#', asmfile
);
1519 /* Write the argument types out longhand. */
1520 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0);
1521 putc (',', asmfile
);
1523 dbxout_type (TREE_TYPE (type
), 0);
1524 dbxout_args (TYPE_ARG_TYPES (type
));
1525 putc (';', asmfile
);
1530 /* Treat it as a function type. */
1531 dbxout_type (TREE_TYPE (type
), 0);
1536 if (use_gnu_debug_info_extensions
)
1538 have_used_extensions
= 1;
1539 putc ('@', asmfile
);
1541 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0);
1542 putc (',', asmfile
);
1544 dbxout_type (TREE_TYPE (type
), 0);
1548 /* Should print as an int, because it is really
1550 dbxout_type (integer_type_node
, 0);
1554 case REFERENCE_TYPE
:
1555 if (use_gnu_debug_info_extensions
)
1556 have_used_extensions
= 1;
1557 putc (use_gnu_debug_info_extensions
? '&' : '*', asmfile
);
1559 dbxout_type (TREE_TYPE (type
), 0);
1563 putc ('f', asmfile
);
1565 dbxout_type (TREE_TYPE (type
), 0);
1573 /* Print the value of integer constant C, in octal,
1574 handling double precision. */
1577 print_int_cst_octal (c
)
1580 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (c
);
1581 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (c
);
1582 int excess
= (3 - (HOST_BITS_PER_WIDE_INT
% 3));
1583 unsigned int width
= TYPE_PRECISION (TREE_TYPE (c
));
1585 /* GDB wants constants with no extra leading "1" bits, so
1586 we need to remove any sign-extension that might be
1588 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
1590 else if (width
> HOST_BITS_PER_WIDE_INT
)
1591 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
1592 else if (width
== HOST_BITS_PER_WIDE_INT
)
1595 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
1597 fprintf (asmfile
, "0");
1601 print_octal (high
, HOST_BITS_PER_WIDE_INT
/ 3);
1602 print_octal (low
, HOST_BITS_PER_WIDE_INT
/ 3);
1606 unsigned HOST_WIDE_INT beg
= high
>> excess
;
1607 unsigned HOST_WIDE_INT middle
1608 = ((high
& (((HOST_WIDE_INT
) 1 << excess
) - 1)) << (3 - excess
)
1609 | (low
>> (HOST_BITS_PER_WIDE_INT
/ 3 * 3)));
1610 unsigned HOST_WIDE_INT end
1611 = low
& (((unsigned HOST_WIDE_INT
) 1
1612 << (HOST_BITS_PER_WIDE_INT
/ 3 * 3))
1615 fprintf (asmfile
, "%o%01o", (int) beg
, (int) middle
);
1616 print_octal (end
, HOST_BITS_PER_WIDE_INT
/ 3);
1621 print_octal (value
, digits
)
1622 unsigned HOST_WIDE_INT value
;
1627 for (i
= digits
- 1; i
>= 0; i
--)
1628 fprintf (asmfile
, "%01o", (int) ((value
>> (3 * i
)) & 7));
1631 /* Output the name of type TYPE, with no punctuation.
1632 Such names can be set up either by typedef declarations
1633 or by struct, enum and union tags. */
1636 dbxout_type_name (type
)
1640 if (TYPE_NAME (type
) == 0)
1642 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
1644 t
= TYPE_NAME (type
);
1646 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1648 t
= DECL_NAME (TYPE_NAME (type
));
1653 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
1654 CHARS (IDENTIFIER_LENGTH (t
));
1657 /* Output a .stabs for the symbol defined by DECL,
1658 which must be a ..._DECL node in the normal namespace.
1659 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1660 LOCAL is nonzero if the scope is less than the entire file.
1661 Return 1 if a stabs might have been emitted. */
1664 dbxout_symbol (decl
, local
)
1666 int local ATTRIBUTE_UNUSED
;
1668 tree type
= TREE_TYPE (decl
);
1669 tree context
= NULL_TREE
;
1672 /* Cast avoids warning in old compilers. */
1673 current_sym_code
= (STAB_CODE_TYPE
) 0;
1674 current_sym_value
= 0;
1675 current_sym_addr
= 0;
1677 /* Ignore nameless syms, but don't ignore type tags. */
1679 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
1680 || DECL_IGNORED_P (decl
))
1683 dbxout_prepare_symbol (decl
);
1685 /* The output will always start with the symbol name,
1686 so always count that in the length-output-so-far. */
1688 if (DECL_NAME (decl
) != 0)
1689 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
1691 switch (TREE_CODE (decl
))
1694 /* Enum values are defined by defining the enum type. */
1698 if (DECL_RTL (decl
) == 0)
1700 if (DECL_EXTERNAL (decl
))
1702 /* Don't mention a nested function under its parent. */
1703 context
= decl_function_context (decl
);
1704 if (context
== current_function_decl
)
1706 if (GET_CODE (DECL_RTL (decl
)) != MEM
1707 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
1711 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
1712 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1713 TREE_PUBLIC (decl
) ? 'F' : 'f');
1716 current_sym_code
= N_FUN
;
1717 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1719 if (TREE_TYPE (type
))
1720 dbxout_type (TREE_TYPE (type
), 0);
1722 dbxout_type (void_type_node
, 0);
1724 /* For a nested function, when that function is compiled,
1725 mention the containing function name
1726 as well as (since dbx wants it) our own assembler-name. */
1728 fprintf (asmfile
, ",%s,%s",
1729 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1730 IDENTIFIER_POINTER (DECL_NAME (context
)));
1732 dbxout_finish_symbol (decl
);
1737 /* This seems all wrong. Outputting most kinds of types gives no name
1738 at all. A true definition gives no name; a cross-ref for a
1739 structure can give the tag name, but not a type name.
1740 It seems that no typedef name is defined by outputting a type. */
1742 /* If this typedef name was defined by outputting the type,
1743 don't duplicate it. */
1744 if (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
== TYPE_DEFINED
1745 && TYPE_NAME (TREE_TYPE (decl
)) == decl
)
1748 /* Don't output the same typedef twice.
1749 And don't output what language-specific stuff doesn't want output. */
1750 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
1759 if (DECL_NAME (decl
))
1761 /* Nonzero means we must output a tag as well as a typedef. */
1764 /* Handle the case of a C++ structure or union
1765 where the TYPE_NAME is a TYPE_DECL
1766 which gives both a typedef name and a tag. */
1767 /* dbx requires the tag first and the typedef second. */
1768 if ((TREE_CODE (type
) == RECORD_TYPE
1769 || TREE_CODE (type
) == UNION_TYPE
1770 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1771 && TYPE_NAME (type
) == decl
1772 && !(use_gnu_debug_info_extensions
&& have_used_extensions
)
1773 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
1774 /* Distinguish the implicit typedefs of C++
1775 from explicit ones that might be found in C. */
1776 && DECL_ARTIFICIAL (decl
)
1777 /* Do not generate a tag for records of variable size,
1778 since this type can not be properly described in the
1779 DBX format, and it confuses some tools such as objdump. */
1780 && host_integerp (TYPE_SIZE (type
), 1))
1782 tree name
= TYPE_NAME (type
);
1783 if (TREE_CODE (name
) == TYPE_DECL
)
1784 name
= DECL_NAME (name
);
1786 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1787 current_sym_value
= 0;
1788 current_sym_addr
= 0;
1789 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1791 fprintf (asmfile
, "%s\"%s:T", ASM_STABS_OP
,
1792 IDENTIFIER_POINTER (name
));
1793 dbxout_type (type
, 1);
1794 dbxout_finish_symbol (NULL_TREE
);
1797 /* Output typedef name. */
1798 fprintf (asmfile
, "%s\"%s:", ASM_STABS_OP
,
1799 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1801 /* Short cut way to output a tag also. */
1802 if ((TREE_CODE (type
) == RECORD_TYPE
1803 || TREE_CODE (type
) == UNION_TYPE
1804 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1805 && TYPE_NAME (type
) == decl
1806 /* Distinguish the implicit typedefs of C++
1807 from explicit ones that might be found in C. */
1808 && DECL_ARTIFICIAL (decl
))
1810 if (use_gnu_debug_info_extensions
&& have_used_extensions
)
1812 putc ('T', asmfile
);
1813 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
1815 #if 0 /* Now we generate the tag for this case up above. */
1821 putc ('t', asmfile
);
1822 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1824 dbxout_type (type
, 1);
1825 dbxout_finish_symbol (decl
);
1829 /* Don't output a tag if this is an incomplete type. This prevents
1830 the sun4 Sun OS 4.x dbx from crashing. */
1832 if (tag_needed
&& TYPE_NAME (type
) != 0
1833 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
1834 || (DECL_NAME (TYPE_NAME (type
)) != 0))
1835 && COMPLETE_TYPE_P (type
)
1836 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1838 /* For a TYPE_DECL with no name, but the type has a name,
1840 This is what represents `struct foo' with no typedef. */
1841 /* In C++, the name of a type is the corresponding typedef.
1842 In C, it is an IDENTIFIER_NODE. */
1843 tree name
= TYPE_NAME (type
);
1844 if (TREE_CODE (name
) == TYPE_DECL
)
1845 name
= DECL_NAME (name
);
1847 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1848 current_sym_value
= 0;
1849 current_sym_addr
= 0;
1850 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1852 fprintf (asmfile
, "%s\"%s:T", ASM_STABS_OP
,
1853 IDENTIFIER_POINTER (name
));
1854 dbxout_type (type
, 1);
1855 dbxout_finish_symbol (NULL_TREE
);
1859 /* If an enum type has no name, it cannot be referred to,
1860 but we must output it anyway, since the enumeration constants
1861 can be referred to. */
1862 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
1864 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1865 current_sym_value
= 0;
1866 current_sym_addr
= 0;
1867 current_sym_nchars
= 2;
1869 /* Some debuggers fail when given NULL names, so give this a
1870 harmless name of ` '. */
1871 fprintf (asmfile
, "%s\" :T", ASM_STABS_OP
);
1872 dbxout_type (type
, 1);
1873 dbxout_finish_symbol (NULL_TREE
);
1876 /* Prevent duplicate output of a typedef. */
1877 TREE_ASM_WRITTEN (decl
) = 1;
1882 /* Parm decls go in their own separate chains
1883 and are output by dbxout_reg_parms and dbxout_parms. */
1887 /* Named return value, treat like a VAR_DECL. */
1889 if (! DECL_RTL_SET_P (decl
))
1891 /* Don't mention a variable that is external.
1892 Let the file that defines it describe it. */
1893 if (DECL_EXTERNAL (decl
))
1896 /* If the variable is really a constant
1897 and not written in memory, inform the debugger. */
1898 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
1899 && DECL_INITIAL (decl
) != 0
1900 && host_integerp (DECL_INITIAL (decl
), 0)
1901 && ! TREE_ASM_WRITTEN (decl
)
1902 && (DECL_CONTEXT (decl
) == NULL_TREE
1903 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
))
1905 if (TREE_PUBLIC (decl
) == 0)
1907 /* The sun4 assembler does not grok this. */
1908 const char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1910 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
1911 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
1913 HOST_WIDE_INT ival
= tree_low_cst (DECL_INITIAL (decl
), 0);
1914 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1915 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile
, name
, ival
);
1917 fprintf (asmfile
, "%s\"%s:c=i", ASM_STABS_OP
, name
);
1919 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, ival
);
1920 fprintf (asmfile
, "\",0x%x,0,0,0\n", N_LSYM
);
1924 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
1926 /* don't know how to do this yet. */
1930 /* else it is something we handle like a normal variable. */
1933 SET_DECL_RTL (decl
, eliminate_regs (DECL_RTL (decl
), 0, NULL_RTX
));
1934 #ifdef LEAF_REG_REMAP
1935 if (current_function_uses_only_leaf_regs
)
1936 leaf_renumber_regs_insn (DECL_RTL (decl
));
1939 result
= dbxout_symbol_location (decl
, type
, 0, DECL_RTL (decl
));
1948 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1949 Add SUFFIX to its name, if SUFFIX is not 0.
1950 Describe the variable as residing in HOME
1951 (usually HOME is DECL_RTL (DECL), but not always).
1952 Returns 1 if the stab was really emitted. */
1955 dbxout_symbol_location (decl
, type
, suffix
, home
)
1963 /* Don't mention a variable at all
1964 if it was completely optimized into nothingness.
1966 If the decl was from an inline function, then its rtl
1967 is not identically the rtl that was used in this
1968 particular compilation. */
1969 if (GET_CODE (home
) == REG
)
1971 regno
= REGNO (home
);
1972 if (regno
>= FIRST_PSEUDO_REGISTER
)
1975 else if (GET_CODE (home
) == SUBREG
)
1979 while (GET_CODE (value
) == SUBREG
)
1980 value
= SUBREG_REG (value
);
1981 if (GET_CODE (value
) == REG
)
1983 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
1986 regno
= REGNO (alter_subreg (home
));
1989 /* The kind-of-variable letter depends on where
1990 the variable is and on the scope of its name:
1991 G and N_GSYM for static storage and global scope,
1992 S for static storage and file scope,
1993 V for static storage and local scope,
1994 for those two, use N_LCSYM if data is in bss segment,
1995 N_STSYM if in data segment, N_FUN otherwise.
1996 (We used N_FUN originally, then changed to N_STSYM
1997 to please GDB. However, it seems that confused ld.
1998 Now GDB has been fixed to like N_FUN, says Kingdon.)
1999 no letter at all, and N_LSYM, for auto variable,
2000 r and N_RSYM for register variable. */
2002 if (GET_CODE (home
) == MEM
2003 && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2005 if (TREE_PUBLIC (decl
))
2008 current_sym_code
= N_GSYM
;
2012 current_sym_addr
= XEXP (home
, 0);
2014 letter
= decl_function_context (decl
) ? 'V' : 'S';
2016 /* This should be the same condition as in assemble_variable, but
2017 we don't have access to dont_output_data here. So, instead,
2018 we rely on the fact that error_mark_node initializers always
2019 end up in bss for C++ and never end up in bss for C. */
2020 if (DECL_INITIAL (decl
) == 0
2021 || (!strcmp (lang_identify (), "cplusplus")
2022 && DECL_INITIAL (decl
) == error_mark_node
))
2023 current_sym_code
= N_LCSYM
;
2024 else if (DECL_IN_TEXT_SECTION (decl
))
2025 /* This is not quite right, but it's the closest
2026 of all the codes that Unix defines. */
2027 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
2030 /* Ultrix `as' seems to need this. */
2031 #ifdef DBX_STATIC_STAB_DATA_SECTION
2034 current_sym_code
= N_STSYM
;
2038 else if (regno
>= 0)
2041 current_sym_code
= N_RSYM
;
2042 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
2044 else if (GET_CODE (home
) == MEM
2045 && (GET_CODE (XEXP (home
, 0)) == MEM
2046 || (GET_CODE (XEXP (home
, 0)) == REG
2047 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
2048 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
2049 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2050 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
2053 /* If the value is indirect by memory or by a register
2054 that isn't the frame pointer
2055 then it means the object is variable-sized and address through
2056 that register or stack slot. DBX has no way to represent this
2057 so all we can do is output the variable as a pointer.
2058 If it's not a parameter, ignore it.
2059 (VAR_DECLs like this can be made by integrate.c.) */
2061 if (GET_CODE (XEXP (home
, 0)) == REG
)
2064 current_sym_code
= N_RSYM
;
2065 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
2069 current_sym_code
= N_LSYM
;
2070 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2071 We want the value of that CONST_INT. */
2073 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
2076 /* Effectively do build_pointer_type, but don't cache this type,
2077 since it might be temporary whereas the type it points to
2078 might have been saved for inlining. */
2079 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2080 type
= make_node (POINTER_TYPE
);
2081 TREE_TYPE (type
) = TREE_TYPE (decl
);
2083 else if (GET_CODE (home
) == MEM
2084 && GET_CODE (XEXP (home
, 0)) == REG
)
2086 current_sym_code
= N_LSYM
;
2087 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2089 else if (GET_CODE (home
) == MEM
2090 && GET_CODE (XEXP (home
, 0)) == PLUS
2091 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
2093 current_sym_code
= N_LSYM
;
2094 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2095 We want the value of that CONST_INT. */
2096 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2098 else if (GET_CODE (home
) == MEM
2099 && GET_CODE (XEXP (home
, 0)) == CONST
)
2101 /* Handle an obscure case which can arise when optimizing and
2102 when there are few available registers. (This is *always*
2103 the case for i386/i486 targets). The RTL looks like
2104 (MEM (CONST ...)) even though this variable is a local `auto'
2105 or a local `register' variable. In effect, what has happened
2106 is that the reload pass has seen that all assignments and
2107 references for one such a local variable can be replaced by
2108 equivalent assignments and references to some static storage
2109 variable, thereby avoiding the need for a register. In such
2110 cases we're forced to lie to debuggers and tell them that
2111 this variable was itself `static'. */
2112 current_sym_code
= N_LCSYM
;
2114 current_sym_addr
= XEXP (XEXP (home
, 0), 0);
2116 else if (GET_CODE (home
) == CONCAT
)
2120 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
2121 for example), then there is no easy way to figure out
2122 what SUBTYPE should be. So, we give up. */
2123 if (TREE_CODE (type
) != COMPLEX_TYPE
)
2126 subtype
= TREE_TYPE (type
);
2128 /* If the variable's storage is in two parts,
2129 output each as a separate stab with a modified name. */
2130 if (WORDS_BIG_ENDIAN
)
2131 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
2133 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
2135 /* Cast avoids warning in old compilers. */
2136 current_sym_code
= (STAB_CODE_TYPE
) 0;
2137 current_sym_value
= 0;
2138 current_sym_addr
= 0;
2139 dbxout_prepare_symbol (decl
);
2141 if (WORDS_BIG_ENDIAN
)
2142 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
2144 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
2148 /* Address might be a MEM, when DECL is a variable-sized object.
2149 Or it might be const0_rtx, meaning previous passes
2150 want us to ignore this variable. */
2153 /* Ok, start a symtab entry and output the variable name. */
2156 #ifdef DBX_STATIC_BLOCK_START
2157 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
2160 dbxout_symbol_name (decl
, suffix
, letter
);
2161 dbxout_type (type
, 0);
2162 dbxout_finish_symbol (decl
);
2164 #ifdef DBX_STATIC_BLOCK_END
2165 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
2170 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2171 Then output LETTER to indicate the kind of location the symbol has. */
2174 dbxout_symbol_name (decl
, suffix
, letter
)
2181 if (DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
)))
2182 /* One slight hitch: if this is a VAR_DECL which is a static
2183 class member, we must put out the mangled name instead of the
2184 DECL_NAME. Note also that static member (variable) names DO NOT begin
2185 with underscores in .stabs directives. */
2186 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2188 /* ...but if we're function-local, we don't want to include the junk
2189 added by ASM_FORMAT_PRIVATE_NAME. */
2190 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
2194 fprintf (asmfile
, "%s\"%s%s:", ASM_STABS_OP
, name
,
2195 (suffix
? suffix
: ""));
2197 if (letter
) putc (letter
, asmfile
);
2201 dbxout_prepare_symbol (decl
)
2202 tree decl ATTRIBUTE_UNUSED
;
2205 const char *filename
= DECL_SOURCE_FILE (decl
);
2207 dbxout_source_file (asmfile
, filename
);
2212 dbxout_finish_symbol (sym
)
2215 #ifdef DBX_FINISH_SYMBOL
2216 DBX_FINISH_SYMBOL (sym
);
2219 if (use_gnu_debug_info_extensions
&& sym
!= 0)
2220 line
= DECL_SOURCE_LINE (sym
);
2222 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
2223 if (current_sym_addr
)
2224 output_addr_const (asmfile
, current_sym_addr
);
2226 fprintf (asmfile
, "%d", current_sym_value
);
2227 putc ('\n', asmfile
);
2231 /* Output definitions of all the decls in a chain. Return non-zero if
2232 anything was output */
2241 result
+= dbxout_symbol (syms
, 1);
2242 syms
= TREE_CHAIN (syms
);
2247 /* The following two functions output definitions of function parameters.
2248 Each parameter gets a definition locating it in the parameter list.
2249 Each parameter that is a register variable gets a second definition
2250 locating it in the register.
2252 Printing or argument lists in gdb uses the definitions that
2253 locate in the parameter list. But reference to the variable in
2254 expressions uses preferentially the definition as a register. */
2256 /* Output definitions, referring to storage in the parmlist,
2257 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2260 dbxout_parms (parms
)
2263 for (; parms
; parms
= TREE_CHAIN (parms
))
2264 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
2266 dbxout_prepare_symbol (parms
);
2268 /* Perform any necessary register eliminations on the parameter's rtl,
2269 so that the debugging output will be accurate. */
2270 DECL_INCOMING_RTL (parms
)
2271 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
2272 SET_DECL_RTL (parms
, eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
));
2273 #ifdef LEAF_REG_REMAP
2274 if (current_function_uses_only_leaf_regs
)
2276 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
2277 leaf_renumber_regs_insn (DECL_RTL (parms
));
2281 if (PARM_PASSED_IN_MEMORY (parms
))
2283 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
2285 /* ??? Here we assume that the parm address is indexed
2286 off the frame pointer or arg pointer.
2287 If that is not true, we produce meaningless results,
2288 but do not crash. */
2289 if (GET_CODE (addr
) == PLUS
2290 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
2291 current_sym_value
= INTVAL (XEXP (addr
, 1));
2293 current_sym_value
= 0;
2295 current_sym_code
= N_PSYM
;
2296 current_sym_addr
= 0;
2299 if (DECL_NAME (parms
))
2301 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2303 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2304 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2305 DBX_MEMPARM_STABS_LETTER
);
2309 current_sym_nchars
= 8;
2310 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2311 DBX_MEMPARM_STABS_LETTER
);
2314 /* It is quite tempting to use:
2316 dbxout_type (TREE_TYPE (parms), 0);
2318 as the next statement, rather than using DECL_ARG_TYPE(), so
2319 that gcc reports the actual type of the parameter, rather
2320 than the promoted type. This certainly makes GDB's life
2321 easier, at least for some ports. The change is a bad idea
2322 however, since GDB expects to be able access the type without
2323 performing any conversions. So for example, if we were
2324 passing a float to an unprototyped function, gcc will store a
2325 double on the stack, but if we emit a stab saying the type is a
2326 float, then gdb will only read in a single value, and this will
2327 produce an erropneous value. */
2328 dbxout_type (DECL_ARG_TYPE (parms
), 0);
2329 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
2330 dbxout_finish_symbol (parms
);
2332 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
2335 char regparm_letter
;
2337 /* Parm passed in registers and lives in registers or nowhere. */
2339 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2340 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2341 current_sym_addr
= 0;
2343 /* If parm lives in a register, use that register;
2344 pretend the parm was passed there. It would be more consistent
2345 to describe the register where the parm was passed,
2346 but in practice that register usually holds something else.
2348 If we use DECL_RTL, then we must use the declared type of
2349 the variable, not the type that it arrived in. */
2350 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2352 best_rtl
= DECL_RTL (parms
);
2353 parm_type
= TREE_TYPE (parms
);
2355 /* If the parm lives nowhere, use the register where it was
2356 passed. It is also better to use the declared type here. */
2359 best_rtl
= DECL_INCOMING_RTL (parms
);
2360 parm_type
= TREE_TYPE (parms
);
2362 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
2365 if (DECL_NAME (parms
))
2367 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2368 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2369 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2374 current_sym_nchars
= 8;
2375 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2379 dbxout_type (parm_type
, 0);
2380 dbxout_finish_symbol (parms
);
2382 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2383 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
2384 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
2385 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
2386 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2387 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
2391 /* Parm was passed via invisible reference.
2392 That is, its address was passed in a register.
2393 Output it as if it lived in that register.
2394 The debugger will know from the type
2395 that it was actually passed by invisible reference. */
2397 char regparm_letter
;
2398 /* Parm passed in registers and lives in registers or nowhere. */
2400 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2401 if (use_gnu_debug_info_extensions
)
2402 regparm_letter
= GDB_INV_REF_REGPARM_STABS_LETTER
;
2404 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2406 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2407 If it is an unallocated pseudo-reg, then use the register where
2408 it was passed instead. */
2409 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
2410 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
2412 current_sym_value
= REGNO (DECL_INCOMING_RTL (parms
));
2414 current_sym_addr
= 0;
2417 if (DECL_NAME (parms
))
2419 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2421 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2422 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2427 current_sym_nchars
= 8;
2428 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2432 dbxout_type (TREE_TYPE (parms
), 0);
2433 dbxout_finish_symbol (parms
);
2435 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2436 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
2438 /* Parm was passed via invisible reference, with the reference
2439 living on the stack. DECL_RTL looks like
2440 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
2441 could look like (MEM (MEM (REG))). */
2442 const char *decl_name
= (DECL_NAME (parms
)
2443 ? IDENTIFIER_POINTER (DECL_NAME (parms
))
2445 if (GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 0)) == REG
)
2446 current_sym_value
= 0;
2449 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
2450 current_sym_addr
= 0;
2453 fprintf (asmfile
, "%s\"%s:v", ASM_STABS_OP
, decl_name
);
2454 dbxout_type (TREE_TYPE (parms
), 0);
2455 dbxout_finish_symbol (parms
);
2457 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2458 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
2459 /* ??? A constant address for a parm can happen
2460 when the reg it lives in is equiv to a constant in memory.
2461 Should make this not happen, after 2.4. */
2462 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
2464 /* Parm was passed in registers but lives on the stack. */
2466 current_sym_code
= N_PSYM
;
2467 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2468 in which case we want the value of that CONST_INT,
2470 in which case we use a value of zero. */
2471 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
)
2472 current_sym_value
= 0;
2475 = INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
2477 current_sym_addr
= 0;
2479 /* Make a big endian correction if the mode of the type of the
2480 parameter is not the same as the mode of the rtl. */
2481 if (BYTES_BIG_ENDIAN
2482 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
2483 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
2485 current_sym_value
+=
2486 GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
2487 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
)));
2491 if (DECL_NAME (parms
))
2494 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2496 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2497 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2498 DBX_MEMPARM_STABS_LETTER
);
2502 current_sym_nchars
= 8;
2503 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2504 DBX_MEMPARM_STABS_LETTER
);
2508 = DEBUGGER_ARG_OFFSET (current_sym_value
,
2509 XEXP (DECL_RTL (parms
), 0));
2510 dbxout_type (TREE_TYPE (parms
), 0);
2511 dbxout_finish_symbol (parms
);
2516 /* Output definitions for the places where parms live during the function,
2517 when different from where they were passed, when the parms were passed
2520 It is not useful to do this for parms passed in registers
2521 that live during the function in different registers, because it is
2522 impossible to look in the passed register for the passed value,
2523 so we use the within-the-function register to begin with.
2525 PARMS is a chain of PARM_DECL nodes. */
2528 dbxout_reg_parms (parms
)
2531 for (; parms
; parms
= TREE_CHAIN (parms
))
2532 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
2534 dbxout_prepare_symbol (parms
);
2536 /* Report parms that live in registers during the function
2537 but were passed in memory. */
2538 if (GET_CODE (DECL_RTL (parms
)) == REG
2539 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2540 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2541 0, DECL_RTL (parms
));
2542 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
2543 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2544 0, DECL_RTL (parms
));
2545 /* Report parms that live in memory but not where they were passed. */
2546 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2547 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
2548 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2549 0, DECL_RTL (parms
));
2553 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2554 output definitions of those names, in raw form */
2562 putc (',', asmfile
);
2563 dbxout_type (TREE_VALUE (args
), 0);
2565 args
= TREE_CHAIN (args
);
2569 /* Given a chain of ..._TYPE nodes,
2570 find those which have typedef names and output those names.
2571 This is to ensure those types get output. */
2574 dbxout_types (types
)
2575 register tree types
;
2579 if (TYPE_NAME (types
)
2580 && TREE_CODE (TYPE_NAME (types
)) == TYPE_DECL
2581 && ! TREE_ASM_WRITTEN (TYPE_NAME (types
)))
2582 dbxout_symbol (TYPE_NAME (types
), 1);
2583 types
= TREE_CHAIN (types
);
2587 /* Output everything about a symbol block (a BLOCK node
2588 that represents a scope level),
2589 including recursive output of contained blocks.
2591 BLOCK is the BLOCK node.
2592 DEPTH is its depth within containing symbol blocks.
2593 ARGS is usually zero; but for the outermost block of the
2594 body of a function, it is a chain of PARM_DECLs for the function parameters.
2595 We output definitions of all the register parms
2596 as if they were local variables of that block.
2598 If -g1 was used, we count blocks just the same, but output nothing
2599 except for the outermost block.
2601 Actually, BLOCK may be several blocks chained together.
2602 We handle them all in sequence. */
2605 dbxout_block (block
, depth
, args
)
2606 register tree block
;
2612 #if DBX_BLOCKS_FUNCTION_RELATIVE
2613 const char *begin_label
;
2614 if (current_function_func_begin_label
!= NULL_TREE
)
2615 begin_label
= IDENTIFIER_POINTER (current_function_func_begin_label
);
2617 begin_label
= XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0);
2622 /* Ignore blocks never expanded or otherwise marked as real. */
2623 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
2627 #ifdef DBX_LBRAC_FIRST
2630 /* In dbx format, the syms of a block come before the N_LBRAC.
2631 If nothing is output, we don't need the N_LBRAC, either. */
2633 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2634 did_output
= dbxout_syms (BLOCK_VARS (block
));
2636 dbxout_reg_parms (args
);
2639 /* Now output an N_LBRAC symbol to represent the beginning of
2640 the block. Use the block's tree-walk order to generate
2641 the assembler symbols LBBn and LBEn
2642 that final will define around the code in this block. */
2643 if (depth
> 0 && did_output
)
2646 blocknum
= BLOCK_NUMBER (block
);
2647 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
2649 if (BLOCK_HANDLER_BLOCK (block
))
2651 /* A catch block. Must precede N_LBRAC. */
2652 tree decl
= BLOCK_VARS (block
);
2655 #ifdef DBX_OUTPUT_CATCH
2656 DBX_OUTPUT_CATCH (asmfile
, decl
, buf
);
2658 fprintf (asmfile
, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP
,
2659 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
2660 assemble_name (asmfile
, buf
);
2661 fprintf (asmfile
, "\n");
2663 decl
= TREE_CHAIN (decl
);
2667 #ifdef DBX_OUTPUT_LBRAC
2668 DBX_OUTPUT_LBRAC (asmfile
, buf
);
2670 fprintf (asmfile
, "%s%d,0,0,", ASM_STABN_OP
, N_LBRAC
);
2671 assemble_name (asmfile
, buf
);
2672 #if DBX_BLOCKS_FUNCTION_RELATIVE
2673 fputc ('-', asmfile
);
2674 assemble_name (asmfile
, begin_label
);
2676 fprintf (asmfile
, "\n");
2680 #ifdef DBX_LBRAC_FIRST
2681 /* On some weird machines, the syms of a block
2682 come after the N_LBRAC. */
2683 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2684 dbxout_syms (BLOCK_VARS (block
));
2686 dbxout_reg_parms (args
);
2689 /* Output the subblocks. */
2690 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
2692 /* Refer to the marker for the end of the block. */
2693 if (depth
> 0 && did_output
)
2696 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
2697 #ifdef DBX_OUTPUT_RBRAC
2698 DBX_OUTPUT_RBRAC (asmfile
, buf
);
2700 fprintf (asmfile
, "%s%d,0,0,", ASM_STABN_OP
, N_RBRAC
);
2701 assemble_name (asmfile
, buf
);
2702 #if DBX_BLOCKS_FUNCTION_RELATIVE
2703 fputc ('-', asmfile
);
2704 assemble_name (asmfile
, begin_label
);
2706 fprintf (asmfile
, "\n");
2710 block
= BLOCK_CHAIN (block
);
2714 /* Output the information about a function and its arguments and result.
2715 Usually this follows the function's code,
2716 but on some systems, it comes before. */
2719 dbxout_really_begin_function (decl
)
2722 dbxout_symbol (decl
, 0);
2723 dbxout_parms (DECL_ARGUMENTS (decl
));
2724 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
2725 dbxout_symbol (DECL_RESULT (decl
), 1);
2728 /* Called at beginning of output of function definition. */
2731 dbxout_begin_function (decl
)
2732 tree decl ATTRIBUTE_UNUSED
;
2734 #ifdef DBX_FUNCTION_FIRST
2735 dbxout_really_begin_function (decl
);
2739 /* Output dbx data for a function definition.
2740 This includes a definition of the function name itself (a symbol),
2741 definitions of the parameters (locating them in the parameter list)
2742 and then output the block that makes up the function's body
2743 (including all the auto variables of the function). */
2746 dbxout_function (decl
)
2749 #ifndef DBX_FUNCTION_FIRST
2750 dbxout_really_begin_function (decl
);
2752 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
2753 #ifdef DBX_OUTPUT_FUNCTION_END
2754 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
2756 #if defined(ASM_OUTPUT_SECTION_NAME)
2757 if (use_gnu_debug_info_extensions
2758 #if defined(NO_DBX_FUNCTION_END)
2759 && ! NO_DBX_FUNCTION_END
2762 dbxout_function_end ();
2765 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */