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 #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_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));
320 static void dbxout_function_decl
PARAMS ((tree
));
322 struct gcc_debug_hooks dbx_debug_hooks
=
326 debug_nothing_int_charstar
,
327 debug_nothing_int_charstar
,
328 dbxout_start_source_file
,
329 dbxout_end_source_file
,
332 dbxout_source_line
, /* source_line */
333 dbxout_source_line
, /* begin_prologue: just output line info */
334 debug_nothing_int
, /* end_prologue */
335 debug_nothing_void
, /* end_epilogue */
336 #ifdef DBX_FUNCTION_FIRST
337 dbxout_begin_function
,
339 debug_nothing_tree
, /* begin_function */
341 debug_nothing_int
, /* end_function */
342 dbxout_function_decl
,
343 debug_nothing_tree
, /* global_decl */
344 debug_nothing_tree
/* deferred_inline_function */
346 #endif /* DBX_DEBUGGING_INFO */
348 #if defined (XCOFF_DEBUGGING_INFO)
349 struct gcc_debug_hooks xcoff_debug_hooks
=
353 debug_nothing_int_charstar
,
354 debug_nothing_int_charstar
,
355 dbxout_start_source_file
,
356 dbxout_end_source_file
,
357 xcoffout_begin_block
,
359 xcoffout_source_line
,
360 xcoffout_begin_prologue
, /* begin_prologue */
361 debug_nothing_int
, /* end_prologue */
362 xcoffout_end_epilogue
,
363 debug_nothing_tree
, /* begin_function */
364 xcoffout_end_function
,
365 debug_nothing_tree
, /* function_decl */
366 debug_nothing_tree
, /* global_decl */
367 debug_nothing_tree
/* deferred_inline_function */
369 #endif /* XCOFF_DEBUGGING_INFO */
371 #if defined(ASM_OUTPUT_SECTION_NAME)
373 dbxout_function_end ()
375 static int scope_labelno
= 0;
376 char lscope_label_name
[100];
377 /* Convert Ltext into the appropriate format for local labels in case
378 the system doesn't insert underscores in front of user generated
380 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
381 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Lscope", scope_labelno
);
384 /* By convention, GCC will mark the end of a function with an N_FUN
385 symbol and an empty string. */
386 fprintf (asmfile
, "%s\"\",%d,0,0,", ASM_STABS_OP
, N_FUN
);
387 assemble_name (asmfile
, lscope_label_name
);
388 fputc ('-', asmfile
);
389 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
390 fprintf (asmfile
, "\n");
392 #endif /* ! NO_DBX_FUNCTION_END */
394 /* At the beginning of compilation, start writing the symbol table.
395 Initialize `typevec' and output the standard data types of C. */
398 dbxout_init (input_file_name
)
399 const char *input_file_name
;
401 char ltext_label_name
[100];
402 tree syms
= getdecls ();
404 asmfile
= asm_out_file
;
407 typevec
= (struct typeinfo
*) xcalloc (typevec_len
, sizeof typevec
[0]);
409 /* Convert Ltext into the appropriate format for local labels in case
410 the system doesn't insert underscores in front of user generated
412 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
414 /* Put the current working directory in an N_SO symbol. */
415 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
416 but GDB always does. */
417 if (use_gnu_debug_info_extensions
)
420 if (!cwd
&& (cwd
= getpwd ()) && (!*cwd
|| cwd
[strlen (cwd
) - 1] != '/'))
421 cwd
= concat (cwd
, FILE_NAME_JOINER
, NULL
);
424 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
425 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile
, cwd
);
426 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
427 fprintf (asmfile
, "%s", ASM_STABS_OP
);
428 output_quoted_string (asmfile
, cwd
);
429 fprintf (asmfile
, ",%d,0,0,%s\n", N_SO
, <ext_label_name
[1]);
430 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
434 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
435 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
436 would give us an N_SOL, and we want an N_SO. */
437 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile
, input_file_name
);
438 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
439 /* We include outputting `Ltext:' here,
440 because that gives you a way to override it. */
441 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
442 fprintf (asmfile
, "%s", ASM_STABS_OP
);
443 output_quoted_string (asmfile
, input_file_name
);
444 fprintf (asmfile
, ",%d,0,0,%s\n",
445 N_SO
, <ext_label_name
[1]);
447 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Ltext", 0);
448 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
450 #ifdef DBX_OUTPUT_GCC_MARKER
451 DBX_OUTPUT_GCC_MARKER (asmfile
);
453 /* Emit an N_OPT stab to indicate that this file was compiled by GCC. */
454 fprintf (asmfile
, "%s\"%s\",%d,0,0,0\n",
455 ASM_STABS_OP
, STABS_GCC_MARKER
, N_OPT
);
458 lastfile
= input_file_name
;
460 next_type_number
= 1;
463 current_file
= (struct dbx_file
*) xmalloc (sizeof *current_file
);
464 current_file
->next
= NULL
;
465 current_file
->file_number
= 0;
466 current_file
->next_type_number
= 1;
467 next_file_number
= 1;
470 /* Make sure that types `int' and `char' have numbers 1 and 2.
471 Definitions of other integer types will refer to those numbers.
472 (Actually it should no longer matter what their numbers are.
473 Also, if any types with tags have been defined, dbxout_symbol
474 will output them first, so the numbers won't be 1 and 2. That
475 happens in C++. So it's a good thing it should no longer matter). */
477 #ifdef DBX_OUTPUT_STANDARD_TYPES
478 DBX_OUTPUT_STANDARD_TYPES (syms
);
480 dbxout_symbol (TYPE_NAME (integer_type_node
), 0);
481 dbxout_symbol (TYPE_NAME (char_type_node
), 0);
484 /* Get all permanent types that have typedef names,
485 and output them all, except for those already output. */
487 dbxout_typedefs (syms
);
490 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
491 in the reverse order from that which is found in SYMS. */
494 dbxout_typedefs (syms
)
499 dbxout_typedefs (TREE_CHAIN (syms
));
500 if (TREE_CODE (syms
) == TYPE_DECL
)
502 tree type
= TREE_TYPE (syms
);
504 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
505 && COMPLETE_TYPE_P (type
)
506 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
507 dbxout_symbol (TYPE_NAME (type
), 0);
512 /* Change to reading from a new source file. Generate a N_BINCL stab. */
515 dbxout_start_source_file (line
, filename
)
516 unsigned int line ATTRIBUTE_UNUSED
;
517 const char *filename ATTRIBUTE_UNUSED
;
520 struct dbx_file
*n
= (struct dbx_file
*) xmalloc (sizeof *n
);
522 n
->next
= current_file
;
523 n
->file_number
= next_file_number
++;
524 n
->next_type_number
= 1;
526 fprintf (asmfile
, "%s", ASM_STABS_OP
);
527 output_quoted_string (asmfile
, filename
);
528 fprintf (asmfile
, ",%d,0,0,0\n", N_BINCL
);
532 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
535 dbxout_end_source_file (line
)
536 unsigned int line ATTRIBUTE_UNUSED
;
539 struct dbx_file
*next
;
541 fprintf (asmfile
, "%s%d,0,0,0\n", ASM_STABN_OP
, N_EINCL
);
542 next
= current_file
->next
;
548 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
551 dbxout_source_file (file
, filename
)
553 const char *filename
;
555 char ltext_label_name
[100];
557 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
559 #ifdef DBX_OUTPUT_SOURCE_FILENAME
560 DBX_OUTPUT_SOURCE_FILENAME (file
, filename
);
562 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext",
563 source_label_number
);
564 fprintf (file
, "%s", ASM_STABS_OP
);
565 output_quoted_string (file
, filename
);
566 fprintf (file
, ",%d,0,0,%s\n", N_SOL
, <ext_label_name
[1]);
567 if (current_function_decl
!= NULL_TREE
568 && DECL_SECTION_NAME (current_function_decl
) != NULL_TREE
)
569 ; /* Don't change section amid function. */
572 ASM_OUTPUT_INTERNAL_LABEL (file
, "Ltext", source_label_number
);
573 source_label_number
++;
579 /* Output a line number symbol entry for source file FILENAME and line
583 dbxout_source_line (lineno
, filename
)
585 const char *filename
;
587 dbxout_source_file (asmfile
, filename
);
589 #ifdef ASM_OUTPUT_SOURCE_LINE
590 ASM_OUTPUT_SOURCE_LINE (asmfile
, lineno
);
592 fprintf (asmfile
, "%s%d,0,%d\n", ASM_STABD_OP
, N_SLINE
, lineno
);
596 #if defined (DBX_DEBUGGING_INFO)
598 /* Describe the beginning of an internal block within a function. */
601 dbxout_begin_block (line
, n
)
602 unsigned int line ATTRIBUTE_UNUSED
;
605 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "LBB", n
);
608 /* Describe the end line-number of an internal block within a function. */
611 dbxout_end_block (line
, n
)
612 unsigned int line ATTRIBUTE_UNUSED
;
615 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "LBE", n
);
618 /* Output dbx data for a function definition.
619 This includes a definition of the function name itself (a symbol),
620 definitions of the parameters (locating them in the parameter list)
621 and then output the block that makes up the function's body
622 (including all the auto variables of the function). */
625 dbxout_function_decl (decl
)
628 #ifndef DBX_FUNCTION_FIRST
629 dbxout_begin_function (decl
);
631 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
632 #ifdef DBX_OUTPUT_FUNCTION_END
633 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
635 #if defined(ASM_OUTPUT_SECTION_NAME)
636 if (use_gnu_debug_info_extensions
637 #if defined(NO_DBX_FUNCTION_END)
638 && ! NO_DBX_FUNCTION_END
641 dbxout_function_end ();
645 #endif /* DBX_DEBUGGING_INFO */
647 /* At the end of compilation, finish writing the symbol table.
648 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
652 dbxout_finish (filename
)
653 const char *filename ATTRIBUTE_UNUSED
;
655 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
656 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asmfile
, filename
);
657 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
660 /* Output the index of a type. */
663 dbxout_type_index (type
)
666 #ifndef DBX_USE_BINCL
667 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
670 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
671 fprintf (asmfile
, "(%d,%d)", t
->file_number
, t
->type_number
);
676 #if DBX_CONTIN_LENGTH > 0
677 /* Continue a symbol-description that gets too big.
678 End one symbol table entry with a double-backslash
679 and start a new one, eventually producing something like
680 .stabs "start......\\",code,0,value
681 .stabs "...rest",code,0,value */
686 #ifdef DBX_CONTIN_CHAR
687 fprintf (asmfile
, "%c", DBX_CONTIN_CHAR
);
689 fprintf (asmfile
, "\\\\");
691 dbxout_finish_symbol (NULL_TREE
);
692 fprintf (asmfile
, "%s\"", ASM_STABS_OP
);
693 current_sym_nchars
= 0;
695 #endif /* DBX_CONTIN_LENGTH > 0 */
697 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
698 This must be a separate function because anonymous unions require
702 dbxout_type_fields (type
)
707 /* Output the name, type, position (in bits), size (in bits) of each
708 field that we can support. */
709 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
711 /* Omit here local type decls until we know how to support them. */
712 if (TREE_CODE (tem
) == TYPE_DECL
713 /* Omit fields whose position or size are variable or too large to
715 || (TREE_CODE (tem
) == FIELD_DECL
716 && (! host_integerp (bit_position (tem
), 0)
718 || ! host_integerp (DECL_SIZE (tem
), 1)))
719 /* Omit here the nameless fields that are used to skip bits. */
720 || DECL_IGNORED_P (tem
))
723 else if (TREE_CODE (tem
) != CONST_DECL
)
725 /* Continue the line if necessary,
726 but not before the first field. */
727 if (tem
!= TYPE_FIELDS (type
))
732 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem
)));
733 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem
)));
737 fprintf (asmfile
, ":");
741 if (use_gnu_debug_info_extensions
742 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
743 || TREE_CODE (tem
) != FIELD_DECL
))
745 have_used_extensions
= 1;
747 putc ((TREE_PRIVATE (tem
) ? '0'
748 : TREE_PROTECTED (tem
) ? '1' : '2'),
753 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
754 && DECL_BIT_FIELD_TYPE (tem
))
755 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0);
757 if (TREE_CODE (tem
) == VAR_DECL
)
759 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
762 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
));
763 have_used_extensions
= 1;
764 fprintf (asmfile
, ":%s;", name
);
765 CHARS (strlen (name
));
768 /* If TEM is non-static, GDB won't understand it. */
769 fprintf (asmfile
, ",0,0;");
773 fputc (',', asmfile
);
774 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
775 int_bit_position (tem
));
776 fputc (',', asmfile
);
777 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
778 tree_low_cst (DECL_SIZE (tem
), 1));
779 fputc (';', asmfile
);
786 /* Subroutine of `dbxout_type_methods'. Output debug info about the
787 method described DECL. DEBUG_NAME is an encoding of the method's
788 type signature. ??? We may be able to do without DEBUG_NAME altogether
792 dbxout_type_method_1 (decl
, debug_name
)
794 const char *debug_name
;
798 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
800 else /* it's a METHOD_TYPE. */
802 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
803 /* A for normal functions.
804 B for `const' member functions.
805 C for `volatile' member functions.
806 D for `const volatile' member functions. */
807 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
809 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
812 if (DECL_VINDEX (decl
))
818 fprintf (asmfile
, ":%s;%c%c%c", debug_name
,
819 TREE_PRIVATE (decl
) ? '0'
820 : TREE_PROTECTED (decl
) ? '1' : '2', c1
, c2
);
821 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
)) + 6
822 - (debug_name
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
824 if (DECL_VINDEX (decl
) && host_integerp (DECL_VINDEX (decl
), 0))
826 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
827 tree_low_cst (DECL_VINDEX (decl
), 0));
828 fputc (';', asmfile
);
829 dbxout_type (DECL_CONTEXT (decl
), 0);
830 fprintf (asmfile
, ";");
835 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
839 dbxout_type_methods (type
)
842 /* C++: put out the method names and their parameter lists */
843 tree methods
= TYPE_METHODS (type
);
845 register tree fndecl
;
847 char formatted_type_identifier_length
[16];
848 register int type_identifier_length
;
850 if (methods
== NULL_TREE
)
853 type_encoding
= DECL_NAME (TYPE_NAME (type
));
856 /* C++: Template classes break some assumptions made by this code about
857 the class names, constructor names, and encodings for assembler
858 label names. For now, disable output of dbx info for them. */
860 const char *ptr
= IDENTIFIER_POINTER (type_encoding
);
861 /* This should use index. (mrs) */
862 while (*ptr
&& *ptr
!= '<') ptr
++;
873 type_identifier_length
= IDENTIFIER_LENGTH (type_encoding
);
875 sprintf (formatted_type_identifier_length
, "%d", type_identifier_length
);
877 if (TREE_CODE (methods
) != TREE_VEC
)
879 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
880 fndecl
= TREE_VEC_ELT (methods
, 0);
882 fndecl
= TREE_VEC_ELT (methods
, 1);
888 /* Group together all the methods for the same operation.
889 These differ in the types of the arguments. */
890 for (last
= NULL_TREE
;
891 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
892 fndecl
= TREE_CHAIN (fndecl
))
893 /* Output the name of the field (after overloading), as
894 well as the name of the field before overloading, along
895 with its parameter list */
897 /* This is the "mangled" name of the method.
898 It encodes the argument types. */
899 const char *debug_name
;
901 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
902 include TEMPLATE_DECLs.) The debugger doesn't know what
903 to do with such entities anyhow. */
904 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
908 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
));
914 /* Also ignore abstract methods; those are only interesting to
915 the DWARF backends. */
916 if (DECL_IGNORED_P (fndecl
) || DECL_ABSTRACT (fndecl
))
919 /* Redundantly output the plain name, since that's what gdb
923 tree name
= DECL_NAME (fndecl
);
924 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (name
));
925 CHARS (IDENTIFIER_LENGTH (name
) + 2);
929 dbxout_type (TREE_TYPE (fndecl
), 0);
931 dbxout_type_method_1 (fndecl
, debug_name
);
941 /* Emit a "range" type specification, which has the form:
942 "r<index type>;<lower bound>;<upper bound>;".
943 TYPE is an INTEGER_TYPE. */
946 dbxout_range_type (type
)
949 fprintf (asmfile
, "r");
950 if (TREE_TYPE (type
))
951 dbxout_type (TREE_TYPE (type
), 0);
952 else if (TREE_CODE (type
) != INTEGER_TYPE
)
953 dbxout_type (type
, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
956 /* Traditionally, we made sure 'int' was type 1, and builtin types
957 were defined to be sub-ranges of int. Unfortunately, this
958 does not allow us to distinguish true sub-ranges from integer
959 types. So, instead we define integer (non-sub-range) types as
960 sub-ranges of themselves. This matters for Chill. If this isn't
961 a subrange type, then we want to define it in terms of itself.
962 However, in C, this may be an anonymous integer type, and we don't
963 want to emit debug info referring to it. Just calling
964 dbxout_type_index won't work anyways, because the type hasn't been
965 defined yet. We make this work for both cases by checked to see
966 whether this is a defined type, referring to it if it is, and using
968 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
969 dbxout_type_index (type
);
971 dbxout_type_index (integer_type_node
);
974 if (TYPE_MIN_VALUE (type
) != 0
975 && host_integerp (TYPE_MIN_VALUE (type
), 0))
977 fputc (';', asmfile
);
978 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
979 tree_low_cst (TYPE_MIN_VALUE (type
), 0));
982 fprintf (asmfile
, ";0");
984 if (TYPE_MAX_VALUE (type
) != 0
985 && host_integerp (TYPE_MAX_VALUE (type
), 0))
987 fputc (';', asmfile
);
988 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
989 tree_low_cst (TYPE_MAX_VALUE (type
), 0));
990 fputc (';', asmfile
);
993 fprintf (asmfile
, ";-1;");
996 /* Output a reference to a type. If the type has not yet been
997 described in the dbx output, output its definition now.
998 For a type already defined, just refer to its definition
999 using the type number.
1001 If FULL is nonzero, and the type has been described only with
1002 a forward-reference, output the definition now.
1003 If FULL is zero in this case, just refer to the forward-reference
1004 using the number previously allocated. */
1007 dbxout_type (type
, full
)
1012 static int anonymous_type_number
= 0;
1014 if (TREE_CODE (type
) == VECTOR_TYPE
)
1015 type
= TYPE_DEBUG_REPRESENTATION_TYPE (type
);
1017 /* If there was an input error and we don't really have a type,
1018 avoid crashing and write something that is at least valid
1019 by assuming `int'. */
1020 if (type
== error_mark_node
)
1021 type
= integer_type_node
;
1024 /* Try to find the "main variant" with the same name but not const
1025 or volatile. (Since stabs does not distinguish const and volatile,
1026 there is no need to make them separate types. But types with
1027 different names are usefully distinguished.) */
1029 for (tem
= TYPE_MAIN_VARIANT (type
); tem
; tem
= TYPE_NEXT_VARIANT (tem
))
1030 if (!TYPE_READONLY (tem
) && !TYPE_VOLATILE (tem
)
1031 && TYPE_NAME (tem
) == TYPE_NAME (type
))
1036 if (TYPE_NAME (type
)
1037 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1038 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1042 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1044 /* Type has no dbx number assigned. Assign next available number. */
1045 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1047 /* Make sure type vector is long enough to record about this type. */
1049 if (next_type_number
== typevec_len
)
1052 = (struct typeinfo
*) xrealloc (typevec
,
1053 typevec_len
* 2 * sizeof typevec
[0]);
1054 memset ((char *) (typevec
+ typevec_len
), 0,
1055 typevec_len
* sizeof typevec
[0]);
1059 #ifdef DBX_USE_BINCL
1060 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1061 = current_file
->file_number
;
1062 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1063 = current_file
->next_type_number
++;
1067 /* Output the number of this type, to refer to it. */
1068 dbxout_type_index (type
);
1070 #ifdef DBX_TYPE_DEFINED
1071 if (DBX_TYPE_DEFINED (type
))
1075 /* If this type's definition has been output or is now being output,
1078 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1083 /* If we have already had a cross reference,
1084 and either that's all we want or that's the best we could do,
1085 don't repeat the cross reference.
1086 Sun dbx crashes if we do. */
1087 if (! full
|| !COMPLETE_TYPE_P (type
)
1088 /* No way in DBX fmt to describe a variable size. */
1089 || ! host_integerp (TYPE_SIZE (type
), 1))
1097 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1098 leave the type-number completely undefined rather than output
1099 a cross-reference. If we have already used GNU debug info extensions,
1100 then it is OK to output a cross reference. This is necessary to get
1101 proper C++ debug output. */
1102 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1103 || TREE_CODE (type
) == QUAL_UNION_TYPE
1104 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1105 && ! use_gnu_debug_info_extensions
)
1106 /* We must use the same test here as we use twice below when deciding
1107 whether to emit a cross-reference. */
1108 if ((TYPE_NAME (type
) != 0
1109 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1110 && DECL_IGNORED_P (TYPE_NAME (type
)))
1112 || !COMPLETE_TYPE_P (type
)
1113 /* No way in DBX fmt to describe a variable size. */
1114 || ! host_integerp (TYPE_SIZE (type
), 1))
1116 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1121 /* Output a definition now. */
1123 fprintf (asmfile
, "=");
1126 /* Mark it as defined, so that if it is self-referent
1127 we will not get into an infinite recursion of definitions. */
1129 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1131 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1132 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1134 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0);
1138 switch (TREE_CODE (type
))
1142 /* For a void type, just define it as itself; ie, "5=5".
1143 This makes us consider it defined
1144 without saying what it is. The debugger will make it
1145 a void type when the reference is seen, and nothing will
1146 ever override that default. */
1147 dbxout_type_index (type
);
1151 if (type
== char_type_node
&& ! TREE_UNSIGNED (type
))
1153 /* Output the type `char' as a subrange of itself!
1154 I don't understand this definition, just copied it
1155 from the output of pcc.
1156 This used to use `r2' explicitly and we used to
1157 take care to make sure that `char' was type number 2. */
1158 fprintf (asmfile
, "r");
1159 dbxout_type_index (type
);
1160 fprintf (asmfile
, ";0;127;");
1163 /* If this is a subtype of another integer type, always prefer to
1164 write it as a subtype. */
1165 else if (TREE_TYPE (type
) != 0
1166 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
1167 dbxout_range_type (type
);
1171 /* If the size is non-standard, say what it is if we can use
1174 if (use_gnu_debug_info_extensions
1175 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1176 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1178 /* If we can use GDB extensions and the size is wider than a
1179 long (the size used by GDB to read them) or we may have
1180 trouble writing the bounds the usual way, write them in
1181 octal. Note the test is for the *target's* size of "long",
1182 not that of the host. The host test is just to make sure we
1183 can write it out in case the host wide int is narrower than the
1186 /* For unsigned types, we use octal if they are the same size or
1187 larger. This is because we print the bounds as signed decimal,
1188 and hence they can't span same size unsigned types. */
1190 if (use_gnu_debug_info_extensions
1191 && TYPE_MIN_VALUE (type
) != 0
1192 && TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
1193 && TYPE_MAX_VALUE (type
) != 0
1194 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
1195 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
1196 || ((TYPE_PRECISION (type
)
1197 == TYPE_PRECISION (integer_type_node
))
1198 && TREE_UNSIGNED (type
))
1199 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
1200 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
1201 && TREE_UNSIGNED (type
))))
1203 fprintf (asmfile
, "r");
1204 dbxout_type_index (type
);
1205 fprintf (asmfile
, ";");
1206 print_int_cst_octal (TYPE_MIN_VALUE (type
));
1207 fprintf (asmfile
, ";");
1208 print_int_cst_octal (TYPE_MAX_VALUE (type
));
1209 fprintf (asmfile
, ";");
1213 /* Output other integer types as subranges of `int'. */
1214 dbxout_range_type (type
);
1221 /* This used to say `r1' and we used to take care
1222 to make sure that `int' was type number 1. */
1223 fprintf (asmfile
, "r");
1224 dbxout_type_index (integer_type_node
);
1225 fputc (';', asmfile
);
1226 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1227 fputs (";0;", asmfile
);
1232 if (use_gnu_debug_info_extensions
)
1234 fputs ("@s", asmfile
);
1235 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1236 BITS_PER_UNIT
* int_size_in_bytes (type
));
1237 fputs (";-20;", asmfile
);
1241 /* Output the type `char' as a subrange of itself.
1242 That is what pcc seems to do. */
1243 fprintf (asmfile
, "r");
1244 dbxout_type_index (char_type_node
);
1245 fprintf (asmfile
, ";0;%d;", TREE_UNSIGNED (type
) ? 255 : 127);
1251 if (use_gnu_debug_info_extensions
)
1253 fputs ("@s", asmfile
);
1254 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1255 BITS_PER_UNIT
* int_size_in_bytes (type
));
1256 fputs (";-16;", asmfile
);
1258 else /* Define as enumeral type (False, True) */
1259 fprintf (asmfile
, "eFalse:0,True:1,;");
1264 putc ('d', asmfile
);
1266 dbxout_type (TREE_TYPE (type
), 0);
1270 /* Differs from the REAL_TYPE by its new data type number */
1272 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1274 fprintf (asmfile
, "r");
1275 dbxout_type_index (type
);
1276 fputc (';', asmfile
);
1277 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1278 2 * int_size_in_bytes (TREE_TYPE (type
)));
1279 fputs (";0;", asmfile
);
1280 CHARS (12); /* The number is probably incorrect here. */
1284 /* Output a complex integer type as a structure,
1285 pending some other way to do it. */
1286 fputc ('s', asmfile
);
1287 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1289 fprintf (asmfile
, "real:");
1291 dbxout_type (TREE_TYPE (type
), 0);
1292 fprintf (asmfile
, ",%d,%d;",
1293 0, TYPE_PRECISION (TREE_TYPE (type
)));
1295 fprintf (asmfile
, "imag:");
1297 dbxout_type (TREE_TYPE (type
), 0);
1298 fprintf (asmfile
, ",%d,%d;;",
1299 TYPE_PRECISION (TREE_TYPE (type
)),
1300 TYPE_PRECISION (TREE_TYPE (type
)));
1306 if (use_gnu_debug_info_extensions
)
1308 have_used_extensions
= 1;
1309 fputs ("@s", asmfile
);
1310 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1311 BITS_PER_UNIT
* int_size_in_bytes (type
));
1312 fputc (';', asmfile
);
1313 /* Check if a bitstring type, which in Chill is
1314 different from a [power]set. */
1315 if (TYPE_STRING_FLAG (type
))
1316 fprintf (asmfile
, "@S;");
1318 putc ('S', asmfile
);
1320 dbxout_type (TYPE_DOMAIN (type
), 0);
1324 /* Make arrays of packed bits look like bitstrings for chill. */
1325 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
1327 have_used_extensions
= 1;
1328 fputs ("@s", asmfile
);
1329 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1330 BITS_PER_UNIT
* int_size_in_bytes (type
));
1331 fputc (';', asmfile
);
1332 fprintf (asmfile
, "@S;");
1333 putc ('S', asmfile
);
1335 dbxout_type (TYPE_DOMAIN (type
), 0);
1338 /* Output "a" followed by a range type definition
1339 for the index type of the array
1340 followed by a reference to the target-type.
1341 ar1;0;N;M for a C array of type M and size N+1. */
1342 /* Check if a character string type, which in Chill is
1343 different from an array of characters. */
1344 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
1346 have_used_extensions
= 1;
1347 fprintf (asmfile
, "@S;");
1349 tem
= TYPE_DOMAIN (type
);
1352 fprintf (asmfile
, "ar");
1353 dbxout_type_index (integer_type_node
);
1354 fprintf (asmfile
, ";0;-1;");
1358 fprintf (asmfile
, "a");
1359 dbxout_range_type (tem
);
1362 dbxout_type (TREE_TYPE (type
), 0);
1367 case QUAL_UNION_TYPE
:
1369 int i
, n_baseclasses
= 0;
1371 if (TYPE_BINFO (type
) != 0
1372 && TREE_CODE (TYPE_BINFO (type
)) == TREE_VEC
1373 && TYPE_BINFO_BASETYPES (type
) != 0)
1374 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
1376 /* Output a structure type. We must use the same test here as we
1377 use in the DBX_NO_XREFS case above. */
1378 if ((TYPE_NAME (type
) != 0
1379 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1380 && DECL_IGNORED_P (TYPE_NAME (type
)))
1382 || !COMPLETE_TYPE_P (type
)
1383 /* No way in DBX fmt to describe a variable size. */
1384 || ! host_integerp (TYPE_SIZE (type
), 1))
1386 /* If the type is just a cross reference, output one
1387 and mark the type as partially described.
1388 If it later becomes defined, we will output
1389 its real definition.
1390 If the type has a name, don't nest its definition within
1391 another type's definition; instead, output an xref
1392 and let the definition come when the name is defined. */
1393 fputs ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu", asmfile
);
1395 #if 0 /* This assertion is legitimately false in C++. */
1396 /* We shouldn't be outputting a reference to a type before its
1397 definition unless the type has a tag name.
1398 A typedef name without a tag name should be impossible. */
1399 if (TREE_CODE (TYPE_NAME (type
)) != IDENTIFIER_NODE
)
1402 if (TYPE_NAME (type
) != 0)
1403 dbxout_type_name (type
);
1405 fprintf (asmfile
, "$$%d", anonymous_type_number
++);
1406 fprintf (asmfile
, ":");
1407 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1411 /* Identify record or union, and print its size. */
1412 fputc (((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u'), asmfile
);
1413 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1414 int_size_in_bytes (type
));
1416 if (use_gnu_debug_info_extensions
)
1420 have_used_extensions
= 1;
1421 fprintf (asmfile
, "!%d,", n_baseclasses
);
1425 for (i
= 0; i
< n_baseclasses
; i
++)
1427 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)), i
);
1429 if (use_gnu_debug_info_extensions
)
1431 have_used_extensions
= 1;
1432 putc (TREE_VIA_VIRTUAL (child
) ? '1' : '0', asmfile
);
1433 putc (TREE_VIA_PUBLIC (child
) ? '2' : '0', asmfile
);
1434 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1435 (tree_low_cst (BINFO_OFFSET (child
), 0)
1437 fputc (',', asmfile
);
1439 dbxout_type (BINFO_TYPE (child
), 0);
1440 putc (';', asmfile
);
1444 /* Print out the base class information with fields
1445 which have the same names at the types they hold. */
1446 dbxout_type_name (BINFO_TYPE (child
));
1447 putc (':', asmfile
);
1448 dbxout_type (BINFO_TYPE (child
), full
);
1449 fputc (',', asmfile
);
1450 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1451 tree_low_cst (BINFO_OFFSET (child
), 0)
1453 fputc (',', asmfile
);
1454 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1455 (tree_low_cst (DECL_SIZE (TYPE_NAME
1456 (BINFO_TYPE (child
))), 0)
1458 fputc (';', asmfile
);
1466 /* Write out the field declarations. */
1467 dbxout_type_fields (type
);
1468 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1470 have_used_extensions
= 1;
1471 dbxout_type_methods (type
);
1474 putc (';', asmfile
);
1476 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1477 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1478 && TYPE_VFIELD (type
))
1480 have_used_extensions
= 1;
1482 /* Tell GDB+ that it may keep reading. */
1483 putc ('~', asmfile
);
1485 /* We need to write out info about what field this class
1486 uses as its "main" vtable pointer field, because if this
1487 field is inherited from a base class, GDB cannot necessarily
1488 figure out which field it's using in time. */
1489 if (TYPE_VFIELD (type
))
1491 putc ('%', asmfile
);
1492 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0);
1494 putc (';', asmfile
);
1500 /* We must use the same test here as we use in the DBX_NO_XREFS case
1501 above. We simplify it a bit since an enum will never have a variable
1503 if ((TYPE_NAME (type
) != 0
1504 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1505 && DECL_IGNORED_P (TYPE_NAME (type
)))
1507 || !COMPLETE_TYPE_P (type
))
1509 fprintf (asmfile
, "xe");
1511 dbxout_type_name (type
);
1512 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1513 fprintf (asmfile
, ":");
1516 #ifdef DBX_OUTPUT_ENUM
1517 DBX_OUTPUT_ENUM (asmfile
, type
);
1519 if (use_gnu_debug_info_extensions
1520 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1521 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1522 putc ('e', asmfile
);
1524 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1526 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)));
1527 if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == 0)
1528 fprintf (asmfile
, HOST_WIDE_INT_PRINT_UNSIGNED
,
1529 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1530 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == -1
1531 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (TREE_VALUE (tem
)) < 0)
1532 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1533 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1535 print_int_cst_octal (TREE_VALUE (tem
));
1536 fprintf (asmfile
, ",");
1537 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)));
1538 if (TREE_CHAIN (tem
) != 0)
1543 putc (';', asmfile
);
1549 putc ('*', asmfile
);
1551 dbxout_type (TREE_TYPE (type
), 0);
1555 if (use_gnu_debug_info_extensions
)
1557 have_used_extensions
= 1;
1558 putc ('#', asmfile
);
1561 /* Write the argument types out longhand. */
1562 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0);
1563 putc (',', asmfile
);
1565 dbxout_type (TREE_TYPE (type
), 0);
1566 dbxout_args (TYPE_ARG_TYPES (type
));
1567 putc (';', asmfile
);
1572 /* Treat it as a function type. */
1573 dbxout_type (TREE_TYPE (type
), 0);
1578 if (use_gnu_debug_info_extensions
)
1580 have_used_extensions
= 1;
1581 putc ('@', asmfile
);
1583 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0);
1584 putc (',', asmfile
);
1586 dbxout_type (TREE_TYPE (type
), 0);
1590 /* Should print as an int, because it is really
1592 dbxout_type (integer_type_node
, 0);
1596 case REFERENCE_TYPE
:
1597 if (use_gnu_debug_info_extensions
)
1598 have_used_extensions
= 1;
1599 putc (use_gnu_debug_info_extensions
? '&' : '*', asmfile
);
1601 dbxout_type (TREE_TYPE (type
), 0);
1605 putc ('f', asmfile
);
1607 dbxout_type (TREE_TYPE (type
), 0);
1615 /* Print the value of integer constant C, in octal,
1616 handling double precision. */
1619 print_int_cst_octal (c
)
1622 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (c
);
1623 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (c
);
1624 int excess
= (3 - (HOST_BITS_PER_WIDE_INT
% 3));
1625 unsigned int width
= TYPE_PRECISION (TREE_TYPE (c
));
1627 /* GDB wants constants with no extra leading "1" bits, so
1628 we need to remove any sign-extension that might be
1630 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
1632 else if (width
> HOST_BITS_PER_WIDE_INT
)
1633 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
1634 else if (width
== HOST_BITS_PER_WIDE_INT
)
1637 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
1639 fprintf (asmfile
, "0");
1643 print_octal (high
, HOST_BITS_PER_WIDE_INT
/ 3);
1644 print_octal (low
, HOST_BITS_PER_WIDE_INT
/ 3);
1648 unsigned HOST_WIDE_INT beg
= high
>> excess
;
1649 unsigned HOST_WIDE_INT middle
1650 = ((high
& (((HOST_WIDE_INT
) 1 << excess
) - 1)) << (3 - excess
)
1651 | (low
>> (HOST_BITS_PER_WIDE_INT
/ 3 * 3)));
1652 unsigned HOST_WIDE_INT end
1653 = low
& (((unsigned HOST_WIDE_INT
) 1
1654 << (HOST_BITS_PER_WIDE_INT
/ 3 * 3))
1657 fprintf (asmfile
, "%o%01o", (int) beg
, (int) middle
);
1658 print_octal (end
, HOST_BITS_PER_WIDE_INT
/ 3);
1663 print_octal (value
, digits
)
1664 unsigned HOST_WIDE_INT value
;
1669 for (i
= digits
- 1; i
>= 0; i
--)
1670 fprintf (asmfile
, "%01o", (int) ((value
>> (3 * i
)) & 7));
1673 /* Output the name of type TYPE, with no punctuation.
1674 Such names can be set up either by typedef declarations
1675 or by struct, enum and union tags. */
1678 dbxout_type_name (type
)
1682 if (TYPE_NAME (type
) == 0)
1684 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
1686 t
= TYPE_NAME (type
);
1688 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1690 t
= DECL_NAME (TYPE_NAME (type
));
1695 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
1696 CHARS (IDENTIFIER_LENGTH (t
));
1699 /* Output a .stabs for the symbol defined by DECL,
1700 which must be a ..._DECL node in the normal namespace.
1701 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1702 LOCAL is nonzero if the scope is less than the entire file.
1703 Return 1 if a stabs might have been emitted. */
1706 dbxout_symbol (decl
, local
)
1708 int local ATTRIBUTE_UNUSED
;
1710 tree type
= TREE_TYPE (decl
);
1711 tree context
= NULL_TREE
;
1714 /* Cast avoids warning in old compilers. */
1715 current_sym_code
= (STAB_CODE_TYPE
) 0;
1716 current_sym_value
= 0;
1717 current_sym_addr
= 0;
1719 /* Ignore nameless syms, but don't ignore type tags. */
1721 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
1722 || DECL_IGNORED_P (decl
))
1725 dbxout_prepare_symbol (decl
);
1727 /* The output will always start with the symbol name,
1728 so always count that in the length-output-so-far. */
1730 if (DECL_NAME (decl
) != 0)
1731 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
1733 switch (TREE_CODE (decl
))
1736 /* Enum values are defined by defining the enum type. */
1740 if (DECL_RTL (decl
) == 0)
1742 if (DECL_EXTERNAL (decl
))
1744 /* Don't mention a nested function under its parent. */
1745 context
= decl_function_context (decl
);
1746 if (context
== current_function_decl
)
1748 if (GET_CODE (DECL_RTL (decl
)) != MEM
1749 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
1753 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
1754 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1755 TREE_PUBLIC (decl
) ? 'F' : 'f');
1758 current_sym_code
= N_FUN
;
1759 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1761 if (TREE_TYPE (type
))
1762 dbxout_type (TREE_TYPE (type
), 0);
1764 dbxout_type (void_type_node
, 0);
1766 /* For a nested function, when that function is compiled,
1767 mention the containing function name
1768 as well as (since dbx wants it) our own assembler-name. */
1770 fprintf (asmfile
, ",%s,%s",
1771 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1772 IDENTIFIER_POINTER (DECL_NAME (context
)));
1774 dbxout_finish_symbol (decl
);
1779 /* This seems all wrong. Outputting most kinds of types gives no name
1780 at all. A true definition gives no name; a cross-ref for a
1781 structure can give the tag name, but not a type name.
1782 It seems that no typedef name is defined by outputting a type. */
1784 /* If this typedef name was defined by outputting the type,
1785 don't duplicate it. */
1786 if (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
== TYPE_DEFINED
1787 && TYPE_NAME (TREE_TYPE (decl
)) == decl
)
1790 /* Don't output the same typedef twice.
1791 And don't output what language-specific stuff doesn't want output. */
1792 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
1801 if (DECL_NAME (decl
))
1803 /* Nonzero means we must output a tag as well as a typedef. */
1806 /* Handle the case of a C++ structure or union
1807 where the TYPE_NAME is a TYPE_DECL
1808 which gives both a typedef name and a tag. */
1809 /* dbx requires the tag first and the typedef second. */
1810 if ((TREE_CODE (type
) == RECORD_TYPE
1811 || TREE_CODE (type
) == UNION_TYPE
1812 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1813 && TYPE_NAME (type
) == decl
1814 && !(use_gnu_debug_info_extensions
&& have_used_extensions
)
1815 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
1816 /* Distinguish the implicit typedefs of C++
1817 from explicit ones that might be found in C. */
1818 && DECL_ARTIFICIAL (decl
)
1819 /* Do not generate a tag for records of variable size,
1820 since this type can not be properly described in the
1821 DBX format, and it confuses some tools such as objdump. */
1822 && host_integerp (TYPE_SIZE (type
), 1))
1824 tree name
= TYPE_NAME (type
);
1825 if (TREE_CODE (name
) == TYPE_DECL
)
1826 name
= DECL_NAME (name
);
1828 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1829 current_sym_value
= 0;
1830 current_sym_addr
= 0;
1831 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1833 fprintf (asmfile
, "%s\"%s:T", ASM_STABS_OP
,
1834 IDENTIFIER_POINTER (name
));
1835 dbxout_type (type
, 1);
1836 dbxout_finish_symbol (NULL_TREE
);
1839 /* Output typedef name. */
1840 fprintf (asmfile
, "%s\"%s:", ASM_STABS_OP
,
1841 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1843 /* Short cut way to output a tag also. */
1844 if ((TREE_CODE (type
) == RECORD_TYPE
1845 || TREE_CODE (type
) == UNION_TYPE
1846 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1847 && TYPE_NAME (type
) == decl
1848 /* Distinguish the implicit typedefs of C++
1849 from explicit ones that might be found in C. */
1850 && DECL_ARTIFICIAL (decl
))
1852 if (use_gnu_debug_info_extensions
&& have_used_extensions
)
1854 putc ('T', asmfile
);
1855 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
1857 #if 0 /* Now we generate the tag for this case up above. */
1863 putc ('t', asmfile
);
1864 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1866 dbxout_type (type
, 1);
1867 dbxout_finish_symbol (decl
);
1871 /* Don't output a tag if this is an incomplete type. This prevents
1872 the sun4 Sun OS 4.x dbx from crashing. */
1874 if (tag_needed
&& TYPE_NAME (type
) != 0
1875 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
1876 || (DECL_NAME (TYPE_NAME (type
)) != 0))
1877 && COMPLETE_TYPE_P (type
)
1878 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1880 /* For a TYPE_DECL with no name, but the type has a name,
1882 This is what represents `struct foo' with no typedef. */
1883 /* In C++, the name of a type is the corresponding typedef.
1884 In C, it is an IDENTIFIER_NODE. */
1885 tree name
= TYPE_NAME (type
);
1886 if (TREE_CODE (name
) == TYPE_DECL
)
1887 name
= DECL_NAME (name
);
1889 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1890 current_sym_value
= 0;
1891 current_sym_addr
= 0;
1892 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1894 fprintf (asmfile
, "%s\"%s:T", ASM_STABS_OP
,
1895 IDENTIFIER_POINTER (name
));
1896 dbxout_type (type
, 1);
1897 dbxout_finish_symbol (NULL_TREE
);
1901 /* If an enum type has no name, it cannot be referred to,
1902 but we must output it anyway, since the enumeration constants
1903 can be referred to. */
1904 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
1906 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1907 current_sym_value
= 0;
1908 current_sym_addr
= 0;
1909 current_sym_nchars
= 2;
1911 /* Some debuggers fail when given NULL names, so give this a
1912 harmless name of ` '. */
1913 fprintf (asmfile
, "%s\" :T", ASM_STABS_OP
);
1914 dbxout_type (type
, 1);
1915 dbxout_finish_symbol (NULL_TREE
);
1918 /* Prevent duplicate output of a typedef. */
1919 TREE_ASM_WRITTEN (decl
) = 1;
1924 /* Parm decls go in their own separate chains
1925 and are output by dbxout_reg_parms and dbxout_parms. */
1929 /* Named return value, treat like a VAR_DECL. */
1931 if (! DECL_RTL_SET_P (decl
))
1933 /* Don't mention a variable that is external.
1934 Let the file that defines it describe it. */
1935 if (DECL_EXTERNAL (decl
))
1938 /* If the variable is really a constant
1939 and not written in memory, inform the debugger. */
1940 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
1941 && DECL_INITIAL (decl
) != 0
1942 && host_integerp (DECL_INITIAL (decl
), 0)
1943 && ! TREE_ASM_WRITTEN (decl
)
1944 && (DECL_CONTEXT (decl
) == NULL_TREE
1945 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
))
1947 if (TREE_PUBLIC (decl
) == 0)
1949 /* The sun4 assembler does not grok this. */
1950 const char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1952 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
1953 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
1955 HOST_WIDE_INT ival
= tree_low_cst (DECL_INITIAL (decl
), 0);
1956 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1957 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile
, name
, ival
);
1959 fprintf (asmfile
, "%s\"%s:c=i", ASM_STABS_OP
, name
);
1961 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, ival
);
1962 fprintf (asmfile
, "\",0x%x,0,0,0\n", N_LSYM
);
1966 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
1968 /* don't know how to do this yet. */
1972 /* else it is something we handle like a normal variable. */
1975 SET_DECL_RTL (decl
, eliminate_regs (DECL_RTL (decl
), 0, NULL_RTX
));
1976 #ifdef LEAF_REG_REMAP
1977 if (current_function_uses_only_leaf_regs
)
1978 leaf_renumber_regs_insn (DECL_RTL (decl
));
1981 result
= dbxout_symbol_location (decl
, type
, 0, DECL_RTL (decl
));
1990 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1991 Add SUFFIX to its name, if SUFFIX is not 0.
1992 Describe the variable as residing in HOME
1993 (usually HOME is DECL_RTL (DECL), but not always).
1994 Returns 1 if the stab was really emitted. */
1997 dbxout_symbol_location (decl
, type
, suffix
, home
)
2005 /* Don't mention a variable at all
2006 if it was completely optimized into nothingness.
2008 If the decl was from an inline function, then its rtl
2009 is not identically the rtl that was used in this
2010 particular compilation. */
2011 if (GET_CODE (home
) == REG
)
2013 regno
= REGNO (home
);
2014 if (regno
>= FIRST_PSEUDO_REGISTER
)
2017 else if (GET_CODE (home
) == SUBREG
)
2021 while (GET_CODE (value
) == SUBREG
)
2022 value
= SUBREG_REG (value
);
2023 if (GET_CODE (value
) == REG
)
2025 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
2028 regno
= REGNO (alter_subreg (home
));
2031 /* The kind-of-variable letter depends on where
2032 the variable is and on the scope of its name:
2033 G and N_GSYM for static storage and global scope,
2034 S for static storage and file scope,
2035 V for static storage and local scope,
2036 for those two, use N_LCSYM if data is in bss segment,
2037 N_STSYM if in data segment, N_FUN otherwise.
2038 (We used N_FUN originally, then changed to N_STSYM
2039 to please GDB. However, it seems that confused ld.
2040 Now GDB has been fixed to like N_FUN, says Kingdon.)
2041 no letter at all, and N_LSYM, for auto variable,
2042 r and N_RSYM for register variable. */
2044 if (GET_CODE (home
) == MEM
2045 && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2047 if (TREE_PUBLIC (decl
))
2050 current_sym_code
= N_GSYM
;
2054 current_sym_addr
= XEXP (home
, 0);
2056 letter
= decl_function_context (decl
) ? 'V' : 'S';
2058 /* This should be the same condition as in assemble_variable, but
2059 we don't have access to dont_output_data here. So, instead,
2060 we rely on the fact that error_mark_node initializers always
2061 end up in bss for C++ and never end up in bss for C. */
2062 if (DECL_INITIAL (decl
) == 0
2063 || (!strcmp (lang_identify (), "cplusplus")
2064 && DECL_INITIAL (decl
) == error_mark_node
))
2065 current_sym_code
= N_LCSYM
;
2066 else if (DECL_IN_TEXT_SECTION (decl
))
2067 /* This is not quite right, but it's the closest
2068 of all the codes that Unix defines. */
2069 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
2072 /* Ultrix `as' seems to need this. */
2073 #ifdef DBX_STATIC_STAB_DATA_SECTION
2076 current_sym_code
= N_STSYM
;
2080 else if (regno
>= 0)
2083 current_sym_code
= N_RSYM
;
2084 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
2086 else if (GET_CODE (home
) == MEM
2087 && (GET_CODE (XEXP (home
, 0)) == MEM
2088 || (GET_CODE (XEXP (home
, 0)) == REG
2089 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
2090 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
2091 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2092 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
2095 /* If the value is indirect by memory or by a register
2096 that isn't the frame pointer
2097 then it means the object is variable-sized and address through
2098 that register or stack slot. DBX has no way to represent this
2099 so all we can do is output the variable as a pointer.
2100 If it's not a parameter, ignore it.
2101 (VAR_DECLs like this can be made by integrate.c.) */
2103 if (GET_CODE (XEXP (home
, 0)) == REG
)
2106 current_sym_code
= N_RSYM
;
2107 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
2111 current_sym_code
= N_LSYM
;
2112 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2113 We want the value of that CONST_INT. */
2115 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
2118 /* Effectively do build_pointer_type, but don't cache this type,
2119 since it might be temporary whereas the type it points to
2120 might have been saved for inlining. */
2121 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2122 type
= make_node (POINTER_TYPE
);
2123 TREE_TYPE (type
) = TREE_TYPE (decl
);
2125 else if (GET_CODE (home
) == MEM
2126 && GET_CODE (XEXP (home
, 0)) == REG
)
2128 current_sym_code
= N_LSYM
;
2129 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2131 else if (GET_CODE (home
) == MEM
2132 && GET_CODE (XEXP (home
, 0)) == PLUS
2133 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
2135 current_sym_code
= N_LSYM
;
2136 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2137 We want the value of that CONST_INT. */
2138 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2140 else if (GET_CODE (home
) == MEM
2141 && GET_CODE (XEXP (home
, 0)) == CONST
)
2143 /* Handle an obscure case which can arise when optimizing and
2144 when there are few available registers. (This is *always*
2145 the case for i386/i486 targets). The RTL looks like
2146 (MEM (CONST ...)) even though this variable is a local `auto'
2147 or a local `register' variable. In effect, what has happened
2148 is that the reload pass has seen that all assignments and
2149 references for one such a local variable can be replaced by
2150 equivalent assignments and references to some static storage
2151 variable, thereby avoiding the need for a register. In such
2152 cases we're forced to lie to debuggers and tell them that
2153 this variable was itself `static'. */
2154 current_sym_code
= N_LCSYM
;
2156 current_sym_addr
= XEXP (XEXP (home
, 0), 0);
2158 else if (GET_CODE (home
) == CONCAT
)
2162 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
2163 for example), then there is no easy way to figure out
2164 what SUBTYPE should be. So, we give up. */
2165 if (TREE_CODE (type
) != COMPLEX_TYPE
)
2168 subtype
= TREE_TYPE (type
);
2170 /* If the variable's storage is in two parts,
2171 output each as a separate stab with a modified name. */
2172 if (WORDS_BIG_ENDIAN
)
2173 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
2175 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
2177 /* Cast avoids warning in old compilers. */
2178 current_sym_code
= (STAB_CODE_TYPE
) 0;
2179 current_sym_value
= 0;
2180 current_sym_addr
= 0;
2181 dbxout_prepare_symbol (decl
);
2183 if (WORDS_BIG_ENDIAN
)
2184 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
2186 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
2190 /* Address might be a MEM, when DECL is a variable-sized object.
2191 Or it might be const0_rtx, meaning previous passes
2192 want us to ignore this variable. */
2195 /* Ok, start a symtab entry and output the variable name. */
2198 #ifdef DBX_STATIC_BLOCK_START
2199 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
2202 dbxout_symbol_name (decl
, suffix
, letter
);
2203 dbxout_type (type
, 0);
2204 dbxout_finish_symbol (decl
);
2206 #ifdef DBX_STATIC_BLOCK_END
2207 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
2212 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2213 Then output LETTER to indicate the kind of location the symbol has. */
2216 dbxout_symbol_name (decl
, suffix
, letter
)
2223 if (DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
)))
2224 /* One slight hitch: if this is a VAR_DECL which is a static
2225 class member, we must put out the mangled name instead of the
2226 DECL_NAME. Note also that static member (variable) names DO NOT begin
2227 with underscores in .stabs directives. */
2228 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2230 /* ...but if we're function-local, we don't want to include the junk
2231 added by ASM_FORMAT_PRIVATE_NAME. */
2232 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
2236 fprintf (asmfile
, "%s\"%s%s:", ASM_STABS_OP
, name
,
2237 (suffix
? suffix
: ""));
2239 if (letter
) putc (letter
, asmfile
);
2243 dbxout_prepare_symbol (decl
)
2244 tree decl ATTRIBUTE_UNUSED
;
2247 const char *filename
= DECL_SOURCE_FILE (decl
);
2249 dbxout_source_file (asmfile
, filename
);
2254 dbxout_finish_symbol (sym
)
2257 #ifdef DBX_FINISH_SYMBOL
2258 DBX_FINISH_SYMBOL (sym
);
2261 if (use_gnu_debug_info_extensions
&& sym
!= 0)
2262 line
= DECL_SOURCE_LINE (sym
);
2264 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
2265 if (current_sym_addr
)
2266 output_addr_const (asmfile
, current_sym_addr
);
2268 fprintf (asmfile
, "%d", current_sym_value
);
2269 putc ('\n', asmfile
);
2273 /* Output definitions of all the decls in a chain. Return non-zero if
2274 anything was output */
2283 result
+= dbxout_symbol (syms
, 1);
2284 syms
= TREE_CHAIN (syms
);
2289 /* The following two functions output definitions of function parameters.
2290 Each parameter gets a definition locating it in the parameter list.
2291 Each parameter that is a register variable gets a second definition
2292 locating it in the register.
2294 Printing or argument lists in gdb uses the definitions that
2295 locate in the parameter list. But reference to the variable in
2296 expressions uses preferentially the definition as a register. */
2298 /* Output definitions, referring to storage in the parmlist,
2299 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2302 dbxout_parms (parms
)
2305 for (; parms
; parms
= TREE_CHAIN (parms
))
2306 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
2308 dbxout_prepare_symbol (parms
);
2310 /* Perform any necessary register eliminations on the parameter's rtl,
2311 so that the debugging output will be accurate. */
2312 DECL_INCOMING_RTL (parms
)
2313 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
2314 SET_DECL_RTL (parms
, eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
));
2315 #ifdef LEAF_REG_REMAP
2316 if (current_function_uses_only_leaf_regs
)
2318 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
2319 leaf_renumber_regs_insn (DECL_RTL (parms
));
2323 if (PARM_PASSED_IN_MEMORY (parms
))
2325 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
2327 /* ??? Here we assume that the parm address is indexed
2328 off the frame pointer or arg pointer.
2329 If that is not true, we produce meaningless results,
2330 but do not crash. */
2331 if (GET_CODE (addr
) == PLUS
2332 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
2333 current_sym_value
= INTVAL (XEXP (addr
, 1));
2335 current_sym_value
= 0;
2337 current_sym_code
= N_PSYM
;
2338 current_sym_addr
= 0;
2341 if (DECL_NAME (parms
))
2343 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2345 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2346 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2347 DBX_MEMPARM_STABS_LETTER
);
2351 current_sym_nchars
= 8;
2352 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2353 DBX_MEMPARM_STABS_LETTER
);
2356 /* It is quite tempting to use:
2358 dbxout_type (TREE_TYPE (parms), 0);
2360 as the next statement, rather than using DECL_ARG_TYPE(), so
2361 that gcc reports the actual type of the parameter, rather
2362 than the promoted type. This certainly makes GDB's life
2363 easier, at least for some ports. The change is a bad idea
2364 however, since GDB expects to be able access the type without
2365 performing any conversions. So for example, if we were
2366 passing a float to an unprototyped function, gcc will store a
2367 double on the stack, but if we emit a stab saying the type is a
2368 float, then gdb will only read in a single value, and this will
2369 produce an erropneous value. */
2370 dbxout_type (DECL_ARG_TYPE (parms
), 0);
2371 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
2372 dbxout_finish_symbol (parms
);
2374 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
2377 char regparm_letter
;
2379 /* Parm passed in registers and lives in registers or nowhere. */
2381 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2382 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2383 current_sym_addr
= 0;
2385 /* If parm lives in a register, use that register;
2386 pretend the parm was passed there. It would be more consistent
2387 to describe the register where the parm was passed,
2388 but in practice that register usually holds something else.
2390 If we use DECL_RTL, then we must use the declared type of
2391 the variable, not the type that it arrived in. */
2392 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2394 best_rtl
= DECL_RTL (parms
);
2395 parm_type
= TREE_TYPE (parms
);
2397 /* If the parm lives nowhere, use the register where it was
2398 passed. It is also better to use the declared type here. */
2401 best_rtl
= DECL_INCOMING_RTL (parms
);
2402 parm_type
= TREE_TYPE (parms
);
2404 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
2407 if (DECL_NAME (parms
))
2409 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2410 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2411 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2416 current_sym_nchars
= 8;
2417 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2421 dbxout_type (parm_type
, 0);
2422 dbxout_finish_symbol (parms
);
2424 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2425 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
2426 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
2427 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
2428 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2429 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
2433 /* Parm was passed via invisible reference.
2434 That is, its address was passed in a register.
2435 Output it as if it lived in that register.
2436 The debugger will know from the type
2437 that it was actually passed by invisible reference. */
2439 char regparm_letter
;
2440 /* Parm passed in registers and lives in registers or nowhere. */
2442 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2443 if (use_gnu_debug_info_extensions
)
2444 regparm_letter
= GDB_INV_REF_REGPARM_STABS_LETTER
;
2446 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2448 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2449 If it is an unallocated pseudo-reg, then use the register where
2450 it was passed instead. */
2451 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
2452 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
2454 current_sym_value
= REGNO (DECL_INCOMING_RTL (parms
));
2456 current_sym_addr
= 0;
2459 if (DECL_NAME (parms
))
2461 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2463 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2464 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2469 current_sym_nchars
= 8;
2470 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2474 dbxout_type (TREE_TYPE (parms
), 0);
2475 dbxout_finish_symbol (parms
);
2477 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2478 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
2480 /* Parm was passed via invisible reference, with the reference
2481 living on the stack. DECL_RTL looks like
2482 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
2483 could look like (MEM (MEM (REG))). */
2484 const char *decl_name
= (DECL_NAME (parms
)
2485 ? IDENTIFIER_POINTER (DECL_NAME (parms
))
2487 if (GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 0)) == REG
)
2488 current_sym_value
= 0;
2491 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
2492 current_sym_addr
= 0;
2495 fprintf (asmfile
, "%s\"%s:v", ASM_STABS_OP
, decl_name
);
2496 dbxout_type (TREE_TYPE (parms
), 0);
2497 dbxout_finish_symbol (parms
);
2499 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2500 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
2501 /* ??? A constant address for a parm can happen
2502 when the reg it lives in is equiv to a constant in memory.
2503 Should make this not happen, after 2.4. */
2504 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
2506 /* Parm was passed in registers but lives on the stack. */
2508 current_sym_code
= N_PSYM
;
2509 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2510 in which case we want the value of that CONST_INT,
2512 in which case we use a value of zero. */
2513 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
)
2514 current_sym_value
= 0;
2517 = INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
2519 current_sym_addr
= 0;
2521 /* Make a big endian correction if the mode of the type of the
2522 parameter is not the same as the mode of the rtl. */
2523 if (BYTES_BIG_ENDIAN
2524 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
2525 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
2527 current_sym_value
+=
2528 GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
2529 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
)));
2533 if (DECL_NAME (parms
))
2536 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2538 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2539 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2540 DBX_MEMPARM_STABS_LETTER
);
2544 current_sym_nchars
= 8;
2545 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2546 DBX_MEMPARM_STABS_LETTER
);
2550 = DEBUGGER_ARG_OFFSET (current_sym_value
,
2551 XEXP (DECL_RTL (parms
), 0));
2552 dbxout_type (TREE_TYPE (parms
), 0);
2553 dbxout_finish_symbol (parms
);
2558 /* Output definitions for the places where parms live during the function,
2559 when different from where they were passed, when the parms were passed
2562 It is not useful to do this for parms passed in registers
2563 that live during the function in different registers, because it is
2564 impossible to look in the passed register for the passed value,
2565 so we use the within-the-function register to begin with.
2567 PARMS is a chain of PARM_DECL nodes. */
2570 dbxout_reg_parms (parms
)
2573 for (; parms
; parms
= TREE_CHAIN (parms
))
2574 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
2576 dbxout_prepare_symbol (parms
);
2578 /* Report parms that live in registers during the function
2579 but were passed in memory. */
2580 if (GET_CODE (DECL_RTL (parms
)) == REG
2581 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2582 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2583 0, DECL_RTL (parms
));
2584 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
2585 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2586 0, DECL_RTL (parms
));
2587 /* Report parms that live in memory but not where they were passed. */
2588 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2589 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
2590 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2591 0, DECL_RTL (parms
));
2595 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2596 output definitions of those names, in raw form */
2604 putc (',', asmfile
);
2605 dbxout_type (TREE_VALUE (args
), 0);
2607 args
= TREE_CHAIN (args
);
2611 /* Given a chain of ..._TYPE nodes,
2612 find those which have typedef names and output those names.
2613 This is to ensure those types get output. */
2616 dbxout_types (types
)
2617 register tree types
;
2621 if (TYPE_NAME (types
)
2622 && TREE_CODE (TYPE_NAME (types
)) == TYPE_DECL
2623 && ! TREE_ASM_WRITTEN (TYPE_NAME (types
)))
2624 dbxout_symbol (TYPE_NAME (types
), 1);
2625 types
= TREE_CHAIN (types
);
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 */