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 GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
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. */
88 #include "langhooks.h"
90 #ifdef XCOFF_DEBUGGING_INFO
95 #define ASM_STABS_OP "\t.stabs\t"
99 #define ASM_STABN_OP "\t.stabn\t"
102 #ifndef DBX_TYPE_DECL_STABS_CODE
103 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
106 #ifndef DBX_STATIC_CONST_VAR_CODE
107 #define DBX_STATIC_CONST_VAR_CODE N_FUN
110 #ifndef DBX_REGPARM_STABS_CODE
111 #define DBX_REGPARM_STABS_CODE N_RSYM
114 #ifndef DBX_REGPARM_STABS_LETTER
115 #define DBX_REGPARM_STABS_LETTER 'P'
118 /* This is used for parameters passed by invisible reference in a register. */
119 #ifndef GDB_INV_REF_REGPARM_STABS_LETTER
120 #define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
123 #ifndef DBX_MEMPARM_STABS_LETTER
124 #define DBX_MEMPARM_STABS_LETTER 'p'
127 #ifndef FILE_NAME_JOINER
128 #define FILE_NAME_JOINER "/"
131 /* GDB needs to know that the stabs were generated by GCC. We emit an
132 N_OPT stab at the beginning of the source file to indicate this.
133 The string is historical, and different on a very few targets. */
134 #ifndef STABS_GCC_MARKER
135 #define STABS_GCC_MARKER "gcc2_compiled."
138 /* Typical USG systems don't have stab.h, and they also have
139 no use for DBX-format debugging info. */
141 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
143 /* Nonzero if we have actually used any of the GDB extensions
144 to the debugging format. The idea is that we use them for the
145 first time only if there's a strong reason, but once we have done that,
146 we use them whenever convenient. */
148 static int have_used_extensions
= 0;
150 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
151 for the N_SO filename stabs label. */
153 #if defined (DBX_DEBUGGING_INFO) && !defined (DBX_OUTPUT_SOURCE_FILENAME)
154 static int source_label_number
= 1;
157 #ifdef DEBUG_SYMS_TEXT
158 #define FORCE_TEXT text_section ();
165 #define STAB_CODE_TYPE enum __stab_debug_code
167 /* 1 if PARM is passed to this function in memory. */
169 #define PARM_PASSED_IN_MEMORY(PARM) \
170 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
172 /* A C expression for the integer offset value of an automatic variable
173 (N_LSYM) having address X (an RTX). */
174 #ifndef DEBUGGER_AUTO_OFFSET
175 #define DEBUGGER_AUTO_OFFSET(X) \
176 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
179 /* A C expression for the integer offset value of an argument (N_PSYM)
180 having address X (an RTX). The nominal offset is OFFSET. */
181 #ifndef DEBUGGER_ARG_OFFSET
182 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
185 /* Stream for writing to assembler file. */
187 static FILE *asmfile
;
189 /* Last source file name mentioned in a NOTE insn. */
191 static const char *lastfile
;
193 /* Current working directory. */
195 static const char *cwd
;
197 enum typestatus
{TYPE_UNSEEN
, TYPE_XREF
, TYPE_DEFINED
};
199 /* Structure recording information about a C data type.
200 The status element says whether we have yet output
201 the definition of the type. TYPE_XREF says we have
202 output it as a cross-reference only.
203 The file_number and type_number elements are used if DBX_USE_BINCL
208 enum typestatus status
;
215 /* Vector recording information about C data types.
216 When we first notice a data type (a tree node),
217 we assign it a number using next_type_number.
218 That is its index in this vector. */
220 struct typeinfo
*typevec
;
222 /* Number of elements of space allocated in `typevec'. */
224 static int typevec_len
;
226 /* In dbx output, each type gets a unique number.
227 This is the number for the next type output.
228 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
230 static int next_type_number
;
234 /* When using N_BINCL in dbx output, each type number is actually a
235 pair of the file number and the type number within the file.
236 This is a stack of input files. */
240 struct dbx_file
*next
;
242 int next_type_number
;
245 /* This is the top of the stack. */
247 static struct dbx_file
*current_file
;
249 /* This is the next file number to use. */
251 static int next_file_number
;
253 #endif /* DBX_USE_BINCL */
255 /* These variables are for dbxout_symbol to communicate to
256 dbxout_finish_symbol.
257 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
258 current_sym_value and current_sym_addr are two ways to address the
259 value to store in the symtab entry.
260 current_sym_addr if nonzero represents the value as an rtx.
261 If that is zero, current_sym_value is used. This is used
262 when the value is an offset (such as for auto variables,
263 register variables and parms). */
265 static STAB_CODE_TYPE current_sym_code
;
266 static int current_sym_value
;
267 static rtx current_sym_addr
;
269 /* Number of chars of symbol-description generated so far for the
270 current symbol. Used by CHARS and CONTIN. */
272 static int current_sym_nchars
;
274 /* Report having output N chars of the current symbol-description. */
276 #define CHARS(N) (current_sym_nchars += (N))
278 /* Break the current symbol-description, generating a continuation,
279 if it has become long. */
281 #ifndef DBX_CONTIN_LENGTH
282 #define DBX_CONTIN_LENGTH 80
285 #if DBX_CONTIN_LENGTH > 0
287 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
289 #define CONTIN do { } while (0)
292 static void dbxout_init
PARAMS ((const char *));
293 static void dbxout_finish
PARAMS ((const char *));
294 static void dbxout_start_source_file
PARAMS ((unsigned, const char *));
295 static void dbxout_end_source_file
PARAMS ((unsigned));
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 print_wide_int
PARAMS ((HOST_WIDE_INT
));
310 static void dbxout_type_name
PARAMS ((tree
));
311 static int dbxout_symbol_location
PARAMS ((tree
, tree
, const char *, rtx
));
312 static void dbxout_symbol_name
PARAMS ((tree
, const char *, int));
313 static void dbxout_prepare_symbol
PARAMS ((tree
));
314 static void dbxout_finish_symbol
PARAMS ((tree
));
315 static void dbxout_block
PARAMS ((tree
, int, tree
));
316 static void dbxout_global_decl
PARAMS ((tree
));
318 /* The debug hooks structure. */
319 #if defined (DBX_DEBUGGING_INFO)
321 static void dbxout_source_line
PARAMS ((unsigned int, const char *));
322 static void dbxout_source_file
PARAMS ((FILE *, const char *));
323 static void dbxout_function_end
PARAMS ((void));
324 static void dbxout_begin_function
PARAMS ((tree
));
325 static void dbxout_begin_block
PARAMS ((unsigned, unsigned));
326 static void dbxout_end_block
PARAMS ((unsigned, unsigned));
327 static void dbxout_function_decl
PARAMS ((tree
));
329 struct gcc_debug_hooks dbx_debug_hooks
=
333 debug_nothing_int_charstar
,
334 debug_nothing_int_charstar
,
335 dbxout_start_source_file
,
336 dbxout_end_source_file
,
339 debug_true_tree
, /* ignore_block */
340 dbxout_source_line
, /* source_line */
341 dbxout_source_line
, /* begin_prologue: just output line info */
342 debug_nothing_int
, /* end_prologue */
343 debug_nothing_void
, /* end_epilogue */
344 #ifdef DBX_FUNCTION_FIRST
345 dbxout_begin_function
,
347 debug_nothing_tree
, /* begin_function */
349 debug_nothing_int
, /* end_function */
350 dbxout_function_decl
,
351 dbxout_global_decl
, /* global_decl */
352 debug_nothing_tree
, /* deferred_inline_function */
353 debug_nothing_tree
, /* outlining_inline_function */
354 debug_nothing_rtx
/* label */
356 #endif /* DBX_DEBUGGING_INFO */
358 #if defined (XCOFF_DEBUGGING_INFO)
359 struct gcc_debug_hooks xcoff_debug_hooks
=
363 debug_nothing_int_charstar
,
364 debug_nothing_int_charstar
,
365 dbxout_start_source_file
,
366 dbxout_end_source_file
,
367 xcoffout_begin_block
,
369 debug_true_tree
, /* ignore_block */
370 xcoffout_source_line
,
371 xcoffout_begin_prologue
, /* begin_prologue */
372 debug_nothing_int
, /* end_prologue */
373 xcoffout_end_epilogue
,
374 debug_nothing_tree
, /* begin_function */
375 xcoffout_end_function
,
376 debug_nothing_tree
, /* function_decl */
377 dbxout_global_decl
, /* global_decl */
378 debug_nothing_tree
, /* deferred_inline_function */
379 debug_nothing_tree
, /* outlining_inline_function */
380 debug_nothing_rtx
/* label */
382 #endif /* XCOFF_DEBUGGING_INFO */
384 #if defined (DBX_DEBUGGING_INFO)
386 dbxout_function_end ()
388 static int scope_labelno
= 0;
389 char lscope_label_name
[100];
390 /* Convert Ltext into the appropriate format for local labels in case
391 the system doesn't insert underscores in front of user generated
393 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
394 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Lscope", scope_labelno
);
397 /* By convention, GCC will mark the end of a function with an N_FUN
398 symbol and an empty string. */
399 fprintf (asmfile
, "%s\"\",%d,0,0,", ASM_STABS_OP
, N_FUN
);
400 assemble_name (asmfile
, lscope_label_name
);
402 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
403 fprintf (asmfile
, "\n");
405 #endif /* DBX_DEBUGGING_INFO */
407 /* At the beginning of compilation, start writing the symbol table.
408 Initialize `typevec' and output the standard data types of C. */
411 dbxout_init (input_file_name
)
412 const char *input_file_name
;
414 char ltext_label_name
[100];
415 tree syms
= getdecls ();
417 asmfile
= asm_out_file
;
420 typevec
= (struct typeinfo
*) xcalloc (typevec_len
, sizeof typevec
[0]);
422 /* Convert Ltext into the appropriate format for local labels in case
423 the system doesn't insert underscores in front of user generated
425 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
427 /* Put the current working directory in an N_SO symbol. */
428 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
429 but GDB always does. */
430 if (use_gnu_debug_info_extensions
)
433 if (!cwd
&& (cwd
= getpwd ()) && (!*cwd
|| cwd
[strlen (cwd
) - 1] != '/'))
434 cwd
= concat (cwd
, FILE_NAME_JOINER
, NULL
);
437 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
438 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile
, cwd
);
439 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
440 fprintf (asmfile
, "%s", ASM_STABS_OP
);
441 output_quoted_string (asmfile
, cwd
);
442 fprintf (asmfile
, ",%d,0,0,%s\n", N_SO
, <ext_label_name
[1]);
443 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
447 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
448 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
449 would give us an N_SOL, and we want an N_SO. */
450 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile
, input_file_name
);
451 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
452 /* We include outputting `Ltext:' here,
453 because that gives you a way to override it. */
454 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
455 fprintf (asmfile
, "%s", ASM_STABS_OP
);
456 output_quoted_string (asmfile
, input_file_name
);
457 fprintf (asmfile
, ",%d,0,0,%s\n",
458 N_SO
, <ext_label_name
[1]);
460 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Ltext", 0);
461 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
463 #ifdef DBX_OUTPUT_GCC_MARKER
464 DBX_OUTPUT_GCC_MARKER (asmfile
);
466 /* Emit an N_OPT stab to indicate that this file was compiled by GCC. */
467 fprintf (asmfile
, "%s\"%s\",%d,0,0,0\n",
468 ASM_STABS_OP
, STABS_GCC_MARKER
, N_OPT
);
471 lastfile
= input_file_name
;
473 next_type_number
= 1;
476 current_file
= (struct dbx_file
*) xmalloc (sizeof *current_file
);
477 current_file
->next
= NULL
;
478 current_file
->file_number
= 0;
479 current_file
->next_type_number
= 1;
480 next_file_number
= 1;
483 /* Make sure that types `int' and `char' have numbers 1 and 2.
484 Definitions of other integer types will refer to those numbers.
485 (Actually it should no longer matter what their numbers are.
486 Also, if any types with tags have been defined, dbxout_symbol
487 will output them first, so the numbers won't be 1 and 2. That
488 happens in C++. So it's a good thing it should no longer matter). */
490 #ifdef DBX_OUTPUT_STANDARD_TYPES
491 DBX_OUTPUT_STANDARD_TYPES (syms
);
493 dbxout_symbol (TYPE_NAME (integer_type_node
), 0);
494 dbxout_symbol (TYPE_NAME (char_type_node
), 0);
497 /* Get all permanent types that have typedef names,
498 and output them all, except for those already output. */
500 dbxout_typedefs (syms
);
503 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
504 in the reverse order from that which is found in SYMS. */
507 dbxout_typedefs (syms
)
512 dbxout_typedefs (TREE_CHAIN (syms
));
513 if (TREE_CODE (syms
) == TYPE_DECL
)
515 tree type
= TREE_TYPE (syms
);
517 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
518 && COMPLETE_TYPE_P (type
)
519 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
520 dbxout_symbol (TYPE_NAME (type
), 0);
525 /* Change to reading from a new source file. Generate a N_BINCL stab. */
528 dbxout_start_source_file (line
, filename
)
529 unsigned int line ATTRIBUTE_UNUSED
;
530 const char *filename ATTRIBUTE_UNUSED
;
533 struct dbx_file
*n
= (struct dbx_file
*) xmalloc (sizeof *n
);
535 n
->next
= current_file
;
536 n
->file_number
= next_file_number
++;
537 n
->next_type_number
= 1;
539 fprintf (asmfile
, "%s", ASM_STABS_OP
);
540 output_quoted_string (asmfile
, filename
);
541 fprintf (asmfile
, ",%d,0,0,0\n", N_BINCL
);
545 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
548 dbxout_end_source_file (line
)
549 unsigned int line ATTRIBUTE_UNUSED
;
552 struct dbx_file
*next
;
554 fprintf (asmfile
, "%s%d,0,0,0\n", ASM_STABN_OP
, N_EINCL
);
555 next
= current_file
->next
;
561 #if defined (DBX_DEBUGGING_INFO)
562 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
565 dbxout_source_file (file
, filename
)
567 const char *filename
;
569 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
571 #ifdef DBX_OUTPUT_SOURCE_FILENAME
572 DBX_OUTPUT_SOURCE_FILENAME (file
, filename
);
574 char ltext_label_name
[100];
576 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext",
577 source_label_number
);
578 fprintf (file
, "%s", ASM_STABS_OP
);
579 output_quoted_string (file
, filename
);
580 fprintf (file
, ",%d,0,0,%s\n", N_SOL
, <ext_label_name
[1]);
581 if (current_function_decl
!= NULL_TREE
582 && DECL_SECTION_NAME (current_function_decl
) != NULL_TREE
)
583 ; /* Don't change section amid function. */
586 ASM_OUTPUT_INTERNAL_LABEL (file
, "Ltext", source_label_number
);
587 source_label_number
++;
593 /* Output a line number symbol entry for source file FILENAME and line
597 dbxout_source_line (lineno
, filename
)
599 const char *filename
;
601 dbxout_source_file (asmfile
, filename
);
603 #ifdef ASM_OUTPUT_SOURCE_LINE
604 ASM_OUTPUT_SOURCE_LINE (asmfile
, lineno
);
606 fprintf (asmfile
, "%s%d,0,%d\n", ASM_STABD_OP
, N_SLINE
, lineno
);
610 /* Describe the beginning of an internal block within a function. */
613 dbxout_begin_block (line
, n
)
614 unsigned int line ATTRIBUTE_UNUSED
;
617 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "LBB", n
);
620 /* Describe the end line-number of an internal block within a function. */
623 dbxout_end_block (line
, n
)
624 unsigned int line ATTRIBUTE_UNUSED
;
627 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "LBE", n
);
630 /* Output dbx data for a function definition.
631 This includes a definition of the function name itself (a symbol),
632 definitions of the parameters (locating them in the parameter list)
633 and then output the block that makes up the function's body
634 (including all the auto variables of the function). */
637 dbxout_function_decl (decl
)
640 #ifndef DBX_FUNCTION_FIRST
641 dbxout_begin_function (decl
);
643 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
644 #ifdef DBX_OUTPUT_FUNCTION_END
645 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
647 if (use_gnu_debug_info_extensions
648 #if defined(NO_DBX_FUNCTION_END)
649 && ! NO_DBX_FUNCTION_END
651 && targetm
.have_named_sections
)
652 dbxout_function_end ();
655 #endif /* DBX_DEBUGGING_INFO */
657 /* Debug information for a global DECL. Called from toplev.c after
658 compilation proper has finished. */
660 dbxout_global_decl (decl
)
663 if (TREE_CODE (decl
) == VAR_DECL
664 && ! DECL_EXTERNAL (decl
)
665 && DECL_RTL_SET_P (decl
)) /* Not necessary? */
666 dbxout_symbol (decl
, 0);
669 /* At the end of compilation, finish writing the symbol table.
670 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
674 dbxout_finish (filename
)
675 const char *filename ATTRIBUTE_UNUSED
;
677 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
678 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asmfile
, filename
);
679 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
682 /* Output the index of a type. */
685 dbxout_type_index (type
)
688 #ifndef DBX_USE_BINCL
689 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
692 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
693 fprintf (asmfile
, "(%d,%d)", t
->file_number
, t
->type_number
);
698 #if DBX_CONTIN_LENGTH > 0
699 /* Continue a symbol-description that gets too big.
700 End one symbol table entry with a double-backslash
701 and start a new one, eventually producing something like
702 .stabs "start......\\",code,0,value
703 .stabs "...rest",code,0,value */
708 #ifdef DBX_CONTIN_CHAR
709 fprintf (asmfile
, "%c", DBX_CONTIN_CHAR
);
711 fprintf (asmfile
, "\\\\");
713 dbxout_finish_symbol (NULL_TREE
);
714 fprintf (asmfile
, "%s\"", ASM_STABS_OP
);
715 current_sym_nchars
= 0;
717 #endif /* DBX_CONTIN_LENGTH > 0 */
719 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
720 This must be a separate function because anonymous unions require
724 dbxout_type_fields (type
)
729 /* Output the name, type, position (in bits), size (in bits) of each
730 field that we can support. */
731 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
733 /* Omit here local type decls until we know how to support them. */
734 if (TREE_CODE (tem
) == TYPE_DECL
735 /* Omit fields whose position or size are variable or too large to
737 || (TREE_CODE (tem
) == FIELD_DECL
738 && (! host_integerp (bit_position (tem
), 0)
740 || ! host_integerp (DECL_SIZE (tem
), 1)))
741 /* Omit here the nameless fields that are used to skip bits. */
742 || DECL_IGNORED_P (tem
))
745 else if (TREE_CODE (tem
) != CONST_DECL
)
747 /* Continue the line if necessary,
748 but not before the first field. */
749 if (tem
!= TYPE_FIELDS (type
))
754 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem
)));
755 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem
)));
759 fprintf (asmfile
, ":");
763 if (use_gnu_debug_info_extensions
764 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
765 || TREE_CODE (tem
) != FIELD_DECL
))
767 have_used_extensions
= 1;
769 putc ((TREE_PRIVATE (tem
) ? '0'
770 : TREE_PROTECTED (tem
) ? '1' : '2'),
775 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
776 && DECL_BIT_FIELD_TYPE (tem
))
777 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0);
779 if (TREE_CODE (tem
) == VAR_DECL
)
781 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
783 tree name
= DECL_ASSEMBLER_NAME (tem
);
785 have_used_extensions
= 1;
786 fprintf (asmfile
, ":%s;", IDENTIFIER_POINTER (name
));
787 CHARS (IDENTIFIER_LENGTH (name
) + 2);
791 /* If TEM is non-static, GDB won't understand it. */
792 fprintf (asmfile
, ",0,0;");
799 print_wide_int (int_bit_position (tem
));
801 print_wide_int (tree_low_cst (DECL_SIZE (tem
), 1));
809 /* Subroutine of `dbxout_type_methods'. Output debug info about the
810 method described DECL. DEBUG_NAME is an encoding of the method's
811 type signature. ??? We may be able to do without DEBUG_NAME altogether
815 dbxout_type_method_1 (decl
, debug_name
)
817 const char *debug_name
;
821 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
823 else /* it's a METHOD_TYPE. */
825 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
826 /* A for normal functions.
827 B for `const' member functions.
828 C for `volatile' member functions.
829 D for `const volatile' member functions. */
830 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
832 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
835 if (DECL_VINDEX (decl
))
841 fprintf (asmfile
, ":%s;%c%c%c", debug_name
,
842 TREE_PRIVATE (decl
) ? '0'
843 : TREE_PROTECTED (decl
) ? '1' : '2', c1
, c2
);
844 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
)) + 6
845 - (debug_name
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
847 if (DECL_VINDEX (decl
) && host_integerp (DECL_VINDEX (decl
), 0))
849 print_wide_int (tree_low_cst (DECL_VINDEX (decl
), 0));
852 dbxout_type (DECL_CONTEXT (decl
), 0);
853 fprintf (asmfile
, ";");
858 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
862 dbxout_type_methods (type
)
865 /* C++: put out the method names and their parameter lists */
866 tree methods
= TYPE_METHODS (type
);
870 char formatted_type_identifier_length
[16];
871 int type_identifier_length
;
873 if (methods
== NULL_TREE
)
876 type_encoding
= DECL_NAME (TYPE_NAME (type
));
879 /* C++: Template classes break some assumptions made by this code about
880 the class names, constructor names, and encodings for assembler
881 label names. For now, disable output of dbx info for them. */
883 const char *ptr
= IDENTIFIER_POINTER (type_encoding
);
884 /* This should use index. (mrs) */
885 while (*ptr
&& *ptr
!= '<') ptr
++;
896 type_identifier_length
= IDENTIFIER_LENGTH (type_encoding
);
898 sprintf (formatted_type_identifier_length
, "%d", type_identifier_length
);
900 if (TREE_CODE (methods
) != TREE_VEC
)
902 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
903 fndecl
= TREE_VEC_ELT (methods
, 0);
905 fndecl
= TREE_VEC_ELT (methods
, 1);
911 /* Group together all the methods for the same operation.
912 These differ in the types of the arguments. */
913 for (last
= NULL_TREE
;
914 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
915 fndecl
= TREE_CHAIN (fndecl
))
916 /* Output the name of the field (after overloading), as
917 well as the name of the field before overloading, along
918 with its parameter list */
920 /* This is the "mangled" name of the method.
921 It encodes the argument types. */
922 const char *debug_name
;
924 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
925 include TEMPLATE_DECLs.) The debugger doesn't know what
926 to do with such entities anyhow. */
927 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
930 debug_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
));
936 /* Also ignore abstract methods; those are only interesting to
937 the DWARF backends. */
938 if (DECL_IGNORED_P (fndecl
) || DECL_ABSTRACT (fndecl
))
941 /* Redundantly output the plain name, since that's what gdb
945 tree name
= DECL_NAME (fndecl
);
946 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (name
));
947 CHARS (IDENTIFIER_LENGTH (name
) + 2);
951 dbxout_type (TREE_TYPE (fndecl
), 0);
953 dbxout_type_method_1 (fndecl
, debug_name
);
963 /* Emit a "range" type specification, which has the form:
964 "r<index type>;<lower bound>;<upper bound>;".
965 TYPE is an INTEGER_TYPE. */
968 dbxout_range_type (type
)
971 fprintf (asmfile
, "r");
972 if (TREE_TYPE (type
))
973 dbxout_type (TREE_TYPE (type
), 0);
974 else if (TREE_CODE (type
) != INTEGER_TYPE
)
975 dbxout_type (type
, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
978 /* Traditionally, we made sure 'int' was type 1, and builtin types
979 were defined to be sub-ranges of int. Unfortunately, this
980 does not allow us to distinguish true sub-ranges from integer
981 types. So, instead we define integer (non-sub-range) types as
982 sub-ranges of themselves. This matters for Chill. If this isn't
983 a subrange type, then we want to define it in terms of itself.
984 However, in C, this may be an anonymous integer type, and we don't
985 want to emit debug info referring to it. Just calling
986 dbxout_type_index won't work anyways, because the type hasn't been
987 defined yet. We make this work for both cases by checked to see
988 whether this is a defined type, referring to it if it is, and using
990 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
991 dbxout_type_index (type
);
993 dbxout_type_index (integer_type_node
);
996 if (TYPE_MIN_VALUE (type
) != 0
997 && host_integerp (TYPE_MIN_VALUE (type
), 0))
1001 print_wide_int (tree_low_cst (TYPE_MIN_VALUE (type
), 0));
1005 fprintf (asmfile
, ";0");
1009 if (TYPE_MAX_VALUE (type
) != 0
1010 && host_integerp (TYPE_MAX_VALUE (type
), 0))
1012 putc (';', asmfile
);
1014 print_wide_int (tree_low_cst (TYPE_MAX_VALUE (type
), 0));
1015 putc (';', asmfile
);
1020 fprintf (asmfile
, ";-1;");
1025 /* Output a reference to a type. If the type has not yet been
1026 described in the dbx output, output its definition now.
1027 For a type already defined, just refer to its definition
1028 using the type number.
1030 If FULL is nonzero, and the type has been described only with
1031 a forward-reference, output the definition now.
1032 If FULL is zero in this case, just refer to the forward-reference
1033 using the number previously allocated. */
1036 dbxout_type (type
, full
)
1041 static int anonymous_type_number
= 0;
1043 if (TREE_CODE (type
) == VECTOR_TYPE
)
1044 type
= TYPE_DEBUG_REPRESENTATION_TYPE (type
);
1046 /* If there was an input error and we don't really have a type,
1047 avoid crashing and write something that is at least valid
1048 by assuming `int'. */
1049 if (type
== error_mark_node
)
1050 type
= integer_type_node
;
1053 /* Try to find the "main variant" with the same name but not const
1054 or volatile. (Since stabs does not distinguish const and volatile,
1055 there is no need to make them separate types. But types with
1056 different names are usefully distinguished.) */
1058 for (tem
= TYPE_MAIN_VARIANT (type
); tem
; tem
= TYPE_NEXT_VARIANT (tem
))
1059 if (!TYPE_READONLY (tem
) && !TYPE_VOLATILE (tem
)
1060 && TYPE_NAME (tem
) == TYPE_NAME (type
))
1065 if (TYPE_NAME (type
)
1066 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1067 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1071 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1073 /* Type has no dbx number assigned. Assign next available number. */
1074 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1076 /* Make sure type vector is long enough to record about this type. */
1078 if (next_type_number
== typevec_len
)
1081 = (struct typeinfo
*) xrealloc (typevec
,
1082 typevec_len
* 2 * sizeof typevec
[0]);
1083 memset ((char *) (typevec
+ typevec_len
), 0,
1084 typevec_len
* sizeof typevec
[0]);
1088 #ifdef DBX_USE_BINCL
1089 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1090 = current_file
->file_number
;
1091 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1092 = current_file
->next_type_number
++;
1096 /* Output the number of this type, to refer to it. */
1097 dbxout_type_index (type
);
1099 #ifdef DBX_TYPE_DEFINED
1100 if (DBX_TYPE_DEFINED (type
))
1104 /* If this type's definition has been output or is now being output,
1107 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1112 /* If we have already had a cross reference,
1113 and either that's all we want or that's the best we could do,
1114 don't repeat the cross reference.
1115 Sun dbx crashes if we do. */
1116 if (! full
|| !COMPLETE_TYPE_P (type
)
1117 /* No way in DBX fmt to describe a variable size. */
1118 || ! host_integerp (TYPE_SIZE (type
), 1))
1126 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1127 leave the type-number completely undefined rather than output
1128 a cross-reference. If we have already used GNU debug info extensions,
1129 then it is OK to output a cross reference. This is necessary to get
1130 proper C++ debug output. */
1131 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1132 || TREE_CODE (type
) == QUAL_UNION_TYPE
1133 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1134 && ! use_gnu_debug_info_extensions
)
1135 /* We must use the same test here as we use twice below when deciding
1136 whether to emit a cross-reference. */
1137 if ((TYPE_NAME (type
) != 0
1138 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1139 && DECL_IGNORED_P (TYPE_NAME (type
)))
1141 || !COMPLETE_TYPE_P (type
)
1142 /* No way in DBX fmt to describe a variable size. */
1143 || ! host_integerp (TYPE_SIZE (type
), 1))
1145 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1150 /* Output a definition now. */
1152 fprintf (asmfile
, "=");
1155 /* Mark it as defined, so that if it is self-referent
1156 we will not get into an infinite recursion of definitions. */
1158 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1160 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1161 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1163 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0);
1167 switch (TREE_CODE (type
))
1171 /* For a void type, just define it as itself; ie, "5=5".
1172 This makes us consider it defined
1173 without saying what it is. The debugger will make it
1174 a void type when the reference is seen, and nothing will
1175 ever override that default. */
1176 dbxout_type_index (type
);
1180 if (type
== char_type_node
&& ! TREE_UNSIGNED (type
))
1182 /* Output the type `char' as a subrange of itself!
1183 I don't understand this definition, just copied it
1184 from the output of pcc.
1185 This used to use `r2' explicitly and we used to
1186 take care to make sure that `char' was type number 2. */
1187 fprintf (asmfile
, "r");
1189 dbxout_type_index (type
);
1190 fprintf (asmfile
, ";0;127;");
1194 /* If this is a subtype of another integer type, always prefer to
1195 write it as a subtype. */
1196 else if (TREE_TYPE (type
) != 0
1197 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
1198 dbxout_range_type (type
);
1202 /* If the size is non-standard, say what it is if we can use
1205 if (use_gnu_debug_info_extensions
1206 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1208 have_used_extensions
= 1;
1209 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1213 /* If we can use GDB extensions and the size is wider than a
1214 long (the size used by GDB to read them) or we may have
1215 trouble writing the bounds the usual way, write them in
1216 octal. Note the test is for the *target's* size of "long",
1217 not that of the host. The host test is just to make sure we
1218 can write it out in case the host wide int is narrower than the
1221 /* For unsigned types, we use octal if they are the same size or
1222 larger. This is because we print the bounds as signed decimal,
1223 and hence they can't span same size unsigned types. */
1225 if (use_gnu_debug_info_extensions
1226 && TYPE_MIN_VALUE (type
) != 0
1227 && TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
1228 && TYPE_MAX_VALUE (type
) != 0
1229 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
1230 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
1231 || ((TYPE_PRECISION (type
)
1232 == TYPE_PRECISION (integer_type_node
))
1233 && TREE_UNSIGNED (type
))
1234 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
1235 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
1236 && TREE_UNSIGNED (type
))))
1238 fprintf (asmfile
, "r");
1240 dbxout_type_index (type
);
1241 fprintf (asmfile
, ";");
1243 print_int_cst_octal (TYPE_MIN_VALUE (type
));
1244 fprintf (asmfile
, ";");
1246 print_int_cst_octal (TYPE_MAX_VALUE (type
));
1247 fprintf (asmfile
, ";");
1252 /* Output other integer types as subranges of `int'. */
1253 dbxout_range_type (type
);
1259 /* This used to say `r1' and we used to take care
1260 to make sure that `int' was type number 1. */
1261 fprintf (asmfile
, "r");
1263 dbxout_type_index (integer_type_node
);
1264 putc (';', asmfile
);
1266 print_wide_int (int_size_in_bytes (type
));
1267 fputs (";0;", asmfile
);
1272 if (use_gnu_debug_info_extensions
)
1274 have_used_extensions
= 1;
1275 fputs ("@s", asmfile
);
1277 print_wide_int (BITS_PER_UNIT
* int_size_in_bytes (type
));
1278 fputs (";-20;", asmfile
);
1283 /* Output the type `char' as a subrange of itself.
1284 That is what pcc seems to do. */
1285 fprintf (asmfile
, "r");
1287 dbxout_type_index (char_type_node
);
1288 fprintf (asmfile
, ";0;%d;", TREE_UNSIGNED (type
) ? 255 : 127);
1294 if (use_gnu_debug_info_extensions
)
1296 have_used_extensions
= 1;
1297 fputs ("@s", asmfile
);
1299 print_wide_int (BITS_PER_UNIT
* int_size_in_bytes (type
));
1300 fputs (";-16;", asmfile
);
1303 else /* Define as enumeral type (False, True) */
1305 fprintf (asmfile
, "eFalse:0,True:1,;");
1311 putc ('d', asmfile
);
1313 dbxout_type (TREE_TYPE (type
), 0);
1317 /* Differs from the REAL_TYPE by its new data type number */
1319 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1321 fprintf (asmfile
, "r");
1323 dbxout_type_index (type
);
1324 putc (';', asmfile
);
1326 print_wide_int (2 * int_size_in_bytes (TREE_TYPE (type
)));
1327 fputs (";0;", asmfile
);
1332 /* Output a complex integer type as a structure,
1333 pending some other way to do it. */
1334 putc ('s', asmfile
);
1336 print_wide_int (int_size_in_bytes (type
));
1337 fprintf (asmfile
, "real:");
1340 dbxout_type (TREE_TYPE (type
), 0);
1341 fprintf (asmfile
, ",0,%d;", TYPE_PRECISION (TREE_TYPE (type
)));
1343 fprintf (asmfile
, "imag:");
1345 dbxout_type (TREE_TYPE (type
), 0);
1346 fprintf (asmfile
, ",%d,%d;;", TYPE_PRECISION (TREE_TYPE (type
)),
1347 TYPE_PRECISION (TREE_TYPE (type
)));
1353 if (use_gnu_debug_info_extensions
)
1355 have_used_extensions
= 1;
1356 fputs ("@s", asmfile
);
1358 print_wide_int (BITS_PER_UNIT
* int_size_in_bytes (type
));
1359 putc (';', asmfile
);
1362 /* Check if a bitstring type, which in Chill is
1363 different from a [power]set. */
1364 if (TYPE_STRING_FLAG (type
))
1366 fprintf (asmfile
, "@S;");
1370 putc ('S', asmfile
);
1372 dbxout_type (TYPE_DOMAIN (type
), 0);
1376 /* Make arrays of packed bits look like bitstrings for chill. */
1377 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
1379 have_used_extensions
= 1;
1380 fputs ("@s", asmfile
);
1382 print_wide_int (BITS_PER_UNIT
* int_size_in_bytes (type
));
1383 fprintf (asmfile
, ";@S;S");
1385 dbxout_type (TYPE_DOMAIN (type
), 0);
1389 /* Output "a" followed by a range type definition
1390 for the index type of the array
1391 followed by a reference to the target-type.
1392 ar1;0;N;M for a C array of type M and size N+1. */
1393 /* Check if a character string type, which in Chill is
1394 different from an array of characters. */
1395 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
1397 have_used_extensions
= 1;
1398 fprintf (asmfile
, "@S;");
1401 tem
= TYPE_DOMAIN (type
);
1404 fprintf (asmfile
, "ar");
1406 dbxout_type_index (integer_type_node
);
1407 fprintf (asmfile
, ";0;-1;");
1412 fprintf (asmfile
, "a");
1414 dbxout_range_type (tem
);
1417 dbxout_type (TREE_TYPE (type
), 0);
1422 case QUAL_UNION_TYPE
:
1424 int i
, n_baseclasses
= 0;
1426 if (TYPE_BINFO (type
) != 0
1427 && TREE_CODE (TYPE_BINFO (type
)) == TREE_VEC
1428 && TYPE_BINFO_BASETYPES (type
) != 0)
1429 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
1431 /* Output a structure type. We must use the same test here as we
1432 use in the DBX_NO_XREFS case above. */
1433 if ((TYPE_NAME (type
) != 0
1434 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1435 && DECL_IGNORED_P (TYPE_NAME (type
)))
1437 || !COMPLETE_TYPE_P (type
)
1438 /* No way in DBX fmt to describe a variable size. */
1439 || ! host_integerp (TYPE_SIZE (type
), 1))
1441 /* If the type is just a cross reference, output one
1442 and mark the type as partially described.
1443 If it later becomes defined, we will output
1444 its real definition.
1445 If the type has a name, don't nest its definition within
1446 another type's definition; instead, output an xref
1447 and let the definition come when the name is defined. */
1448 fputs ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu", asmfile
);
1450 #if 0 /* This assertion is legitimately false in C++. */
1451 /* We shouldn't be outputting a reference to a type before its
1452 definition unless the type has a tag name.
1453 A typedef name without a tag name should be impossible. */
1454 if (TREE_CODE (TYPE_NAME (type
)) != IDENTIFIER_NODE
)
1457 if (TYPE_NAME (type
) != 0)
1458 dbxout_type_name (type
);
1461 fprintf (asmfile
, "$$%d", anonymous_type_number
++);
1465 fprintf (asmfile
, ":");
1467 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1471 /* Identify record or union, and print its size. */
1472 putc (((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u'), asmfile
);
1474 print_wide_int (int_size_in_bytes (type
));
1476 if (use_gnu_debug_info_extensions
)
1480 have_used_extensions
= 1;
1481 fprintf (asmfile
, "!%d,", n_baseclasses
);
1485 for (i
= 0; i
< n_baseclasses
; i
++)
1487 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)), i
);
1489 if (use_gnu_debug_info_extensions
)
1491 have_used_extensions
= 1;
1492 putc (TREE_VIA_VIRTUAL (child
) ? '1' : '0', asmfile
);
1493 putc (TREE_VIA_PUBLIC (child
) ? '2' : '0', asmfile
);
1495 if (TREE_VIA_VIRTUAL (child
) && strcmp (lang_hooks
.name
, "GNU C++") == 0)
1496 /* For a virtual base, print the (negative) offset within
1497 the vtable where we must look to find the necessary
1499 print_wide_int (tree_low_cst (BINFO_VPTR_FIELD (child
), 0)
1502 print_wide_int (tree_low_cst (BINFO_OFFSET (child
), 0)
1504 putc (',', asmfile
);
1506 dbxout_type (BINFO_TYPE (child
), 0);
1507 putc (';', asmfile
);
1512 /* Print out the base class information with fields
1513 which have the same names at the types they hold. */
1514 dbxout_type_name (BINFO_TYPE (child
));
1515 putc (':', asmfile
);
1517 dbxout_type (BINFO_TYPE (child
), full
);
1518 putc (',', asmfile
);
1520 print_wide_int (tree_low_cst (BINFO_OFFSET (child
), 0)
1522 putc (',', asmfile
);
1524 print_wide_int (tree_low_cst (DECL_SIZE
1526 (BINFO_TYPE (child
))),
1529 putc (';', asmfile
);
1535 /* Write out the field declarations. */
1536 dbxout_type_fields (type
);
1537 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1539 have_used_extensions
= 1;
1540 dbxout_type_methods (type
);
1543 putc (';', asmfile
);
1546 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1547 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1548 && TYPE_VFIELD (type
))
1550 have_used_extensions
= 1;
1552 /* Tell GDB+ that it may keep reading. */
1553 putc ('~', asmfile
);
1556 /* We need to write out info about what field this class
1557 uses as its "main" vtable pointer field, because if this
1558 field is inherited from a base class, GDB cannot necessarily
1559 figure out which field it's using in time. */
1560 if (TYPE_VFIELD (type
))
1562 putc ('%', asmfile
);
1564 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0);
1567 putc (';', asmfile
);
1573 /* We must use the same test here as we use in the DBX_NO_XREFS case
1574 above. We simplify it a bit since an enum will never have a variable
1576 if ((TYPE_NAME (type
) != 0
1577 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1578 && DECL_IGNORED_P (TYPE_NAME (type
)))
1580 || !COMPLETE_TYPE_P (type
))
1582 fprintf (asmfile
, "xe");
1584 dbxout_type_name (type
);
1585 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1586 putc (':', asmfile
);
1590 #ifdef DBX_OUTPUT_ENUM
1591 DBX_OUTPUT_ENUM (asmfile
, type
);
1593 if (use_gnu_debug_info_extensions
1594 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1596 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1600 putc ('e', asmfile
);
1602 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1604 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)));
1605 CHARS (IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)) + 1);
1606 if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == 0)
1607 print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1608 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == -1
1609 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (TREE_VALUE (tem
)) < 0)
1610 print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1612 print_int_cst_octal (TREE_VALUE (tem
));
1614 putc (',', asmfile
);
1616 if (TREE_CHAIN (tem
) != 0)
1620 putc (';', asmfile
);
1626 putc ('*', asmfile
);
1628 dbxout_type (TREE_TYPE (type
), 0);
1632 if (use_gnu_debug_info_extensions
)
1634 have_used_extensions
= 1;
1635 putc ('#', asmfile
);
1638 /* Write the argument types out longhand. */
1639 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0);
1640 putc (',', asmfile
);
1642 dbxout_type (TREE_TYPE (type
), 0);
1643 dbxout_args (TYPE_ARG_TYPES (type
));
1644 putc (';', asmfile
);
1648 /* Treat it as a function type. */
1649 dbxout_type (TREE_TYPE (type
), 0);
1653 if (use_gnu_debug_info_extensions
)
1655 have_used_extensions
= 1;
1656 putc ('@', asmfile
);
1658 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0);
1659 putc (',', asmfile
);
1661 dbxout_type (TREE_TYPE (type
), 0);
1664 /* Should print as an int, because it is really just an offset. */
1665 dbxout_type (integer_type_node
, 0);
1668 case REFERENCE_TYPE
:
1669 if (use_gnu_debug_info_extensions
)
1670 have_used_extensions
= 1;
1671 putc (use_gnu_debug_info_extensions
? '&' : '*', asmfile
);
1673 dbxout_type (TREE_TYPE (type
), 0);
1677 putc ('f', asmfile
);
1679 dbxout_type (TREE_TYPE (type
), 0);
1687 /* Print the value of integer constant C, in octal,
1688 handling double precision. */
1691 print_int_cst_octal (c
)
1694 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (c
);
1695 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (c
);
1696 int excess
= (3 - (HOST_BITS_PER_WIDE_INT
% 3));
1697 unsigned int width
= TYPE_PRECISION (TREE_TYPE (c
));
1699 /* GDB wants constants with no extra leading "1" bits, so
1700 we need to remove any sign-extension that might be
1702 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
1704 else if (width
> HOST_BITS_PER_WIDE_INT
)
1705 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
1706 else if (width
== HOST_BITS_PER_WIDE_INT
)
1709 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
1711 fprintf (asmfile
, "0");
1716 print_octal (high
, HOST_BITS_PER_WIDE_INT
/ 3);
1717 print_octal (low
, HOST_BITS_PER_WIDE_INT
/ 3);
1721 unsigned HOST_WIDE_INT beg
= high
>> excess
;
1722 unsigned HOST_WIDE_INT middle
1723 = ((high
& (((HOST_WIDE_INT
) 1 << excess
) - 1)) << (3 - excess
)
1724 | (low
>> (HOST_BITS_PER_WIDE_INT
/ 3 * 3)));
1725 unsigned HOST_WIDE_INT end
1726 = low
& (((unsigned HOST_WIDE_INT
) 1
1727 << (HOST_BITS_PER_WIDE_INT
/ 3 * 3))
1730 fprintf (asmfile
, "%o%01o", (int) beg
, (int) middle
);
1732 print_octal (end
, HOST_BITS_PER_WIDE_INT
/ 3);
1737 print_octal (value
, digits
)
1738 unsigned HOST_WIDE_INT value
;
1743 for (i
= digits
- 1; i
>= 0; i
--)
1744 fprintf (asmfile
, "%01o", (int) ((value
>> (3 * i
)) & 7));
1749 /* Output C in decimal while adjusting the number of digits written. */
1757 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, c
);
1768 /* Output the name of type TYPE, with no punctuation.
1769 Such names can be set up either by typedef declarations
1770 or by struct, enum and union tags. */
1773 dbxout_type_name (type
)
1777 if (TYPE_NAME (type
) == 0)
1779 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
1781 t
= TYPE_NAME (type
);
1783 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1785 t
= DECL_NAME (TYPE_NAME (type
));
1790 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
1791 CHARS (IDENTIFIER_LENGTH (t
));
1794 /* Output a .stabs for the symbol defined by DECL,
1795 which must be a ..._DECL node in the normal namespace.
1796 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1797 LOCAL is nonzero if the scope is less than the entire file.
1798 Return 1 if a stabs might have been emitted. */
1801 dbxout_symbol (decl
, local
)
1803 int local ATTRIBUTE_UNUSED
;
1805 tree type
= TREE_TYPE (decl
);
1806 tree context
= NULL_TREE
;
1809 /* Cast avoids warning in old compilers. */
1810 current_sym_code
= (STAB_CODE_TYPE
) 0;
1811 current_sym_value
= 0;
1812 current_sym_addr
= 0;
1814 /* Ignore nameless syms, but don't ignore type tags. */
1816 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
1817 || DECL_IGNORED_P (decl
))
1820 dbxout_prepare_symbol (decl
);
1822 /* The output will always start with the symbol name,
1823 so always count that in the length-output-so-far. */
1825 if (DECL_NAME (decl
) != 0)
1826 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
1828 switch (TREE_CODE (decl
))
1831 /* Enum values are defined by defining the enum type. */
1835 if (DECL_RTL (decl
) == 0)
1837 if (DECL_EXTERNAL (decl
))
1839 /* Don't mention a nested function under its parent. */
1840 context
= decl_function_context (decl
);
1841 if (context
== current_function_decl
)
1843 if (GET_CODE (DECL_RTL (decl
)) != MEM
1844 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
1848 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
1849 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1850 TREE_PUBLIC (decl
) ? 'F' : 'f');
1853 current_sym_code
= N_FUN
;
1854 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1856 if (TREE_TYPE (type
))
1857 dbxout_type (TREE_TYPE (type
), 0);
1859 dbxout_type (void_type_node
, 0);
1861 /* For a nested function, when that function is compiled,
1862 mention the containing function name
1863 as well as (since dbx wants it) our own assembler-name. */
1865 fprintf (asmfile
, ",%s,%s",
1866 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1867 IDENTIFIER_POINTER (DECL_NAME (context
)));
1869 dbxout_finish_symbol (decl
);
1874 /* This seems all wrong. Outputting most kinds of types gives no name
1875 at all. A true definition gives no name; a cross-ref for a
1876 structure can give the tag name, but not a type name.
1877 It seems that no typedef name is defined by outputting a type. */
1879 /* If this typedef name was defined by outputting the type,
1880 don't duplicate it. */
1881 if (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
== TYPE_DEFINED
1882 && TYPE_NAME (TREE_TYPE (decl
)) == decl
)
1885 /* Don't output the same typedef twice.
1886 And don't output what language-specific stuff doesn't want output. */
1887 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
1896 if (DECL_NAME (decl
))
1898 /* Nonzero means we must output a tag as well as a typedef. */
1901 /* Handle the case of a C++ structure or union
1902 where the TYPE_NAME is a TYPE_DECL
1903 which gives both a typedef name and a tag. */
1904 /* dbx requires the tag first and the typedef second. */
1905 if ((TREE_CODE (type
) == RECORD_TYPE
1906 || TREE_CODE (type
) == UNION_TYPE
1907 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1908 && TYPE_NAME (type
) == decl
1909 && !(use_gnu_debug_info_extensions
&& have_used_extensions
)
1910 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
1911 /* Distinguish the implicit typedefs of C++
1912 from explicit ones that might be found in C. */
1913 && DECL_ARTIFICIAL (decl
)
1914 /* Do not generate a tag for records of variable size,
1915 since this type can not be properly described in the
1916 DBX format, and it confuses some tools such as objdump. */
1917 && host_integerp (TYPE_SIZE (type
), 1))
1919 tree name
= TYPE_NAME (type
);
1920 if (TREE_CODE (name
) == TYPE_DECL
)
1921 name
= DECL_NAME (name
);
1923 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1924 current_sym_value
= 0;
1925 current_sym_addr
= 0;
1926 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1928 fprintf (asmfile
, "%s\"%s:T", ASM_STABS_OP
,
1929 IDENTIFIER_POINTER (name
));
1930 dbxout_type (type
, 1);
1931 dbxout_finish_symbol (NULL_TREE
);
1934 /* Output typedef name. */
1935 fprintf (asmfile
, "%s\"%s:", ASM_STABS_OP
,
1936 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1938 /* Short cut way to output a tag also. */
1939 if ((TREE_CODE (type
) == RECORD_TYPE
1940 || TREE_CODE (type
) == UNION_TYPE
1941 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1942 && TYPE_NAME (type
) == decl
1943 /* Distinguish the implicit typedefs of C++
1944 from explicit ones that might be found in C. */
1945 && DECL_ARTIFICIAL (decl
))
1947 if (use_gnu_debug_info_extensions
&& have_used_extensions
)
1949 putc ('T', asmfile
);
1950 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
1952 #if 0 /* Now we generate the tag for this case up above. */
1958 putc ('t', asmfile
);
1959 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1961 dbxout_type (type
, 1);
1962 dbxout_finish_symbol (decl
);
1966 /* Don't output a tag if this is an incomplete type. This prevents
1967 the sun4 Sun OS 4.x dbx from crashing. */
1969 if (tag_needed
&& TYPE_NAME (type
) != 0
1970 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
1971 || (DECL_NAME (TYPE_NAME (type
)) != 0))
1972 && COMPLETE_TYPE_P (type
)
1973 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1975 /* For a TYPE_DECL with no name, but the type has a name,
1977 This is what represents `struct foo' with no typedef. */
1978 /* In C++, the name of a type is the corresponding typedef.
1979 In C, it is an IDENTIFIER_NODE. */
1980 tree name
= TYPE_NAME (type
);
1981 if (TREE_CODE (name
) == TYPE_DECL
)
1982 name
= DECL_NAME (name
);
1984 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1985 current_sym_value
= 0;
1986 current_sym_addr
= 0;
1987 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1989 fprintf (asmfile
, "%s\"%s:T", ASM_STABS_OP
,
1990 IDENTIFIER_POINTER (name
));
1991 dbxout_type (type
, 1);
1992 dbxout_finish_symbol (NULL_TREE
);
1996 /* If an enum type has no name, it cannot be referred to,
1997 but we must output it anyway, since the enumeration constants
1998 can be referred to. */
1999 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2001 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
2002 current_sym_value
= 0;
2003 current_sym_addr
= 0;
2004 current_sym_nchars
= 2;
2006 /* Some debuggers fail when given NULL names, so give this a
2007 harmless name of ` '. */
2008 fprintf (asmfile
, "%s\" :T", ASM_STABS_OP
);
2009 dbxout_type (type
, 1);
2010 dbxout_finish_symbol (NULL_TREE
);
2013 /* Prevent duplicate output of a typedef. */
2014 TREE_ASM_WRITTEN (decl
) = 1;
2019 /* Parm decls go in their own separate chains
2020 and are output by dbxout_reg_parms and dbxout_parms. */
2024 /* Named return value, treat like a VAR_DECL. */
2026 if (! DECL_RTL_SET_P (decl
))
2028 /* Don't mention a variable that is external.
2029 Let the file that defines it describe it. */
2030 if (DECL_EXTERNAL (decl
))
2033 /* If the variable is really a constant
2034 and not written in memory, inform the debugger. */
2035 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
2036 && DECL_INITIAL (decl
) != 0
2037 && host_integerp (DECL_INITIAL (decl
), 0)
2038 && ! TREE_ASM_WRITTEN (decl
)
2039 && (DECL_CONTEXT (decl
) == NULL_TREE
2040 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
))
2042 if (TREE_PUBLIC (decl
) == 0)
2044 /* The sun4 assembler does not grok this. */
2045 const char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
2047 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
2048 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2050 HOST_WIDE_INT ival
= tree_low_cst (DECL_INITIAL (decl
), 0);
2051 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
2052 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile
, name
, ival
);
2054 fprintf (asmfile
, "%s\"%s:c=i", ASM_STABS_OP
, name
);
2056 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, ival
);
2057 fprintf (asmfile
, "\",0x%x,0,0,0\n", N_LSYM
);
2061 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
2063 /* don't know how to do this yet. */
2067 /* else it is something we handle like a normal variable. */
2070 SET_DECL_RTL (decl
, eliminate_regs (DECL_RTL (decl
), 0, NULL_RTX
));
2071 #ifdef LEAF_REG_REMAP
2072 if (current_function_uses_only_leaf_regs
)
2073 leaf_renumber_regs_insn (DECL_RTL (decl
));
2076 result
= dbxout_symbol_location (decl
, type
, 0, DECL_RTL (decl
));
2085 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2086 Add SUFFIX to its name, if SUFFIX is not 0.
2087 Describe the variable as residing in HOME
2088 (usually HOME is DECL_RTL (DECL), but not always).
2089 Returns 1 if the stab was really emitted. */
2092 dbxout_symbol_location (decl
, type
, suffix
, home
)
2100 /* Don't mention a variable at all
2101 if it was completely optimized into nothingness.
2103 If the decl was from an inline function, then its rtl
2104 is not identically the rtl that was used in this
2105 particular compilation. */
2106 if (GET_CODE (home
) == SUBREG
)
2110 while (GET_CODE (value
) == SUBREG
)
2111 value
= SUBREG_REG (value
);
2112 if (GET_CODE (value
) == REG
)
2114 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
2117 home
= alter_subreg (&home
);
2119 if (GET_CODE (home
) == REG
)
2121 regno
= REGNO (home
);
2122 if (regno
>= FIRST_PSEUDO_REGISTER
)
2126 /* The kind-of-variable letter depends on where
2127 the variable is and on the scope of its name:
2128 G and N_GSYM for static storage and global scope,
2129 S for static storage and file scope,
2130 V for static storage and local scope,
2131 for those two, use N_LCSYM if data is in bss segment,
2132 N_STSYM if in data segment, N_FUN otherwise.
2133 (We used N_FUN originally, then changed to N_STSYM
2134 to please GDB. However, it seems that confused ld.
2135 Now GDB has been fixed to like N_FUN, says Kingdon.)
2136 no letter at all, and N_LSYM, for auto variable,
2137 r and N_RSYM for register variable. */
2139 if (GET_CODE (home
) == MEM
2140 && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2142 if (TREE_PUBLIC (decl
))
2145 current_sym_code
= N_GSYM
;
2149 current_sym_addr
= XEXP (home
, 0);
2151 letter
= decl_function_context (decl
) ? 'V' : 'S';
2153 /* This should be the same condition as in assemble_variable, but
2154 we don't have access to dont_output_data here. So, instead,
2155 we rely on the fact that error_mark_node initializers always
2156 end up in bss for C++ and never end up in bss for C. */
2157 if (DECL_INITIAL (decl
) == 0
2158 || (!strcmp (lang_hooks
.name
, "GNU C++")
2159 && DECL_INITIAL (decl
) == error_mark_node
))
2160 current_sym_code
= N_LCSYM
;
2161 else if (DECL_IN_TEXT_SECTION (decl
))
2162 /* This is not quite right, but it's the closest
2163 of all the codes that Unix defines. */
2164 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
2167 /* Some ports can transform a symbol ref into a label ref,
2168 because the symbol ref is too far away and has to be
2169 dumped into a constant pool. Alternatively, the symbol
2170 in the constant pool might be referenced by a different
2172 if (GET_CODE (current_sym_addr
) == SYMBOL_REF
2173 && CONSTANT_POOL_ADDRESS_P (current_sym_addr
))
2175 rtx tmp
= get_pool_constant (current_sym_addr
);
2177 if (GET_CODE (tmp
) == SYMBOL_REF
)
2178 current_sym_addr
= tmp
;
2181 /* Ultrix `as' seems to need this. */
2182 #ifdef DBX_STATIC_STAB_DATA_SECTION
2185 current_sym_code
= N_STSYM
;
2189 else if (regno
>= 0)
2192 current_sym_code
= N_RSYM
;
2193 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
2195 else if (GET_CODE (home
) == MEM
2196 && (GET_CODE (XEXP (home
, 0)) == MEM
2197 || (GET_CODE (XEXP (home
, 0)) == REG
2198 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
2199 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
2200 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2201 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
2204 /* If the value is indirect by memory or by a register
2205 that isn't the frame pointer
2206 then it means the object is variable-sized and address through
2207 that register or stack slot. DBX has no way to represent this
2208 so all we can do is output the variable as a pointer.
2209 If it's not a parameter, ignore it.
2210 (VAR_DECLs like this can be made by integrate.c.) */
2212 if (GET_CODE (XEXP (home
, 0)) == REG
)
2215 current_sym_code
= N_RSYM
;
2216 if (REGNO (XEXP (home
, 0)) >= FIRST_PSEUDO_REGISTER
)
2218 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
2222 current_sym_code
= N_LSYM
;
2223 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2224 We want the value of that CONST_INT. */
2226 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
2229 /* Effectively do build_pointer_type, but don't cache this type,
2230 since it might be temporary whereas the type it points to
2231 might have been saved for inlining. */
2232 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2233 type
= make_node (POINTER_TYPE
);
2234 TREE_TYPE (type
) = TREE_TYPE (decl
);
2236 else if (GET_CODE (home
) == MEM
2237 && GET_CODE (XEXP (home
, 0)) == REG
)
2239 current_sym_code
= N_LSYM
;
2240 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2242 else if (GET_CODE (home
) == MEM
2243 && GET_CODE (XEXP (home
, 0)) == PLUS
2244 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
2246 current_sym_code
= N_LSYM
;
2247 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2248 We want the value of that CONST_INT. */
2249 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2251 else if (GET_CODE (home
) == MEM
2252 && GET_CODE (XEXP (home
, 0)) == CONST
)
2254 /* Handle an obscure case which can arise when optimizing and
2255 when there are few available registers. (This is *always*
2256 the case for i386/i486 targets). The RTL looks like
2257 (MEM (CONST ...)) even though this variable is a local `auto'
2258 or a local `register' variable. In effect, what has happened
2259 is that the reload pass has seen that all assignments and
2260 references for one such a local variable can be replaced by
2261 equivalent assignments and references to some static storage
2262 variable, thereby avoiding the need for a register. In such
2263 cases we're forced to lie to debuggers and tell them that
2264 this variable was itself `static'. */
2265 current_sym_code
= N_LCSYM
;
2267 current_sym_addr
= XEXP (XEXP (home
, 0), 0);
2269 else if (GET_CODE (home
) == CONCAT
)
2273 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
2274 for example), then there is no easy way to figure out
2275 what SUBTYPE should be. So, we give up. */
2276 if (TREE_CODE (type
) != COMPLEX_TYPE
)
2279 subtype
= TREE_TYPE (type
);
2281 /* If the variable's storage is in two parts,
2282 output each as a separate stab with a modified name. */
2283 if (WORDS_BIG_ENDIAN
)
2284 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
2286 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
2288 /* Cast avoids warning in old compilers. */
2289 current_sym_code
= (STAB_CODE_TYPE
) 0;
2290 current_sym_value
= 0;
2291 current_sym_addr
= 0;
2292 dbxout_prepare_symbol (decl
);
2294 if (WORDS_BIG_ENDIAN
)
2295 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
2297 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
2301 /* Address might be a MEM, when DECL is a variable-sized object.
2302 Or it might be const0_rtx, meaning previous passes
2303 want us to ignore this variable. */
2306 /* Ok, start a symtab entry and output the variable name. */
2309 #ifdef DBX_STATIC_BLOCK_START
2310 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
2313 dbxout_symbol_name (decl
, suffix
, letter
);
2314 dbxout_type (type
, 0);
2315 dbxout_finish_symbol (decl
);
2317 #ifdef DBX_STATIC_BLOCK_END
2318 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
2323 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2324 Then output LETTER to indicate the kind of location the symbol has. */
2327 dbxout_symbol_name (decl
, suffix
, letter
)
2334 if (DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
)))
2335 /* One slight hitch: if this is a VAR_DECL which is a static
2336 class member, we must put out the mangled name instead of the
2337 DECL_NAME. Note also that static member (variable) names DO NOT begin
2338 with underscores in .stabs directives. */
2339 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2341 /* ...but if we're function-local, we don't want to include the junk
2342 added by ASM_FORMAT_PRIVATE_NAME. */
2343 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
2347 fprintf (asmfile
, "%s\"%s%s:", ASM_STABS_OP
, name
,
2348 (suffix
? suffix
: ""));
2351 putc (letter
, asmfile
);
2355 dbxout_prepare_symbol (decl
)
2356 tree decl ATTRIBUTE_UNUSED
;
2359 const char *filename
= DECL_SOURCE_FILE (decl
);
2361 dbxout_source_file (asmfile
, filename
);
2366 dbxout_finish_symbol (sym
)
2369 #ifdef DBX_FINISH_SYMBOL
2370 DBX_FINISH_SYMBOL (sym
);
2373 if (use_gnu_debug_info_extensions
&& sym
!= 0)
2374 line
= DECL_SOURCE_LINE (sym
);
2376 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
2377 if (current_sym_addr
)
2378 output_addr_const (asmfile
, current_sym_addr
);
2380 fprintf (asmfile
, "%d", current_sym_value
);
2381 putc ('\n', asmfile
);
2385 /* Output definitions of all the decls in a chain. Return non-zero if
2386 anything was output */
2395 result
+= dbxout_symbol (syms
, 1);
2396 syms
= TREE_CHAIN (syms
);
2401 /* The following two functions output definitions of function parameters.
2402 Each parameter gets a definition locating it in the parameter list.
2403 Each parameter that is a register variable gets a second definition
2404 locating it in the register.
2406 Printing or argument lists in gdb uses the definitions that
2407 locate in the parameter list. But reference to the variable in
2408 expressions uses preferentially the definition as a register. */
2410 /* Output definitions, referring to storage in the parmlist,
2411 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2414 dbxout_parms (parms
)
2417 for (; parms
; parms
= TREE_CHAIN (parms
))
2418 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
2420 dbxout_prepare_symbol (parms
);
2422 /* Perform any necessary register eliminations on the parameter's rtl,
2423 so that the debugging output will be accurate. */
2424 DECL_INCOMING_RTL (parms
)
2425 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
2426 SET_DECL_RTL (parms
, eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
));
2427 #ifdef LEAF_REG_REMAP
2428 if (current_function_uses_only_leaf_regs
)
2430 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
2431 leaf_renumber_regs_insn (DECL_RTL (parms
));
2435 if (PARM_PASSED_IN_MEMORY (parms
))
2437 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
2439 /* ??? Here we assume that the parm address is indexed
2440 off the frame pointer or arg pointer.
2441 If that is not true, we produce meaningless results,
2442 but do not crash. */
2443 if (GET_CODE (addr
) == PLUS
2444 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
2445 current_sym_value
= INTVAL (XEXP (addr
, 1));
2447 current_sym_value
= 0;
2449 current_sym_code
= N_PSYM
;
2450 current_sym_addr
= 0;
2453 if (DECL_NAME (parms
))
2455 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2457 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2458 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2459 DBX_MEMPARM_STABS_LETTER
);
2463 current_sym_nchars
= 8;
2464 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2465 DBX_MEMPARM_STABS_LETTER
);
2468 /* It is quite tempting to use:
2470 dbxout_type (TREE_TYPE (parms), 0);
2472 as the next statement, rather than using DECL_ARG_TYPE(), so
2473 that gcc reports the actual type of the parameter, rather
2474 than the promoted type. This certainly makes GDB's life
2475 easier, at least for some ports. The change is a bad idea
2476 however, since GDB expects to be able access the type without
2477 performing any conversions. So for example, if we were
2478 passing a float to an unprototyped function, gcc will store a
2479 double on the stack, but if we emit a stab saying the type is a
2480 float, then gdb will only read in a single value, and this will
2481 produce an erroneous value. */
2482 dbxout_type (DECL_ARG_TYPE (parms
), 0);
2483 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
2484 dbxout_finish_symbol (parms
);
2486 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
2489 char regparm_letter
;
2491 /* Parm passed in registers and lives in registers or nowhere. */
2493 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2494 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2495 current_sym_addr
= 0;
2497 /* If parm lives in a register, use that register;
2498 pretend the parm was passed there. It would be more consistent
2499 to describe the register where the parm was passed,
2500 but in practice that register usually holds something else.
2502 If we use DECL_RTL, then we must use the declared type of
2503 the variable, not the type that it arrived in. */
2504 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2506 best_rtl
= DECL_RTL (parms
);
2507 parm_type
= TREE_TYPE (parms
);
2509 /* If the parm lives nowhere, use the register where it was
2510 passed. It is also better to use the declared type here. */
2513 best_rtl
= DECL_INCOMING_RTL (parms
);
2514 parm_type
= TREE_TYPE (parms
);
2516 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
2519 if (DECL_NAME (parms
))
2521 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2522 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2523 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2528 current_sym_nchars
= 8;
2529 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2533 dbxout_type (parm_type
, 0);
2534 dbxout_finish_symbol (parms
);
2536 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2537 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
2538 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
2539 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
2540 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2541 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
2545 /* Parm was passed via invisible reference.
2546 That is, its address was passed in a register.
2547 Output it as if it lived in that register.
2548 The debugger will know from the type
2549 that it was actually passed by invisible reference. */
2551 char regparm_letter
;
2552 /* Parm passed in registers and lives in registers or nowhere. */
2554 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2555 if (use_gnu_debug_info_extensions
)
2556 regparm_letter
= GDB_INV_REF_REGPARM_STABS_LETTER
;
2558 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2560 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2561 If it is an unallocated pseudo-reg, then use the register where
2562 it was passed instead. */
2563 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
2564 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
2566 current_sym_value
= REGNO (DECL_INCOMING_RTL (parms
));
2568 current_sym_addr
= 0;
2571 if (DECL_NAME (parms
))
2574 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2576 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2577 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2582 current_sym_nchars
= 8;
2583 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2587 dbxout_type (TREE_TYPE (parms
), 0);
2588 dbxout_finish_symbol (parms
);
2590 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2591 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
2593 /* Parm was passed via invisible reference, with the reference
2594 living on the stack. DECL_RTL looks like
2595 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
2596 could look like (MEM (MEM (REG))). */
2597 const char *const decl_name
= (DECL_NAME (parms
)
2598 ? IDENTIFIER_POINTER (DECL_NAME (parms
))
2600 if (GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 0)) == REG
)
2601 current_sym_value
= 0;
2604 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
2605 current_sym_addr
= 0;
2608 fprintf (asmfile
, "%s\"%s:v", ASM_STABS_OP
, decl_name
);
2609 dbxout_type (TREE_TYPE (parms
), 0);
2610 dbxout_finish_symbol (parms
);
2612 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2613 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
2614 /* ??? A constant address for a parm can happen
2615 when the reg it lives in is equiv to a constant in memory.
2616 Should make this not happen, after 2.4. */
2617 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
2619 /* Parm was passed in registers but lives on the stack. */
2621 current_sym_code
= N_PSYM
;
2622 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2623 in which case we want the value of that CONST_INT,
2625 in which case we use a value of zero. */
2626 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
)
2627 current_sym_value
= 0;
2630 = INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
2632 current_sym_addr
= 0;
2634 /* Make a big endian correction if the mode of the type of the
2635 parameter is not the same as the mode of the rtl. */
2636 if (BYTES_BIG_ENDIAN
2637 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
2638 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
2640 current_sym_value
+=
2641 GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
2642 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
)));
2646 if (DECL_NAME (parms
))
2649 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2651 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2652 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2653 DBX_MEMPARM_STABS_LETTER
);
2657 current_sym_nchars
= 8;
2658 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2659 DBX_MEMPARM_STABS_LETTER
);
2663 = DEBUGGER_ARG_OFFSET (current_sym_value
,
2664 XEXP (DECL_RTL (parms
), 0));
2665 dbxout_type (TREE_TYPE (parms
), 0);
2666 dbxout_finish_symbol (parms
);
2671 /* Output definitions for the places where parms live during the function,
2672 when different from where they were passed, when the parms were passed
2675 It is not useful to do this for parms passed in registers
2676 that live during the function in different registers, because it is
2677 impossible to look in the passed register for the passed value,
2678 so we use the within-the-function register to begin with.
2680 PARMS is a chain of PARM_DECL nodes. */
2683 dbxout_reg_parms (parms
)
2686 for (; parms
; parms
= TREE_CHAIN (parms
))
2687 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
2689 dbxout_prepare_symbol (parms
);
2691 /* Report parms that live in registers during the function
2692 but were passed in memory. */
2693 if (GET_CODE (DECL_RTL (parms
)) == REG
2694 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2695 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2696 0, DECL_RTL (parms
));
2697 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
2698 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2699 0, DECL_RTL (parms
));
2700 /* Report parms that live in memory but not where they were passed. */
2701 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2702 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
2703 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2704 0, DECL_RTL (parms
));
2708 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2709 output definitions of those names, in raw form */
2717 putc (',', asmfile
);
2718 dbxout_type (TREE_VALUE (args
), 0);
2720 args
= TREE_CHAIN (args
);
2724 /* Output everything about a symbol block (a BLOCK node
2725 that represents a scope level),
2726 including recursive output of contained blocks.
2728 BLOCK is the BLOCK node.
2729 DEPTH is its depth within containing symbol blocks.
2730 ARGS is usually zero; but for the outermost block of the
2731 body of a function, it is a chain of PARM_DECLs for the function parameters.
2732 We output definitions of all the register parms
2733 as if they were local variables of that block.
2735 If -g1 was used, we count blocks just the same, but output nothing
2736 except for the outermost block.
2738 Actually, BLOCK may be several blocks chained together.
2739 We handle them all in sequence. */
2742 dbxout_block (block
, depth
, args
)
2749 #if DBX_BLOCKS_FUNCTION_RELATIVE
2750 const char *begin_label
;
2751 if (current_function_func_begin_label
!= NULL_TREE
)
2752 begin_label
= IDENTIFIER_POINTER (current_function_func_begin_label
);
2754 begin_label
= XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0);
2759 /* Ignore blocks never expanded or otherwise marked as real. */
2760 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
2764 #ifdef DBX_LBRAC_FIRST
2767 /* In dbx format, the syms of a block come before the N_LBRAC.
2768 If nothing is output, we don't need the N_LBRAC, either. */
2770 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2771 did_output
= dbxout_syms (BLOCK_VARS (block
));
2773 dbxout_reg_parms (args
);
2776 /* Now output an N_LBRAC symbol to represent the beginning of
2777 the block. Use the block's tree-walk order to generate
2778 the assembler symbols LBBn and LBEn
2779 that final will define around the code in this block. */
2780 if (depth
> 0 && did_output
)
2783 blocknum
= BLOCK_NUMBER (block
);
2784 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
2786 if (BLOCK_HANDLER_BLOCK (block
))
2788 /* A catch block. Must precede N_LBRAC. */
2789 tree decl
= BLOCK_VARS (block
);
2792 #ifdef DBX_OUTPUT_CATCH
2793 DBX_OUTPUT_CATCH (asmfile
, decl
, buf
);
2795 fprintf (asmfile
, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP
,
2796 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
2797 assemble_name (asmfile
, buf
);
2798 fprintf (asmfile
, "\n");
2800 decl
= TREE_CHAIN (decl
);
2804 #ifdef DBX_OUTPUT_LBRAC
2805 DBX_OUTPUT_LBRAC (asmfile
, buf
);
2807 fprintf (asmfile
, "%s%d,0,0,", ASM_STABN_OP
, N_LBRAC
);
2808 assemble_name (asmfile
, buf
);
2809 #if DBX_BLOCKS_FUNCTION_RELATIVE
2810 putc ('-', asmfile
);
2811 assemble_name (asmfile
, begin_label
);
2813 fprintf (asmfile
, "\n");
2817 #ifdef DBX_LBRAC_FIRST
2818 /* On some weird machines, the syms of a block
2819 come after the N_LBRAC. */
2820 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2821 dbxout_syms (BLOCK_VARS (block
));
2823 dbxout_reg_parms (args
);
2826 /* Output the subblocks. */
2827 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
2829 /* Refer to the marker for the end of the block. */
2830 if (depth
> 0 && did_output
)
2833 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
2834 #ifdef DBX_OUTPUT_RBRAC
2835 DBX_OUTPUT_RBRAC (asmfile
, buf
);
2837 fprintf (asmfile
, "%s%d,0,0,", ASM_STABN_OP
, N_RBRAC
);
2838 assemble_name (asmfile
, buf
);
2839 #if DBX_BLOCKS_FUNCTION_RELATIVE
2840 putc ('-', asmfile
);
2841 assemble_name (asmfile
, begin_label
);
2843 fprintf (asmfile
, "\n");
2847 block
= BLOCK_CHAIN (block
);
2851 /* Output the information about a function and its arguments and result.
2852 Usually this follows the function's code,
2853 but on some systems, it comes before. */
2855 #if defined (DBX_DEBUGGING_INFO)
2857 dbxout_begin_function (decl
)
2860 dbxout_symbol (decl
, 0);
2861 dbxout_parms (DECL_ARGUMENTS (decl
));
2862 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
2863 dbxout_symbol (DECL_RESULT (decl
), 1);
2865 #endif /* DBX_DEBUGGING_INFO */
2867 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */