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 ((unsigned int, const char *));
292 static void dbxout_source_file
PARAMS ((FILE *, const char *));
293 #if defined(ASM_OUTPUT_SECTION_NAME)
294 static void dbxout_function_end
PARAMS ((void));
296 static void dbxout_typedefs
PARAMS ((tree
));
297 static void dbxout_type_index
PARAMS ((tree
));
298 #if DBX_CONTIN_LENGTH > 0
299 static void dbxout_continue
PARAMS ((void));
301 static void dbxout_args
PARAMS ((tree
));
302 static void dbxout_type_fields
PARAMS ((tree
));
303 static void dbxout_type_method_1
PARAMS ((tree
, const char *));
304 static void dbxout_type_methods
PARAMS ((tree
));
305 static void dbxout_range_type
PARAMS ((tree
));
306 static void dbxout_type
PARAMS ((tree
, int));
307 static void print_int_cst_octal
PARAMS ((tree
));
308 static void print_octal
PARAMS ((unsigned HOST_WIDE_INT
, int));
309 static void dbxout_type_name
PARAMS ((tree
));
310 static int dbxout_symbol_location
PARAMS ((tree
, tree
, const char *, rtx
));
311 static void dbxout_symbol_name
PARAMS ((tree
, const char *, int));
312 static void dbxout_prepare_symbol
PARAMS ((tree
));
313 static void dbxout_finish_symbol
PARAMS ((tree
));
314 static void dbxout_block
PARAMS ((tree
, int, tree
));
315 static void dbxout_begin_function
PARAMS ((tree
));
316 static void dbxout_global_decl
PARAMS ((tree
));
318 /* The debug hooks structure. */
319 #if defined (DBX_DEBUGGING_INFO)
321 static void dbxout_begin_block
PARAMS ((unsigned, unsigned));
322 static void dbxout_end_block
PARAMS ((unsigned, unsigned));
323 static void dbxout_function_decl
PARAMS ((tree
));
325 struct gcc_debug_hooks dbx_debug_hooks
=
329 debug_nothing_int_charstar
,
330 debug_nothing_int_charstar
,
331 dbxout_start_source_file
,
332 dbxout_end_source_file
,
335 debug_true_tree
, /* ignore_block */
336 dbxout_source_line
, /* source_line */
337 dbxout_source_line
, /* begin_prologue: just output line info */
338 debug_nothing_int
, /* end_prologue */
339 debug_nothing_void
, /* end_epilogue */
340 #ifdef DBX_FUNCTION_FIRST
341 dbxout_begin_function
,
343 debug_nothing_tree
, /* begin_function */
345 debug_nothing_int
, /* end_function */
346 dbxout_function_decl
,
347 dbxout_global_decl
, /* global_decl */
348 debug_nothing_tree
, /* deferred_inline_function */
349 debug_nothing_tree
, /* outlining_inline_function */
350 debug_nothing_rtx
/* label */
352 #endif /* DBX_DEBUGGING_INFO */
354 #if defined (XCOFF_DEBUGGING_INFO)
355 struct gcc_debug_hooks xcoff_debug_hooks
=
359 debug_nothing_int_charstar
,
360 debug_nothing_int_charstar
,
361 dbxout_start_source_file
,
362 dbxout_end_source_file
,
363 xcoffout_begin_block
,
365 debug_true_tree
, /* ignore_block */
366 xcoffout_source_line
,
367 xcoffout_begin_prologue
, /* begin_prologue */
368 debug_nothing_int
, /* end_prologue */
369 xcoffout_end_epilogue
,
370 debug_nothing_tree
, /* begin_function */
371 xcoffout_end_function
,
372 debug_nothing_tree
, /* function_decl */
373 dbxout_global_decl
, /* global_decl */
374 debug_nothing_tree
, /* deferred_inline_function */
375 debug_nothing_tree
, /* outlining_inline_function */
376 debug_nothing_rtx
/* label */
378 #endif /* XCOFF_DEBUGGING_INFO */
380 #if defined(ASM_OUTPUT_SECTION_NAME)
382 dbxout_function_end ()
384 static int scope_labelno
= 0;
385 char lscope_label_name
[100];
386 /* Convert Ltext into the appropriate format for local labels in case
387 the system doesn't insert underscores in front of user generated
389 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
390 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Lscope", scope_labelno
);
393 /* By convention, GCC will mark the end of a function with an N_FUN
394 symbol and an empty string. */
395 fprintf (asmfile
, "%s\"\",%d,0,0,", ASM_STABS_OP
, N_FUN
);
396 assemble_name (asmfile
, lscope_label_name
);
397 fputc ('-', asmfile
);
398 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
399 fprintf (asmfile
, "\n");
401 #endif /* ! NO_DBX_FUNCTION_END */
403 /* At the beginning of compilation, start writing the symbol table.
404 Initialize `typevec' and output the standard data types of C. */
407 dbxout_init (input_file_name
)
408 const char *input_file_name
;
410 char ltext_label_name
[100];
411 tree syms
= getdecls ();
413 asmfile
= asm_out_file
;
416 typevec
= (struct typeinfo
*) xcalloc (typevec_len
, sizeof typevec
[0]);
418 /* Convert Ltext into the appropriate format for local labels in case
419 the system doesn't insert underscores in front of user generated
421 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
423 /* Put the current working directory in an N_SO symbol. */
424 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
425 but GDB always does. */
426 if (use_gnu_debug_info_extensions
)
429 if (!cwd
&& (cwd
= getpwd ()) && (!*cwd
|| cwd
[strlen (cwd
) - 1] != '/'))
430 cwd
= concat (cwd
, FILE_NAME_JOINER
, NULL
);
433 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
434 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile
, cwd
);
435 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
436 fprintf (asmfile
, "%s", ASM_STABS_OP
);
437 output_quoted_string (asmfile
, cwd
);
438 fprintf (asmfile
, ",%d,0,0,%s\n", N_SO
, <ext_label_name
[1]);
439 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
443 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
444 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
445 would give us an N_SOL, and we want an N_SO. */
446 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile
, input_file_name
);
447 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
448 /* We include outputting `Ltext:' here,
449 because that gives you a way to override it. */
450 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
451 fprintf (asmfile
, "%s", ASM_STABS_OP
);
452 output_quoted_string (asmfile
, input_file_name
);
453 fprintf (asmfile
, ",%d,0,0,%s\n",
454 N_SO
, <ext_label_name
[1]);
456 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Ltext", 0);
457 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
459 #ifdef DBX_OUTPUT_GCC_MARKER
460 DBX_OUTPUT_GCC_MARKER (asmfile
);
462 /* Emit an N_OPT stab to indicate that this file was compiled by GCC. */
463 fprintf (asmfile
, "%s\"%s\",%d,0,0,0\n",
464 ASM_STABS_OP
, STABS_GCC_MARKER
, N_OPT
);
467 lastfile
= input_file_name
;
469 next_type_number
= 1;
472 current_file
= (struct dbx_file
*) xmalloc (sizeof *current_file
);
473 current_file
->next
= NULL
;
474 current_file
->file_number
= 0;
475 current_file
->next_type_number
= 1;
476 next_file_number
= 1;
479 /* Make sure that types `int' and `char' have numbers 1 and 2.
480 Definitions of other integer types will refer to those numbers.
481 (Actually it should no longer matter what their numbers are.
482 Also, if any types with tags have been defined, dbxout_symbol
483 will output them first, so the numbers won't be 1 and 2. That
484 happens in C++. So it's a good thing it should no longer matter). */
486 #ifdef DBX_OUTPUT_STANDARD_TYPES
487 DBX_OUTPUT_STANDARD_TYPES (syms
);
489 dbxout_symbol (TYPE_NAME (integer_type_node
), 0);
490 dbxout_symbol (TYPE_NAME (char_type_node
), 0);
493 /* Get all permanent types that have typedef names,
494 and output them all, except for those already output. */
496 dbxout_typedefs (syms
);
499 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
500 in the reverse order from that which is found in SYMS. */
503 dbxout_typedefs (syms
)
508 dbxout_typedefs (TREE_CHAIN (syms
));
509 if (TREE_CODE (syms
) == TYPE_DECL
)
511 tree type
= TREE_TYPE (syms
);
513 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
514 && COMPLETE_TYPE_P (type
)
515 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
516 dbxout_symbol (TYPE_NAME (type
), 0);
521 /* Change to reading from a new source file. Generate a N_BINCL stab. */
524 dbxout_start_source_file (line
, filename
)
525 unsigned int line ATTRIBUTE_UNUSED
;
526 const char *filename ATTRIBUTE_UNUSED
;
529 struct dbx_file
*n
= (struct dbx_file
*) xmalloc (sizeof *n
);
531 n
->next
= current_file
;
532 n
->file_number
= next_file_number
++;
533 n
->next_type_number
= 1;
535 fprintf (asmfile
, "%s", ASM_STABS_OP
);
536 output_quoted_string (asmfile
, filename
);
537 fprintf (asmfile
, ",%d,0,0,0\n", N_BINCL
);
541 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
544 dbxout_end_source_file (line
)
545 unsigned int line ATTRIBUTE_UNUSED
;
548 struct dbx_file
*next
;
550 fprintf (asmfile
, "%s%d,0,0,0\n", ASM_STABN_OP
, N_EINCL
);
551 next
= current_file
->next
;
557 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
560 dbxout_source_file (file
, filename
)
562 const char *filename
;
564 char ltext_label_name
[100];
566 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
568 #ifdef DBX_OUTPUT_SOURCE_FILENAME
569 DBX_OUTPUT_SOURCE_FILENAME (file
, filename
);
571 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext",
572 source_label_number
);
573 fprintf (file
, "%s", ASM_STABS_OP
);
574 output_quoted_string (file
, filename
);
575 fprintf (file
, ",%d,0,0,%s\n", N_SOL
, <ext_label_name
[1]);
576 if (current_function_decl
!= NULL_TREE
577 && DECL_SECTION_NAME (current_function_decl
) != NULL_TREE
)
578 ; /* Don't change section amid function. */
581 ASM_OUTPUT_INTERNAL_LABEL (file
, "Ltext", source_label_number
);
582 source_label_number
++;
588 /* Output a line number symbol entry for source file FILENAME and line
592 dbxout_source_line (lineno
, filename
)
594 const char *filename
;
596 dbxout_source_file (asmfile
, filename
);
598 #ifdef ASM_OUTPUT_SOURCE_LINE
599 ASM_OUTPUT_SOURCE_LINE (asmfile
, lineno
);
601 fprintf (asmfile
, "%s%d,0,%d\n", ASM_STABD_OP
, N_SLINE
, lineno
);
605 #if defined (DBX_DEBUGGING_INFO)
607 /* Describe the beginning of an internal block within a function. */
610 dbxout_begin_block (line
, n
)
611 unsigned int line ATTRIBUTE_UNUSED
;
614 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "LBB", n
);
617 /* Describe the end line-number of an internal block within a function. */
620 dbxout_end_block (line
, n
)
621 unsigned int line ATTRIBUTE_UNUSED
;
624 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "LBE", n
);
627 /* Debug information for a global DECL. Called from toplev.c after
628 compilation proper has finished. */
630 dbxout_global_decl (decl
)
633 dbxout_symbol (decl
, 0);
636 /* Output dbx data for a function definition.
637 This includes a definition of the function name itself (a symbol),
638 definitions of the parameters (locating them in the parameter list)
639 and then output the block that makes up the function's body
640 (including all the auto variables of the function). */
643 dbxout_function_decl (decl
)
646 #ifndef DBX_FUNCTION_FIRST
647 dbxout_begin_function (decl
);
649 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
650 #ifdef DBX_OUTPUT_FUNCTION_END
651 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
653 #if defined(ASM_OUTPUT_SECTION_NAME)
654 if (use_gnu_debug_info_extensions
655 #if defined(NO_DBX_FUNCTION_END)
656 && ! NO_DBX_FUNCTION_END
659 dbxout_function_end ();
663 #endif /* DBX_DEBUGGING_INFO */
665 /* At the end of compilation, finish writing the symbol table.
666 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
670 dbxout_finish (filename
)
671 const char *filename ATTRIBUTE_UNUSED
;
673 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
674 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asmfile
, filename
);
675 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
678 /* Output the index of a type. */
681 dbxout_type_index (type
)
684 #ifndef DBX_USE_BINCL
685 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
688 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
689 fprintf (asmfile
, "(%d,%d)", t
->file_number
, t
->type_number
);
694 #if DBX_CONTIN_LENGTH > 0
695 /* Continue a symbol-description that gets too big.
696 End one symbol table entry with a double-backslash
697 and start a new one, eventually producing something like
698 .stabs "start......\\",code,0,value
699 .stabs "...rest",code,0,value */
704 #ifdef DBX_CONTIN_CHAR
705 fprintf (asmfile
, "%c", DBX_CONTIN_CHAR
);
707 fprintf (asmfile
, "\\\\");
709 dbxout_finish_symbol (NULL_TREE
);
710 fprintf (asmfile
, "%s\"", ASM_STABS_OP
);
711 current_sym_nchars
= 0;
713 #endif /* DBX_CONTIN_LENGTH > 0 */
715 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
716 This must be a separate function because anonymous unions require
720 dbxout_type_fields (type
)
725 /* Output the name, type, position (in bits), size (in bits) of each
726 field that we can support. */
727 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
729 /* Omit here local type decls until we know how to support them. */
730 if (TREE_CODE (tem
) == TYPE_DECL
731 /* Omit fields whose position or size are variable or too large to
733 || (TREE_CODE (tem
) == FIELD_DECL
734 && (! host_integerp (bit_position (tem
), 0)
736 || ! host_integerp (DECL_SIZE (tem
), 1)))
737 /* Omit here the nameless fields that are used to skip bits. */
738 || DECL_IGNORED_P (tem
))
741 else if (TREE_CODE (tem
) != CONST_DECL
)
743 /* Continue the line if necessary,
744 but not before the first field. */
745 if (tem
!= TYPE_FIELDS (type
))
750 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem
)));
751 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem
)));
755 fprintf (asmfile
, ":");
759 if (use_gnu_debug_info_extensions
760 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
761 || TREE_CODE (tem
) != FIELD_DECL
))
763 have_used_extensions
= 1;
765 putc ((TREE_PRIVATE (tem
) ? '0'
766 : TREE_PROTECTED (tem
) ? '1' : '2'),
771 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
772 && DECL_BIT_FIELD_TYPE (tem
))
773 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0);
775 if (TREE_CODE (tem
) == VAR_DECL
)
777 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
780 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
));
781 have_used_extensions
= 1;
782 fprintf (asmfile
, ":%s;", name
);
783 CHARS (strlen (name
));
786 /* If TEM is non-static, GDB won't understand it. */
787 fprintf (asmfile
, ",0,0;");
791 fputc (',', asmfile
);
792 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
793 int_bit_position (tem
));
794 fputc (',', asmfile
);
795 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
796 tree_low_cst (DECL_SIZE (tem
), 1));
797 fputc (';', asmfile
);
804 /* Subroutine of `dbxout_type_methods'. Output debug info about the
805 method described DECL. DEBUG_NAME is an encoding of the method's
806 type signature. ??? We may be able to do without DEBUG_NAME altogether
810 dbxout_type_method_1 (decl
, debug_name
)
812 const char *debug_name
;
816 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
818 else /* it's a METHOD_TYPE. */
820 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
821 /* A for normal functions.
822 B for `const' member functions.
823 C for `volatile' member functions.
824 D for `const volatile' member functions. */
825 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
827 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
830 if (DECL_VINDEX (decl
))
836 fprintf (asmfile
, ":%s;%c%c%c", debug_name
,
837 TREE_PRIVATE (decl
) ? '0'
838 : TREE_PROTECTED (decl
) ? '1' : '2', c1
, c2
);
839 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
)) + 6
840 - (debug_name
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
842 if (DECL_VINDEX (decl
) && host_integerp (DECL_VINDEX (decl
), 0))
844 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
845 tree_low_cst (DECL_VINDEX (decl
), 0));
846 fputc (';', asmfile
);
847 dbxout_type (DECL_CONTEXT (decl
), 0);
848 fprintf (asmfile
, ";");
853 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
857 dbxout_type_methods (type
)
860 /* C++: put out the method names and their parameter lists */
861 tree methods
= TYPE_METHODS (type
);
863 register tree fndecl
;
865 char formatted_type_identifier_length
[16];
866 register int type_identifier_length
;
868 if (methods
== NULL_TREE
)
871 type_encoding
= DECL_NAME (TYPE_NAME (type
));
874 /* C++: Template classes break some assumptions made by this code about
875 the class names, constructor names, and encodings for assembler
876 label names. For now, disable output of dbx info for them. */
878 const char *ptr
= IDENTIFIER_POINTER (type_encoding
);
879 /* This should use index. (mrs) */
880 while (*ptr
&& *ptr
!= '<') ptr
++;
891 type_identifier_length
= IDENTIFIER_LENGTH (type_encoding
);
893 sprintf (formatted_type_identifier_length
, "%d", type_identifier_length
);
895 if (TREE_CODE (methods
) != TREE_VEC
)
897 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
898 fndecl
= TREE_VEC_ELT (methods
, 0);
900 fndecl
= TREE_VEC_ELT (methods
, 1);
906 /* Group together all the methods for the same operation.
907 These differ in the types of the arguments. */
908 for (last
= NULL_TREE
;
909 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
910 fndecl
= TREE_CHAIN (fndecl
))
911 /* Output the name of the field (after overloading), as
912 well as the name of the field before overloading, along
913 with its parameter list */
915 /* This is the "mangled" name of the method.
916 It encodes the argument types. */
917 const char *debug_name
;
919 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
920 include TEMPLATE_DECLs.) The debugger doesn't know what
921 to do with such entities anyhow. */
922 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
926 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
));
932 /* Also ignore abstract methods; those are only interesting to
933 the DWARF backends. */
934 if (DECL_IGNORED_P (fndecl
) || DECL_ABSTRACT (fndecl
))
937 /* Redundantly output the plain name, since that's what gdb
941 tree name
= DECL_NAME (fndecl
);
942 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (name
));
943 CHARS (IDENTIFIER_LENGTH (name
) + 2);
947 dbxout_type (TREE_TYPE (fndecl
), 0);
949 dbxout_type_method_1 (fndecl
, debug_name
);
959 /* Emit a "range" type specification, which has the form:
960 "r<index type>;<lower bound>;<upper bound>;".
961 TYPE is an INTEGER_TYPE. */
964 dbxout_range_type (type
)
967 fprintf (asmfile
, "r");
968 if (TREE_TYPE (type
))
969 dbxout_type (TREE_TYPE (type
), 0);
970 else if (TREE_CODE (type
) != INTEGER_TYPE
)
971 dbxout_type (type
, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
974 /* Traditionally, we made sure 'int' was type 1, and builtin types
975 were defined to be sub-ranges of int. Unfortunately, this
976 does not allow us to distinguish true sub-ranges from integer
977 types. So, instead we define integer (non-sub-range) types as
978 sub-ranges of themselves. This matters for Chill. If this isn't
979 a subrange type, then we want to define it in terms of itself.
980 However, in C, this may be an anonymous integer type, and we don't
981 want to emit debug info referring to it. Just calling
982 dbxout_type_index won't work anyways, because the type hasn't been
983 defined yet. We make this work for both cases by checked to see
984 whether this is a defined type, referring to it if it is, and using
986 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
987 dbxout_type_index (type
);
989 dbxout_type_index (integer_type_node
);
992 if (TYPE_MIN_VALUE (type
) != 0
993 && host_integerp (TYPE_MIN_VALUE (type
), 0))
995 fputc (';', asmfile
);
996 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
997 tree_low_cst (TYPE_MIN_VALUE (type
), 0));
1000 fprintf (asmfile
, ";0");
1002 if (TYPE_MAX_VALUE (type
) != 0
1003 && host_integerp (TYPE_MAX_VALUE (type
), 0))
1005 fputc (';', asmfile
);
1006 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1007 tree_low_cst (TYPE_MAX_VALUE (type
), 0));
1008 fputc (';', asmfile
);
1011 fprintf (asmfile
, ";-1;");
1014 /* Output a reference to a type. If the type has not yet been
1015 described in the dbx output, output its definition now.
1016 For a type already defined, just refer to its definition
1017 using the type number.
1019 If FULL is nonzero, and the type has been described only with
1020 a forward-reference, output the definition now.
1021 If FULL is zero in this case, just refer to the forward-reference
1022 using the number previously allocated. */
1025 dbxout_type (type
, full
)
1030 static int anonymous_type_number
= 0;
1032 if (TREE_CODE (type
) == VECTOR_TYPE
)
1033 type
= TYPE_DEBUG_REPRESENTATION_TYPE (type
);
1035 /* If there was an input error and we don't really have a type,
1036 avoid crashing and write something that is at least valid
1037 by assuming `int'. */
1038 if (type
== error_mark_node
)
1039 type
= integer_type_node
;
1042 /* Try to find the "main variant" with the same name but not const
1043 or volatile. (Since stabs does not distinguish const and volatile,
1044 there is no need to make them separate types. But types with
1045 different names are usefully distinguished.) */
1047 for (tem
= TYPE_MAIN_VARIANT (type
); tem
; tem
= TYPE_NEXT_VARIANT (tem
))
1048 if (!TYPE_READONLY (tem
) && !TYPE_VOLATILE (tem
)
1049 && TYPE_NAME (tem
) == TYPE_NAME (type
))
1054 if (TYPE_NAME (type
)
1055 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1056 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1060 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1062 /* Type has no dbx number assigned. Assign next available number. */
1063 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1065 /* Make sure type vector is long enough to record about this type. */
1067 if (next_type_number
== typevec_len
)
1070 = (struct typeinfo
*) xrealloc (typevec
,
1071 typevec_len
* 2 * sizeof typevec
[0]);
1072 memset ((char *) (typevec
+ typevec_len
), 0,
1073 typevec_len
* sizeof typevec
[0]);
1077 #ifdef DBX_USE_BINCL
1078 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1079 = current_file
->file_number
;
1080 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1081 = current_file
->next_type_number
++;
1085 /* Output the number of this type, to refer to it. */
1086 dbxout_type_index (type
);
1088 #ifdef DBX_TYPE_DEFINED
1089 if (DBX_TYPE_DEFINED (type
))
1093 /* If this type's definition has been output or is now being output,
1096 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1101 /* If we have already had a cross reference,
1102 and either that's all we want or that's the best we could do,
1103 don't repeat the cross reference.
1104 Sun dbx crashes if we do. */
1105 if (! full
|| !COMPLETE_TYPE_P (type
)
1106 /* No way in DBX fmt to describe a variable size. */
1107 || ! host_integerp (TYPE_SIZE (type
), 1))
1115 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1116 leave the type-number completely undefined rather than output
1117 a cross-reference. If we have already used GNU debug info extensions,
1118 then it is OK to output a cross reference. This is necessary to get
1119 proper C++ debug output. */
1120 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1121 || TREE_CODE (type
) == QUAL_UNION_TYPE
1122 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1123 && ! use_gnu_debug_info_extensions
)
1124 /* We must use the same test here as we use twice below when deciding
1125 whether to emit a cross-reference. */
1126 if ((TYPE_NAME (type
) != 0
1127 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1128 && DECL_IGNORED_P (TYPE_NAME (type
)))
1130 || !COMPLETE_TYPE_P (type
)
1131 /* No way in DBX fmt to describe a variable size. */
1132 || ! host_integerp (TYPE_SIZE (type
), 1))
1134 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1139 /* Output a definition now. */
1141 fprintf (asmfile
, "=");
1144 /* Mark it as defined, so that if it is self-referent
1145 we will not get into an infinite recursion of definitions. */
1147 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1149 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1150 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1152 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0);
1156 switch (TREE_CODE (type
))
1160 /* For a void type, just define it as itself; ie, "5=5".
1161 This makes us consider it defined
1162 without saying what it is. The debugger will make it
1163 a void type when the reference is seen, and nothing will
1164 ever override that default. */
1165 dbxout_type_index (type
);
1169 if (type
== char_type_node
&& ! TREE_UNSIGNED (type
))
1171 /* Output the type `char' as a subrange of itself!
1172 I don't understand this definition, just copied it
1173 from the output of pcc.
1174 This used to use `r2' explicitly and we used to
1175 take care to make sure that `char' was type number 2. */
1176 fprintf (asmfile
, "r");
1177 dbxout_type_index (type
);
1178 fprintf (asmfile
, ";0;127;");
1181 /* If this is a subtype of another integer type, always prefer to
1182 write it as a subtype. */
1183 else if (TREE_TYPE (type
) != 0
1184 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
1185 dbxout_range_type (type
);
1189 /* If the size is non-standard, say what it is if we can use
1192 if (use_gnu_debug_info_extensions
1193 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1194 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1196 /* If we can use GDB extensions and the size is wider than a
1197 long (the size used by GDB to read them) or we may have
1198 trouble writing the bounds the usual way, write them in
1199 octal. Note the test is for the *target's* size of "long",
1200 not that of the host. The host test is just to make sure we
1201 can write it out in case the host wide int is narrower than the
1204 /* For unsigned types, we use octal if they are the same size or
1205 larger. This is because we print the bounds as signed decimal,
1206 and hence they can't span same size unsigned types. */
1208 if (use_gnu_debug_info_extensions
1209 && TYPE_MIN_VALUE (type
) != 0
1210 && TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
1211 && TYPE_MAX_VALUE (type
) != 0
1212 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
1213 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
1214 || ((TYPE_PRECISION (type
)
1215 == TYPE_PRECISION (integer_type_node
))
1216 && TREE_UNSIGNED (type
))
1217 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
1218 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
1219 && TREE_UNSIGNED (type
))))
1221 fprintf (asmfile
, "r");
1222 dbxout_type_index (type
);
1223 fprintf (asmfile
, ";");
1224 print_int_cst_octal (TYPE_MIN_VALUE (type
));
1225 fprintf (asmfile
, ";");
1226 print_int_cst_octal (TYPE_MAX_VALUE (type
));
1227 fprintf (asmfile
, ";");
1231 /* Output other integer types as subranges of `int'. */
1232 dbxout_range_type (type
);
1239 /* This used to say `r1' and we used to take care
1240 to make sure that `int' was type number 1. */
1241 fprintf (asmfile
, "r");
1242 dbxout_type_index (integer_type_node
);
1243 fputc (';', asmfile
);
1244 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1245 fputs (";0;", asmfile
);
1250 if (use_gnu_debug_info_extensions
)
1252 fputs ("@s", asmfile
);
1253 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1254 BITS_PER_UNIT
* int_size_in_bytes (type
));
1255 fputs (";-20;", asmfile
);
1259 /* Output the type `char' as a subrange of itself.
1260 That is what pcc seems to do. */
1261 fprintf (asmfile
, "r");
1262 dbxout_type_index (char_type_node
);
1263 fprintf (asmfile
, ";0;%d;", TREE_UNSIGNED (type
) ? 255 : 127);
1269 if (use_gnu_debug_info_extensions
)
1271 fputs ("@s", asmfile
);
1272 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1273 BITS_PER_UNIT
* int_size_in_bytes (type
));
1274 fputs (";-16;", asmfile
);
1276 else /* Define as enumeral type (False, True) */
1277 fprintf (asmfile
, "eFalse:0,True:1,;");
1282 putc ('d', asmfile
);
1284 dbxout_type (TREE_TYPE (type
), 0);
1288 /* Differs from the REAL_TYPE by its new data type number */
1290 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1292 fprintf (asmfile
, "r");
1293 dbxout_type_index (type
);
1294 fputc (';', asmfile
);
1295 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1296 2 * int_size_in_bytes (TREE_TYPE (type
)));
1297 fputs (";0;", asmfile
);
1298 CHARS (12); /* The number is probably incorrect here. */
1302 /* Output a complex integer type as a structure,
1303 pending some other way to do it. */
1304 fputc ('s', asmfile
);
1305 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1307 fprintf (asmfile
, "real:");
1309 dbxout_type (TREE_TYPE (type
), 0);
1310 fprintf (asmfile
, ",%d,%d;",
1311 0, TYPE_PRECISION (TREE_TYPE (type
)));
1313 fprintf (asmfile
, "imag:");
1315 dbxout_type (TREE_TYPE (type
), 0);
1316 fprintf (asmfile
, ",%d,%d;;",
1317 TYPE_PRECISION (TREE_TYPE (type
)),
1318 TYPE_PRECISION (TREE_TYPE (type
)));
1324 if (use_gnu_debug_info_extensions
)
1326 have_used_extensions
= 1;
1327 fputs ("@s", asmfile
);
1328 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1329 BITS_PER_UNIT
* int_size_in_bytes (type
));
1330 fputc (';', asmfile
);
1331 /* Check if a bitstring type, which in Chill is
1332 different from a [power]set. */
1333 if (TYPE_STRING_FLAG (type
))
1334 fprintf (asmfile
, "@S;");
1336 putc ('S', asmfile
);
1338 dbxout_type (TYPE_DOMAIN (type
), 0);
1342 /* Make arrays of packed bits look like bitstrings for chill. */
1343 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
1345 have_used_extensions
= 1;
1346 fputs ("@s", asmfile
);
1347 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1348 BITS_PER_UNIT
* int_size_in_bytes (type
));
1349 fputc (';', asmfile
);
1350 fprintf (asmfile
, "@S;");
1351 putc ('S', asmfile
);
1353 dbxout_type (TYPE_DOMAIN (type
), 0);
1356 /* Output "a" followed by a range type definition
1357 for the index type of the array
1358 followed by a reference to the target-type.
1359 ar1;0;N;M for a C array of type M and size N+1. */
1360 /* Check if a character string type, which in Chill is
1361 different from an array of characters. */
1362 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
1364 have_used_extensions
= 1;
1365 fprintf (asmfile
, "@S;");
1367 tem
= TYPE_DOMAIN (type
);
1370 fprintf (asmfile
, "ar");
1371 dbxout_type_index (integer_type_node
);
1372 fprintf (asmfile
, ";0;-1;");
1376 fprintf (asmfile
, "a");
1377 dbxout_range_type (tem
);
1380 dbxout_type (TREE_TYPE (type
), 0);
1385 case QUAL_UNION_TYPE
:
1387 int i
, n_baseclasses
= 0;
1389 if (TYPE_BINFO (type
) != 0
1390 && TREE_CODE (TYPE_BINFO (type
)) == TREE_VEC
1391 && TYPE_BINFO_BASETYPES (type
) != 0)
1392 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
1394 /* Output a structure type. We must use the same test here as we
1395 use in the DBX_NO_XREFS case above. */
1396 if ((TYPE_NAME (type
) != 0
1397 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1398 && DECL_IGNORED_P (TYPE_NAME (type
)))
1400 || !COMPLETE_TYPE_P (type
)
1401 /* No way in DBX fmt to describe a variable size. */
1402 || ! host_integerp (TYPE_SIZE (type
), 1))
1404 /* If the type is just a cross reference, output one
1405 and mark the type as partially described.
1406 If it later becomes defined, we will output
1407 its real definition.
1408 If the type has a name, don't nest its definition within
1409 another type's definition; instead, output an xref
1410 and let the definition come when the name is defined. */
1411 fputs ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu", asmfile
);
1413 #if 0 /* This assertion is legitimately false in C++. */
1414 /* We shouldn't be outputting a reference to a type before its
1415 definition unless the type has a tag name.
1416 A typedef name without a tag name should be impossible. */
1417 if (TREE_CODE (TYPE_NAME (type
)) != IDENTIFIER_NODE
)
1420 if (TYPE_NAME (type
) != 0)
1421 dbxout_type_name (type
);
1423 fprintf (asmfile
, "$$%d", anonymous_type_number
++);
1424 fprintf (asmfile
, ":");
1425 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1429 /* Identify record or union, and print its size. */
1430 fputc (((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u'), asmfile
);
1431 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1432 int_size_in_bytes (type
));
1434 if (use_gnu_debug_info_extensions
)
1438 have_used_extensions
= 1;
1439 fprintf (asmfile
, "!%d,", n_baseclasses
);
1443 for (i
= 0; i
< n_baseclasses
; i
++)
1445 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)), i
);
1447 if (use_gnu_debug_info_extensions
)
1449 have_used_extensions
= 1;
1450 putc (TREE_VIA_VIRTUAL (child
) ? '1' : '0', asmfile
);
1451 putc (TREE_VIA_PUBLIC (child
) ? '2' : '0', asmfile
);
1452 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1453 (tree_low_cst (BINFO_OFFSET (child
), 0)
1455 fputc (',', asmfile
);
1457 dbxout_type (BINFO_TYPE (child
), 0);
1458 putc (';', asmfile
);
1462 /* Print out the base class information with fields
1463 which have the same names at the types they hold. */
1464 dbxout_type_name (BINFO_TYPE (child
));
1465 putc (':', asmfile
);
1466 dbxout_type (BINFO_TYPE (child
), full
);
1467 fputc (',', asmfile
);
1468 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1469 tree_low_cst (BINFO_OFFSET (child
), 0)
1471 fputc (',', asmfile
);
1472 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1473 (tree_low_cst (DECL_SIZE (TYPE_NAME
1474 (BINFO_TYPE (child
))), 0)
1476 fputc (';', asmfile
);
1484 /* Write out the field declarations. */
1485 dbxout_type_fields (type
);
1486 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1488 have_used_extensions
= 1;
1489 dbxout_type_methods (type
);
1492 putc (';', asmfile
);
1494 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1495 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1496 && TYPE_VFIELD (type
))
1498 have_used_extensions
= 1;
1500 /* Tell GDB+ that it may keep reading. */
1501 putc ('~', asmfile
);
1503 /* We need to write out info about what field this class
1504 uses as its "main" vtable pointer field, because if this
1505 field is inherited from a base class, GDB cannot necessarily
1506 figure out which field it's using in time. */
1507 if (TYPE_VFIELD (type
))
1509 putc ('%', asmfile
);
1510 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0);
1512 putc (';', asmfile
);
1518 /* We must use the same test here as we use in the DBX_NO_XREFS case
1519 above. We simplify it a bit since an enum will never have a variable
1521 if ((TYPE_NAME (type
) != 0
1522 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1523 && DECL_IGNORED_P (TYPE_NAME (type
)))
1525 || !COMPLETE_TYPE_P (type
))
1527 fprintf (asmfile
, "xe");
1529 dbxout_type_name (type
);
1530 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1531 fprintf (asmfile
, ":");
1534 #ifdef DBX_OUTPUT_ENUM
1535 DBX_OUTPUT_ENUM (asmfile
, type
);
1537 if (use_gnu_debug_info_extensions
1538 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1539 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1540 putc ('e', asmfile
);
1542 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1544 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)));
1545 if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == 0)
1546 fprintf (asmfile
, HOST_WIDE_INT_PRINT_UNSIGNED
,
1547 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1548 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == -1
1549 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (TREE_VALUE (tem
)) < 0)
1550 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1551 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1553 print_int_cst_octal (TREE_VALUE (tem
));
1554 fprintf (asmfile
, ",");
1555 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)));
1556 if (TREE_CHAIN (tem
) != 0)
1561 putc (';', asmfile
);
1567 putc ('*', asmfile
);
1569 dbxout_type (TREE_TYPE (type
), 0);
1573 if (use_gnu_debug_info_extensions
)
1575 have_used_extensions
= 1;
1576 putc ('#', asmfile
);
1579 /* Write the argument types out longhand. */
1580 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0);
1581 putc (',', asmfile
);
1583 dbxout_type (TREE_TYPE (type
), 0);
1584 dbxout_args (TYPE_ARG_TYPES (type
));
1585 putc (';', asmfile
);
1590 /* Treat it as a function type. */
1591 dbxout_type (TREE_TYPE (type
), 0);
1596 if (use_gnu_debug_info_extensions
)
1598 have_used_extensions
= 1;
1599 putc ('@', asmfile
);
1601 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0);
1602 putc (',', asmfile
);
1604 dbxout_type (TREE_TYPE (type
), 0);
1608 /* Should print as an int, because it is really
1610 dbxout_type (integer_type_node
, 0);
1614 case REFERENCE_TYPE
:
1615 if (use_gnu_debug_info_extensions
)
1616 have_used_extensions
= 1;
1617 putc (use_gnu_debug_info_extensions
? '&' : '*', asmfile
);
1619 dbxout_type (TREE_TYPE (type
), 0);
1623 putc ('f', asmfile
);
1625 dbxout_type (TREE_TYPE (type
), 0);
1633 /* Print the value of integer constant C, in octal,
1634 handling double precision. */
1637 print_int_cst_octal (c
)
1640 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (c
);
1641 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (c
);
1642 int excess
= (3 - (HOST_BITS_PER_WIDE_INT
% 3));
1643 unsigned int width
= TYPE_PRECISION (TREE_TYPE (c
));
1645 /* GDB wants constants with no extra leading "1" bits, so
1646 we need to remove any sign-extension that might be
1648 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
1650 else if (width
> HOST_BITS_PER_WIDE_INT
)
1651 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
1652 else if (width
== HOST_BITS_PER_WIDE_INT
)
1655 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
1657 fprintf (asmfile
, "0");
1661 print_octal (high
, HOST_BITS_PER_WIDE_INT
/ 3);
1662 print_octal (low
, HOST_BITS_PER_WIDE_INT
/ 3);
1666 unsigned HOST_WIDE_INT beg
= high
>> excess
;
1667 unsigned HOST_WIDE_INT middle
1668 = ((high
& (((HOST_WIDE_INT
) 1 << excess
) - 1)) << (3 - excess
)
1669 | (low
>> (HOST_BITS_PER_WIDE_INT
/ 3 * 3)));
1670 unsigned HOST_WIDE_INT end
1671 = low
& (((unsigned HOST_WIDE_INT
) 1
1672 << (HOST_BITS_PER_WIDE_INT
/ 3 * 3))
1675 fprintf (asmfile
, "%o%01o", (int) beg
, (int) middle
);
1676 print_octal (end
, HOST_BITS_PER_WIDE_INT
/ 3);
1681 print_octal (value
, digits
)
1682 unsigned HOST_WIDE_INT value
;
1687 for (i
= digits
- 1; i
>= 0; i
--)
1688 fprintf (asmfile
, "%01o", (int) ((value
>> (3 * i
)) & 7));
1691 /* Output the name of type TYPE, with no punctuation.
1692 Such names can be set up either by typedef declarations
1693 or by struct, enum and union tags. */
1696 dbxout_type_name (type
)
1700 if (TYPE_NAME (type
) == 0)
1702 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
1704 t
= TYPE_NAME (type
);
1706 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1708 t
= DECL_NAME (TYPE_NAME (type
));
1713 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
1714 CHARS (IDENTIFIER_LENGTH (t
));
1717 /* Output a .stabs for the symbol defined by DECL,
1718 which must be a ..._DECL node in the normal namespace.
1719 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1720 LOCAL is nonzero if the scope is less than the entire file.
1721 Return 1 if a stabs might have been emitted. */
1724 dbxout_symbol (decl
, local
)
1726 int local ATTRIBUTE_UNUSED
;
1728 tree type
= TREE_TYPE (decl
);
1729 tree context
= NULL_TREE
;
1732 /* Cast avoids warning in old compilers. */
1733 current_sym_code
= (STAB_CODE_TYPE
) 0;
1734 current_sym_value
= 0;
1735 current_sym_addr
= 0;
1737 /* Ignore nameless syms, but don't ignore type tags. */
1739 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
1740 || DECL_IGNORED_P (decl
))
1743 dbxout_prepare_symbol (decl
);
1745 /* The output will always start with the symbol name,
1746 so always count that in the length-output-so-far. */
1748 if (DECL_NAME (decl
) != 0)
1749 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
1751 switch (TREE_CODE (decl
))
1754 /* Enum values are defined by defining the enum type. */
1758 if (DECL_RTL (decl
) == 0)
1760 if (DECL_EXTERNAL (decl
))
1762 /* Don't mention a nested function under its parent. */
1763 context
= decl_function_context (decl
);
1764 if (context
== current_function_decl
)
1766 if (GET_CODE (DECL_RTL (decl
)) != MEM
1767 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
1771 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
1772 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1773 TREE_PUBLIC (decl
) ? 'F' : 'f');
1776 current_sym_code
= N_FUN
;
1777 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1779 if (TREE_TYPE (type
))
1780 dbxout_type (TREE_TYPE (type
), 0);
1782 dbxout_type (void_type_node
, 0);
1784 /* For a nested function, when that function is compiled,
1785 mention the containing function name
1786 as well as (since dbx wants it) our own assembler-name. */
1788 fprintf (asmfile
, ",%s,%s",
1789 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1790 IDENTIFIER_POINTER (DECL_NAME (context
)));
1792 dbxout_finish_symbol (decl
);
1797 /* This seems all wrong. Outputting most kinds of types gives no name
1798 at all. A true definition gives no name; a cross-ref for a
1799 structure can give the tag name, but not a type name.
1800 It seems that no typedef name is defined by outputting a type. */
1802 /* If this typedef name was defined by outputting the type,
1803 don't duplicate it. */
1804 if (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
== TYPE_DEFINED
1805 && TYPE_NAME (TREE_TYPE (decl
)) == decl
)
1808 /* Don't output the same typedef twice.
1809 And don't output what language-specific stuff doesn't want output. */
1810 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
1819 if (DECL_NAME (decl
))
1821 /* Nonzero means we must output a tag as well as a typedef. */
1824 /* Handle the case of a C++ structure or union
1825 where the TYPE_NAME is a TYPE_DECL
1826 which gives both a typedef name and a tag. */
1827 /* dbx requires the tag first and the typedef second. */
1828 if ((TREE_CODE (type
) == RECORD_TYPE
1829 || TREE_CODE (type
) == UNION_TYPE
1830 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1831 && TYPE_NAME (type
) == decl
1832 && !(use_gnu_debug_info_extensions
&& have_used_extensions
)
1833 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
1834 /* Distinguish the implicit typedefs of C++
1835 from explicit ones that might be found in C. */
1836 && DECL_ARTIFICIAL (decl
)
1837 /* Do not generate a tag for records of variable size,
1838 since this type can not be properly described in the
1839 DBX format, and it confuses some tools such as objdump. */
1840 && host_integerp (TYPE_SIZE (type
), 1))
1842 tree name
= TYPE_NAME (type
);
1843 if (TREE_CODE (name
) == TYPE_DECL
)
1844 name
= DECL_NAME (name
);
1846 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1847 current_sym_value
= 0;
1848 current_sym_addr
= 0;
1849 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1851 fprintf (asmfile
, "%s\"%s:T", ASM_STABS_OP
,
1852 IDENTIFIER_POINTER (name
));
1853 dbxout_type (type
, 1);
1854 dbxout_finish_symbol (NULL_TREE
);
1857 /* Output typedef name. */
1858 fprintf (asmfile
, "%s\"%s:", ASM_STABS_OP
,
1859 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1861 /* Short cut way to output a tag also. */
1862 if ((TREE_CODE (type
) == RECORD_TYPE
1863 || TREE_CODE (type
) == UNION_TYPE
1864 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1865 && TYPE_NAME (type
) == decl
1866 /* Distinguish the implicit typedefs of C++
1867 from explicit ones that might be found in C. */
1868 && DECL_ARTIFICIAL (decl
))
1870 if (use_gnu_debug_info_extensions
&& have_used_extensions
)
1872 putc ('T', asmfile
);
1873 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
1875 #if 0 /* Now we generate the tag for this case up above. */
1881 putc ('t', asmfile
);
1882 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1884 dbxout_type (type
, 1);
1885 dbxout_finish_symbol (decl
);
1889 /* Don't output a tag if this is an incomplete type. This prevents
1890 the sun4 Sun OS 4.x dbx from crashing. */
1892 if (tag_needed
&& TYPE_NAME (type
) != 0
1893 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
1894 || (DECL_NAME (TYPE_NAME (type
)) != 0))
1895 && COMPLETE_TYPE_P (type
)
1896 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1898 /* For a TYPE_DECL with no name, but the type has a name,
1900 This is what represents `struct foo' with no typedef. */
1901 /* In C++, the name of a type is the corresponding typedef.
1902 In C, it is an IDENTIFIER_NODE. */
1903 tree name
= TYPE_NAME (type
);
1904 if (TREE_CODE (name
) == TYPE_DECL
)
1905 name
= DECL_NAME (name
);
1907 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1908 current_sym_value
= 0;
1909 current_sym_addr
= 0;
1910 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1912 fprintf (asmfile
, "%s\"%s:T", ASM_STABS_OP
,
1913 IDENTIFIER_POINTER (name
));
1914 dbxout_type (type
, 1);
1915 dbxout_finish_symbol (NULL_TREE
);
1919 /* If an enum type has no name, it cannot be referred to,
1920 but we must output it anyway, since the enumeration constants
1921 can be referred to. */
1922 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
1924 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1925 current_sym_value
= 0;
1926 current_sym_addr
= 0;
1927 current_sym_nchars
= 2;
1929 /* Some debuggers fail when given NULL names, so give this a
1930 harmless name of ` '. */
1931 fprintf (asmfile
, "%s\" :T", ASM_STABS_OP
);
1932 dbxout_type (type
, 1);
1933 dbxout_finish_symbol (NULL_TREE
);
1936 /* Prevent duplicate output of a typedef. */
1937 TREE_ASM_WRITTEN (decl
) = 1;
1942 /* Parm decls go in their own separate chains
1943 and are output by dbxout_reg_parms and dbxout_parms. */
1947 /* Named return value, treat like a VAR_DECL. */
1949 if (! DECL_RTL_SET_P (decl
))
1951 /* Don't mention a variable that is external.
1952 Let the file that defines it describe it. */
1953 if (DECL_EXTERNAL (decl
))
1956 /* If the variable is really a constant
1957 and not written in memory, inform the debugger. */
1958 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
1959 && DECL_INITIAL (decl
) != 0
1960 && host_integerp (DECL_INITIAL (decl
), 0)
1961 && ! TREE_ASM_WRITTEN (decl
)
1962 && (DECL_CONTEXT (decl
) == NULL_TREE
1963 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
))
1965 if (TREE_PUBLIC (decl
) == 0)
1967 /* The sun4 assembler does not grok this. */
1968 const char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1970 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
1971 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
1973 HOST_WIDE_INT ival
= tree_low_cst (DECL_INITIAL (decl
), 0);
1974 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1975 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile
, name
, ival
);
1977 fprintf (asmfile
, "%s\"%s:c=i", ASM_STABS_OP
, name
);
1979 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, ival
);
1980 fprintf (asmfile
, "\",0x%x,0,0,0\n", N_LSYM
);
1984 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
1986 /* don't know how to do this yet. */
1990 /* else it is something we handle like a normal variable. */
1993 SET_DECL_RTL (decl
, eliminate_regs (DECL_RTL (decl
), 0, NULL_RTX
));
1994 #ifdef LEAF_REG_REMAP
1995 if (current_function_uses_only_leaf_regs
)
1996 leaf_renumber_regs_insn (DECL_RTL (decl
));
1999 result
= dbxout_symbol_location (decl
, type
, 0, DECL_RTL (decl
));
2008 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2009 Add SUFFIX to its name, if SUFFIX is not 0.
2010 Describe the variable as residing in HOME
2011 (usually HOME is DECL_RTL (DECL), but not always).
2012 Returns 1 if the stab was really emitted. */
2015 dbxout_symbol_location (decl
, type
, suffix
, home
)
2023 /* Don't mention a variable at all
2024 if it was completely optimized into nothingness.
2026 If the decl was from an inline function, then its rtl
2027 is not identically the rtl that was used in this
2028 particular compilation. */
2029 if (GET_CODE (home
) == REG
)
2031 regno
= REGNO (home
);
2032 if (regno
>= FIRST_PSEUDO_REGISTER
)
2035 else if (GET_CODE (home
) == SUBREG
)
2039 while (GET_CODE (value
) == SUBREG
)
2040 value
= SUBREG_REG (value
);
2041 if (GET_CODE (value
) == REG
)
2043 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
2046 regno
= REGNO (alter_subreg (home
));
2049 /* The kind-of-variable letter depends on where
2050 the variable is and on the scope of its name:
2051 G and N_GSYM for static storage and global scope,
2052 S for static storage and file scope,
2053 V for static storage and local scope,
2054 for those two, use N_LCSYM if data is in bss segment,
2055 N_STSYM if in data segment, N_FUN otherwise.
2056 (We used N_FUN originally, then changed to N_STSYM
2057 to please GDB. However, it seems that confused ld.
2058 Now GDB has been fixed to like N_FUN, says Kingdon.)
2059 no letter at all, and N_LSYM, for auto variable,
2060 r and N_RSYM for register variable. */
2062 if (GET_CODE (home
) == MEM
2063 && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2065 if (TREE_PUBLIC (decl
))
2068 current_sym_code
= N_GSYM
;
2072 current_sym_addr
= XEXP (home
, 0);
2074 letter
= decl_function_context (decl
) ? 'V' : 'S';
2076 /* This should be the same condition as in assemble_variable, but
2077 we don't have access to dont_output_data here. So, instead,
2078 we rely on the fact that error_mark_node initializers always
2079 end up in bss for C++ and never end up in bss for C. */
2080 if (DECL_INITIAL (decl
) == 0
2081 || (!strcmp (lang_identify (), "cplusplus")
2082 && DECL_INITIAL (decl
) == error_mark_node
))
2083 current_sym_code
= N_LCSYM
;
2084 else if (DECL_IN_TEXT_SECTION (decl
))
2085 /* This is not quite right, but it's the closest
2086 of all the codes that Unix defines. */
2087 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
2090 /* Ultrix `as' seems to need this. */
2091 #ifdef DBX_STATIC_STAB_DATA_SECTION
2094 current_sym_code
= N_STSYM
;
2098 else if (regno
>= 0)
2101 current_sym_code
= N_RSYM
;
2102 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
2104 else if (GET_CODE (home
) == MEM
2105 && (GET_CODE (XEXP (home
, 0)) == MEM
2106 || (GET_CODE (XEXP (home
, 0)) == REG
2107 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
2108 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
2109 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2110 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
2113 /* If the value is indirect by memory or by a register
2114 that isn't the frame pointer
2115 then it means the object is variable-sized and address through
2116 that register or stack slot. DBX has no way to represent this
2117 so all we can do is output the variable as a pointer.
2118 If it's not a parameter, ignore it.
2119 (VAR_DECLs like this can be made by integrate.c.) */
2121 if (GET_CODE (XEXP (home
, 0)) == REG
)
2124 current_sym_code
= N_RSYM
;
2125 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
2129 current_sym_code
= N_LSYM
;
2130 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2131 We want the value of that CONST_INT. */
2133 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
2136 /* Effectively do build_pointer_type, but don't cache this type,
2137 since it might be temporary whereas the type it points to
2138 might have been saved for inlining. */
2139 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2140 type
= make_node (POINTER_TYPE
);
2141 TREE_TYPE (type
) = TREE_TYPE (decl
);
2143 else if (GET_CODE (home
) == MEM
2144 && GET_CODE (XEXP (home
, 0)) == REG
)
2146 current_sym_code
= N_LSYM
;
2147 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2149 else if (GET_CODE (home
) == MEM
2150 && GET_CODE (XEXP (home
, 0)) == PLUS
2151 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
2153 current_sym_code
= N_LSYM
;
2154 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2155 We want the value of that CONST_INT. */
2156 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2158 else if (GET_CODE (home
) == MEM
2159 && GET_CODE (XEXP (home
, 0)) == CONST
)
2161 /* Handle an obscure case which can arise when optimizing and
2162 when there are few available registers. (This is *always*
2163 the case for i386/i486 targets). The RTL looks like
2164 (MEM (CONST ...)) even though this variable is a local `auto'
2165 or a local `register' variable. In effect, what has happened
2166 is that the reload pass has seen that all assignments and
2167 references for one such a local variable can be replaced by
2168 equivalent assignments and references to some static storage
2169 variable, thereby avoiding the need for a register. In such
2170 cases we're forced to lie to debuggers and tell them that
2171 this variable was itself `static'. */
2172 current_sym_code
= N_LCSYM
;
2174 current_sym_addr
= XEXP (XEXP (home
, 0), 0);
2176 else if (GET_CODE (home
) == CONCAT
)
2180 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
2181 for example), then there is no easy way to figure out
2182 what SUBTYPE should be. So, we give up. */
2183 if (TREE_CODE (type
) != COMPLEX_TYPE
)
2186 subtype
= TREE_TYPE (type
);
2188 /* If the variable's storage is in two parts,
2189 output each as a separate stab with a modified name. */
2190 if (WORDS_BIG_ENDIAN
)
2191 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
2193 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
2195 /* Cast avoids warning in old compilers. */
2196 current_sym_code
= (STAB_CODE_TYPE
) 0;
2197 current_sym_value
= 0;
2198 current_sym_addr
= 0;
2199 dbxout_prepare_symbol (decl
);
2201 if (WORDS_BIG_ENDIAN
)
2202 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
2204 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
2208 /* Address might be a MEM, when DECL is a variable-sized object.
2209 Or it might be const0_rtx, meaning previous passes
2210 want us to ignore this variable. */
2213 /* Ok, start a symtab entry and output the variable name. */
2216 #ifdef DBX_STATIC_BLOCK_START
2217 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
2220 dbxout_symbol_name (decl
, suffix
, letter
);
2221 dbxout_type (type
, 0);
2222 dbxout_finish_symbol (decl
);
2224 #ifdef DBX_STATIC_BLOCK_END
2225 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
2230 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2231 Then output LETTER to indicate the kind of location the symbol has. */
2234 dbxout_symbol_name (decl
, suffix
, letter
)
2241 if (DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
)))
2242 /* One slight hitch: if this is a VAR_DECL which is a static
2243 class member, we must put out the mangled name instead of the
2244 DECL_NAME. Note also that static member (variable) names DO NOT begin
2245 with underscores in .stabs directives. */
2246 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2248 /* ...but if we're function-local, we don't want to include the junk
2249 added by ASM_FORMAT_PRIVATE_NAME. */
2250 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
2254 fprintf (asmfile
, "%s\"%s%s:", ASM_STABS_OP
, name
,
2255 (suffix
? suffix
: ""));
2257 if (letter
) putc (letter
, asmfile
);
2261 dbxout_prepare_symbol (decl
)
2262 tree decl ATTRIBUTE_UNUSED
;
2265 const char *filename
= DECL_SOURCE_FILE (decl
);
2267 dbxout_source_file (asmfile
, filename
);
2272 dbxout_finish_symbol (sym
)
2275 #ifdef DBX_FINISH_SYMBOL
2276 DBX_FINISH_SYMBOL (sym
);
2279 if (use_gnu_debug_info_extensions
&& sym
!= 0)
2280 line
= DECL_SOURCE_LINE (sym
);
2282 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
2283 if (current_sym_addr
)
2284 output_addr_const (asmfile
, current_sym_addr
);
2286 fprintf (asmfile
, "%d", current_sym_value
);
2287 putc ('\n', asmfile
);
2291 /* Output definitions of all the decls in a chain. Return non-zero if
2292 anything was output */
2301 result
+= dbxout_symbol (syms
, 1);
2302 syms
= TREE_CHAIN (syms
);
2307 /* The following two functions output definitions of function parameters.
2308 Each parameter gets a definition locating it in the parameter list.
2309 Each parameter that is a register variable gets a second definition
2310 locating it in the register.
2312 Printing or argument lists in gdb uses the definitions that
2313 locate in the parameter list. But reference to the variable in
2314 expressions uses preferentially the definition as a register. */
2316 /* Output definitions, referring to storage in the parmlist,
2317 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2320 dbxout_parms (parms
)
2323 for (; parms
; parms
= TREE_CHAIN (parms
))
2324 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
2326 dbxout_prepare_symbol (parms
);
2328 /* Perform any necessary register eliminations on the parameter's rtl,
2329 so that the debugging output will be accurate. */
2330 DECL_INCOMING_RTL (parms
)
2331 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
2332 SET_DECL_RTL (parms
, eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
));
2333 #ifdef LEAF_REG_REMAP
2334 if (current_function_uses_only_leaf_regs
)
2336 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
2337 leaf_renumber_regs_insn (DECL_RTL (parms
));
2341 if (PARM_PASSED_IN_MEMORY (parms
))
2343 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
2345 /* ??? Here we assume that the parm address is indexed
2346 off the frame pointer or arg pointer.
2347 If that is not true, we produce meaningless results,
2348 but do not crash. */
2349 if (GET_CODE (addr
) == PLUS
2350 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
2351 current_sym_value
= INTVAL (XEXP (addr
, 1));
2353 current_sym_value
= 0;
2355 current_sym_code
= N_PSYM
;
2356 current_sym_addr
= 0;
2359 if (DECL_NAME (parms
))
2361 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2363 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2364 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2365 DBX_MEMPARM_STABS_LETTER
);
2369 current_sym_nchars
= 8;
2370 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2371 DBX_MEMPARM_STABS_LETTER
);
2374 /* It is quite tempting to use:
2376 dbxout_type (TREE_TYPE (parms), 0);
2378 as the next statement, rather than using DECL_ARG_TYPE(), so
2379 that gcc reports the actual type of the parameter, rather
2380 than the promoted type. This certainly makes GDB's life
2381 easier, at least for some ports. The change is a bad idea
2382 however, since GDB expects to be able access the type without
2383 performing any conversions. So for example, if we were
2384 passing a float to an unprototyped function, gcc will store a
2385 double on the stack, but if we emit a stab saying the type is a
2386 float, then gdb will only read in a single value, and this will
2387 produce an erropneous value. */
2388 dbxout_type (DECL_ARG_TYPE (parms
), 0);
2389 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
2390 dbxout_finish_symbol (parms
);
2392 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
2395 char regparm_letter
;
2397 /* Parm passed in registers and lives in registers or nowhere. */
2399 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2400 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2401 current_sym_addr
= 0;
2403 /* If parm lives in a register, use that register;
2404 pretend the parm was passed there. It would be more consistent
2405 to describe the register where the parm was passed,
2406 but in practice that register usually holds something else.
2408 If we use DECL_RTL, then we must use the declared type of
2409 the variable, not the type that it arrived in. */
2410 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2412 best_rtl
= DECL_RTL (parms
);
2413 parm_type
= TREE_TYPE (parms
);
2415 /* If the parm lives nowhere, use the register where it was
2416 passed. It is also better to use the declared type here. */
2419 best_rtl
= DECL_INCOMING_RTL (parms
);
2420 parm_type
= TREE_TYPE (parms
);
2422 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
2425 if (DECL_NAME (parms
))
2427 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2428 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2429 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2434 current_sym_nchars
= 8;
2435 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2439 dbxout_type (parm_type
, 0);
2440 dbxout_finish_symbol (parms
);
2442 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2443 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
2444 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
2445 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
2446 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2447 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
2451 /* Parm was passed via invisible reference.
2452 That is, its address was passed in a register.
2453 Output it as if it lived in that register.
2454 The debugger will know from the type
2455 that it was actually passed by invisible reference. */
2457 char regparm_letter
;
2458 /* Parm passed in registers and lives in registers or nowhere. */
2460 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2461 if (use_gnu_debug_info_extensions
)
2462 regparm_letter
= GDB_INV_REF_REGPARM_STABS_LETTER
;
2464 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2466 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2467 If it is an unallocated pseudo-reg, then use the register where
2468 it was passed instead. */
2469 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
2470 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
2472 current_sym_value
= REGNO (DECL_INCOMING_RTL (parms
));
2474 current_sym_addr
= 0;
2477 if (DECL_NAME (parms
))
2479 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2481 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2482 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2487 current_sym_nchars
= 8;
2488 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2492 dbxout_type (TREE_TYPE (parms
), 0);
2493 dbxout_finish_symbol (parms
);
2495 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2496 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
2498 /* Parm was passed via invisible reference, with the reference
2499 living on the stack. DECL_RTL looks like
2500 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
2501 could look like (MEM (MEM (REG))). */
2502 const char *decl_name
= (DECL_NAME (parms
)
2503 ? IDENTIFIER_POINTER (DECL_NAME (parms
))
2505 if (GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 0)) == REG
)
2506 current_sym_value
= 0;
2509 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
2510 current_sym_addr
= 0;
2513 fprintf (asmfile
, "%s\"%s:v", ASM_STABS_OP
, decl_name
);
2514 dbxout_type (TREE_TYPE (parms
), 0);
2515 dbxout_finish_symbol (parms
);
2517 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2518 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
2519 /* ??? A constant address for a parm can happen
2520 when the reg it lives in is equiv to a constant in memory.
2521 Should make this not happen, after 2.4. */
2522 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
2524 /* Parm was passed in registers but lives on the stack. */
2526 current_sym_code
= N_PSYM
;
2527 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2528 in which case we want the value of that CONST_INT,
2530 in which case we use a value of zero. */
2531 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
)
2532 current_sym_value
= 0;
2535 = INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
2537 current_sym_addr
= 0;
2539 /* Make a big endian correction if the mode of the type of the
2540 parameter is not the same as the mode of the rtl. */
2541 if (BYTES_BIG_ENDIAN
2542 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
2543 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
2545 current_sym_value
+=
2546 GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
2547 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
)));
2551 if (DECL_NAME (parms
))
2554 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2556 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2557 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2558 DBX_MEMPARM_STABS_LETTER
);
2562 current_sym_nchars
= 8;
2563 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2564 DBX_MEMPARM_STABS_LETTER
);
2568 = DEBUGGER_ARG_OFFSET (current_sym_value
,
2569 XEXP (DECL_RTL (parms
), 0));
2570 dbxout_type (TREE_TYPE (parms
), 0);
2571 dbxout_finish_symbol (parms
);
2576 /* Output definitions for the places where parms live during the function,
2577 when different from where they were passed, when the parms were passed
2580 It is not useful to do this for parms passed in registers
2581 that live during the function in different registers, because it is
2582 impossible to look in the passed register for the passed value,
2583 so we use the within-the-function register to begin with.
2585 PARMS is a chain of PARM_DECL nodes. */
2588 dbxout_reg_parms (parms
)
2591 for (; parms
; parms
= TREE_CHAIN (parms
))
2592 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
2594 dbxout_prepare_symbol (parms
);
2596 /* Report parms that live in registers during the function
2597 but were passed in memory. */
2598 if (GET_CODE (DECL_RTL (parms
)) == REG
2599 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2600 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2601 0, DECL_RTL (parms
));
2602 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
2603 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2604 0, DECL_RTL (parms
));
2605 /* Report parms that live in memory but not where they were passed. */
2606 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2607 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
2608 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2609 0, DECL_RTL (parms
));
2613 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2614 output definitions of those names, in raw form */
2622 putc (',', asmfile
);
2623 dbxout_type (TREE_VALUE (args
), 0);
2625 args
= TREE_CHAIN (args
);
2629 /* Output everything about a symbol block (a BLOCK node
2630 that represents a scope level),
2631 including recursive output of contained blocks.
2633 BLOCK is the BLOCK node.
2634 DEPTH is its depth within containing symbol blocks.
2635 ARGS is usually zero; but for the outermost block of the
2636 body of a function, it is a chain of PARM_DECLs for the function parameters.
2637 We output definitions of all the register parms
2638 as if they were local variables of that block.
2640 If -g1 was used, we count blocks just the same, but output nothing
2641 except for the outermost block.
2643 Actually, BLOCK may be several blocks chained together.
2644 We handle them all in sequence. */
2647 dbxout_block (block
, depth
, args
)
2648 register tree block
;
2654 #if DBX_BLOCKS_FUNCTION_RELATIVE
2655 const char *begin_label
;
2656 if (current_function_func_begin_label
!= NULL_TREE
)
2657 begin_label
= IDENTIFIER_POINTER (current_function_func_begin_label
);
2659 begin_label
= XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0);
2664 /* Ignore blocks never expanded or otherwise marked as real. */
2665 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
2669 #ifdef DBX_LBRAC_FIRST
2672 /* In dbx format, the syms of a block come before the N_LBRAC.
2673 If nothing is output, we don't need the N_LBRAC, either. */
2675 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2676 did_output
= dbxout_syms (BLOCK_VARS (block
));
2678 dbxout_reg_parms (args
);
2681 /* Now output an N_LBRAC symbol to represent the beginning of
2682 the block. Use the block's tree-walk order to generate
2683 the assembler symbols LBBn and LBEn
2684 that final will define around the code in this block. */
2685 if (depth
> 0 && did_output
)
2688 blocknum
= BLOCK_NUMBER (block
);
2689 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
2691 if (BLOCK_HANDLER_BLOCK (block
))
2693 /* A catch block. Must precede N_LBRAC. */
2694 tree decl
= BLOCK_VARS (block
);
2697 #ifdef DBX_OUTPUT_CATCH
2698 DBX_OUTPUT_CATCH (asmfile
, decl
, buf
);
2700 fprintf (asmfile
, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP
,
2701 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
2702 assemble_name (asmfile
, buf
);
2703 fprintf (asmfile
, "\n");
2705 decl
= TREE_CHAIN (decl
);
2709 #ifdef DBX_OUTPUT_LBRAC
2710 DBX_OUTPUT_LBRAC (asmfile
, buf
);
2712 fprintf (asmfile
, "%s%d,0,0,", ASM_STABN_OP
, N_LBRAC
);
2713 assemble_name (asmfile
, buf
);
2714 #if DBX_BLOCKS_FUNCTION_RELATIVE
2715 fputc ('-', asmfile
);
2716 assemble_name (asmfile
, begin_label
);
2718 fprintf (asmfile
, "\n");
2722 #ifdef DBX_LBRAC_FIRST
2723 /* On some weird machines, the syms of a block
2724 come after the N_LBRAC. */
2725 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2726 dbxout_syms (BLOCK_VARS (block
));
2728 dbxout_reg_parms (args
);
2731 /* Output the subblocks. */
2732 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
2734 /* Refer to the marker for the end of the block. */
2735 if (depth
> 0 && did_output
)
2738 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
2739 #ifdef DBX_OUTPUT_RBRAC
2740 DBX_OUTPUT_RBRAC (asmfile
, buf
);
2742 fprintf (asmfile
, "%s%d,0,0,", ASM_STABN_OP
, N_RBRAC
);
2743 assemble_name (asmfile
, buf
);
2744 #if DBX_BLOCKS_FUNCTION_RELATIVE
2745 fputc ('-', asmfile
);
2746 assemble_name (asmfile
, begin_label
);
2748 fprintf (asmfile
, "\n");
2752 block
= BLOCK_CHAIN (block
);
2756 /* Output the information about a function and its arguments and result.
2757 Usually this follows the function's code,
2758 but on some systems, it comes before. */
2761 dbxout_begin_function (decl
)
2764 dbxout_symbol (decl
, 0);
2765 dbxout_parms (DECL_ARGUMENTS (decl
));
2766 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
2767 dbxout_symbol (DECL_RESULT (decl
), 1);
2770 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */