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 ((FILE *, const char *));
288 static void dbxout_finish
PARAMS ((FILE *, const char *));
289 #if defined(ASM_OUTPUT_SECTION_NAME)
290 static void dbxout_function_end
PARAMS ((void));
292 static void dbxout_typedefs
PARAMS ((tree
));
293 static void dbxout_type_index
PARAMS ((tree
));
294 #if DBX_CONTIN_LENGTH > 0
295 static void dbxout_continue
PARAMS ((void));
297 static void dbxout_type_fields
PARAMS ((tree
));
298 static void dbxout_type_method_1
PARAMS ((tree
, const char *));
299 static void dbxout_type_methods
PARAMS ((tree
));
300 static void dbxout_range_type
PARAMS ((tree
));
301 static void dbxout_type
PARAMS ((tree
, int));
302 static void print_int_cst_octal
PARAMS ((tree
));
303 static void print_octal
PARAMS ((unsigned HOST_WIDE_INT
, int));
304 static void dbxout_type_name
PARAMS ((tree
));
305 static int dbxout_symbol_location
PARAMS ((tree
, tree
, const char *, rtx
));
306 static void dbxout_symbol_name
PARAMS ((tree
, const char *, int));
307 static void dbxout_prepare_symbol
PARAMS ((tree
));
308 static void dbxout_finish_symbol
PARAMS ((tree
));
309 static void dbxout_block
PARAMS ((tree
, int, tree
));
310 static void dbxout_really_begin_function
PARAMS ((tree
));
312 /* The target debug structure. */
313 struct gcc_debug_hooks dbx_debug_hooks
=
319 #if defined(ASM_OUTPUT_SECTION_NAME)
321 dbxout_function_end ()
323 static int scope_labelno
= 0;
324 char lscope_label_name
[100];
325 /* Convert Ltext into the appropriate format for local labels in case
326 the system doesn't insert underscores in front of user generated
328 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
329 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Lscope", scope_labelno
);
332 /* By convention, GCC will mark the end of a function with an N_FUN
333 symbol and an empty string. */
334 fprintf (asmfile
, "%s\"\",%d,0,0,", ASM_STABS_OP
, N_FUN
);
335 assemble_name (asmfile
, lscope_label_name
);
336 fputc ('-', asmfile
);
337 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
338 fprintf (asmfile
, "\n");
340 #endif /* ! NO_DBX_FUNCTION_END */
342 /* At the beginning of compilation, start writing the symbol table.
343 Initialize `typevec' and output the standard data types of C. */
346 dbxout_init (asm_file
, input_file_name
)
348 const char *input_file_name
;
350 char ltext_label_name
[100];
351 tree syms
= getdecls ();
356 typevec
= (struct typeinfo
*) xcalloc (typevec_len
, sizeof typevec
[0]);
358 /* Convert Ltext into the appropriate format for local labels in case
359 the system doesn't insert underscores in front of user generated
361 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
363 /* Put the current working directory in an N_SO symbol. */
364 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
365 but GDB always does. */
366 if (use_gnu_debug_info_extensions
)
369 if (!cwd
&& (cwd
= getpwd ()) && (!*cwd
|| cwd
[strlen (cwd
) - 1] != '/'))
370 cwd
= concat (cwd
, FILE_NAME_JOINER
, NULL
);
373 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
374 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile
, cwd
);
375 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
376 fprintf (asmfile
, "%s", ASM_STABS_OP
);
377 output_quoted_string (asmfile
, cwd
);
378 fprintf (asmfile
, ",%d,0,0,%s\n", N_SO
, <ext_label_name
[1]);
379 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
383 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
384 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
385 would give us an N_SOL, and we want an N_SO. */
386 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile
, input_file_name
);
387 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
388 /* We include outputting `Ltext:' here,
389 because that gives you a way to override it. */
390 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
391 fprintf (asmfile
, "%s", ASM_STABS_OP
);
392 output_quoted_string (asmfile
, input_file_name
);
393 fprintf (asmfile
, ",%d,0,0,%s\n",
394 N_SO
, <ext_label_name
[1]);
396 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Ltext", 0);
397 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
399 #ifdef DBX_OUTPUT_GCC_MARKER
400 DBX_OUTPUT_GCC_MARKER (asmfile
);
402 /* Emit an N_OPT stab to indicate that this file was compiled by GCC. */
403 fprintf (asmfile
, "%s\"%s\",%d,0,0,0\n",
404 ASM_STABS_OP
, STABS_GCC_MARKER
, N_OPT
);
407 lastfile
= input_file_name
;
409 next_type_number
= 1;
412 current_file
= (struct dbx_file
*) xmalloc (sizeof *current_file
);
413 current_file
->next
= NULL
;
414 current_file
->file_number
= 0;
415 current_file
->next_type_number
= 1;
416 next_file_number
= 1;
419 /* Make sure that types `int' and `char' have numbers 1 and 2.
420 Definitions of other integer types will refer to those numbers.
421 (Actually it should no longer matter what their numbers are.
422 Also, if any types with tags have been defined, dbxout_symbol
423 will output them first, so the numbers won't be 1 and 2. That
424 happens in C++. So it's a good thing it should no longer matter). */
426 #ifdef DBX_OUTPUT_STANDARD_TYPES
427 DBX_OUTPUT_STANDARD_TYPES (syms
);
429 dbxout_symbol (TYPE_NAME (integer_type_node
), 0);
430 dbxout_symbol (TYPE_NAME (char_type_node
), 0);
433 /* Get all permanent types that have typedef names,
434 and output them all, except for those already output. */
436 dbxout_typedefs (syms
);
439 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
440 in the reverse order from that which is found in SYMS. */
443 dbxout_typedefs (syms
)
448 dbxout_typedefs (TREE_CHAIN (syms
));
449 if (TREE_CODE (syms
) == TYPE_DECL
)
451 tree type
= TREE_TYPE (syms
);
453 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
454 && COMPLETE_TYPE_P (type
)
455 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
456 dbxout_symbol (TYPE_NAME (type
), 0);
461 /* Change to reading from a new source file. Generate a N_BINCL stab. */
464 dbxout_start_new_source_file (filename
)
465 const char *filename ATTRIBUTE_UNUSED
;
468 struct dbx_file
*n
= (struct dbx_file
*) xmalloc (sizeof *n
);
470 n
->next
= current_file
;
471 n
->file_number
= next_file_number
++;
472 n
->next_type_number
= 1;
474 fprintf (asmfile
, "%s", ASM_STABS_OP
);
475 output_quoted_string (asmfile
, filename
);
476 fprintf (asmfile
, ",%d,0,0,0\n", N_BINCL
);
480 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
483 dbxout_resume_previous_source_file ()
486 struct dbx_file
*next
;
488 fprintf (asmfile
, "%s%d,0,0,0\n", ASM_STABN_OP
, N_EINCL
);
489 next
= current_file
->next
;
495 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
498 dbxout_source_file (file
, filename
)
500 const char *filename
;
502 char ltext_label_name
[100];
504 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
506 #ifdef DBX_OUTPUT_SOURCE_FILENAME
507 DBX_OUTPUT_SOURCE_FILENAME (file
, filename
);
509 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext",
510 source_label_number
);
511 fprintf (file
, "%s", ASM_STABS_OP
);
512 output_quoted_string (file
, filename
);
513 fprintf (file
, ",%d,0,0,%s\n", N_SOL
, <ext_label_name
[1]);
514 if (current_function_decl
!= NULL_TREE
515 && DECL_SECTION_NAME (current_function_decl
) != NULL_TREE
)
516 ; /* Don't change section amid function. */
519 ASM_OUTPUT_INTERNAL_LABEL (file
, "Ltext", source_label_number
);
520 source_label_number
++;
526 /* Output a line number symbol entry into output stream FILE,
527 for source file FILENAME and line number LINENO. */
530 dbxout_source_line (file
, filename
, lineno
)
532 const char *filename
;
535 dbxout_source_file (file
, filename
);
537 #ifdef ASM_OUTPUT_SOURCE_LINE
538 ASM_OUTPUT_SOURCE_LINE (file
, lineno
);
540 fprintf (file
, "%s%d,0,%d\n", ASM_STABD_OP
, N_SLINE
, lineno
);
544 /* At the end of compilation, finish writing the symbol table.
545 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
549 dbxout_finish (file
, filename
)
550 FILE *file ATTRIBUTE_UNUSED
;
551 const char *filename ATTRIBUTE_UNUSED
;
553 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
554 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file
, filename
);
555 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
558 /* Output the index of a type. */
561 dbxout_type_index (type
)
564 #ifndef DBX_USE_BINCL
565 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
568 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
569 fprintf (asmfile
, "(%d,%d)", t
->file_number
, t
->type_number
);
574 #if DBX_CONTIN_LENGTH > 0
575 /* Continue a symbol-description that gets too big.
576 End one symbol table entry with a double-backslash
577 and start a new one, eventually producing something like
578 .stabs "start......\\",code,0,value
579 .stabs "...rest",code,0,value */
584 #ifdef DBX_CONTIN_CHAR
585 fprintf (asmfile
, "%c", DBX_CONTIN_CHAR
);
587 fprintf (asmfile
, "\\\\");
589 dbxout_finish_symbol (NULL_TREE
);
590 fprintf (asmfile
, "%s\"", ASM_STABS_OP
);
591 current_sym_nchars
= 0;
593 #endif /* DBX_CONTIN_LENGTH > 0 */
595 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
596 This must be a separate function because anonymous unions require
600 dbxout_type_fields (type
)
605 /* Output the name, type, position (in bits), size (in bits) of each
606 field that we can support. */
607 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
609 /* Omit here local type decls until we know how to support them. */
610 if (TREE_CODE (tem
) == TYPE_DECL
611 /* Omit fields whose position or size are variable or too large to
613 || (TREE_CODE (tem
) == FIELD_DECL
614 && (! host_integerp (bit_position (tem
), 0)
616 || ! host_integerp (DECL_SIZE (tem
), 1)))
617 /* Omit here the nameless fields that are used to skip bits. */
618 || DECL_IGNORED_P (tem
))
621 else if (TREE_CODE (tem
) != CONST_DECL
)
623 /* Continue the line if necessary,
624 but not before the first field. */
625 if (tem
!= TYPE_FIELDS (type
))
630 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem
)));
631 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem
)));
635 fprintf (asmfile
, ":");
639 if (use_gnu_debug_info_extensions
640 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
641 || TREE_CODE (tem
) != FIELD_DECL
))
643 have_used_extensions
= 1;
645 putc ((TREE_PRIVATE (tem
) ? '0'
646 : TREE_PROTECTED (tem
) ? '1' : '2'),
651 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
652 && DECL_BIT_FIELD_TYPE (tem
))
653 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0);
655 if (TREE_CODE (tem
) == VAR_DECL
)
657 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
660 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
));
661 have_used_extensions
= 1;
662 fprintf (asmfile
, ":%s;", name
);
663 CHARS (strlen (name
));
666 /* If TEM is non-static, GDB won't understand it. */
667 fprintf (asmfile
, ",0,0;");
671 fputc (',', asmfile
);
672 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
673 int_bit_position (tem
));
674 fputc (',', asmfile
);
675 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
676 tree_low_cst (DECL_SIZE (tem
), 1));
677 fputc (';', asmfile
);
684 /* Subroutine of `dbxout_type_methods'. Output debug info about the
685 method described DECL. DEBUG_NAME is an encoding of the method's
686 type signature. ??? We may be able to do without DEBUG_NAME altogether
690 dbxout_type_method_1 (decl
, debug_name
)
692 const char *debug_name
;
696 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
698 else /* it's a METHOD_TYPE. */
700 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
701 /* A for normal functions.
702 B for `const' member functions.
703 C for `volatile' member functions.
704 D for `const volatile' member functions. */
705 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
707 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
710 if (DECL_VINDEX (decl
))
716 fprintf (asmfile
, ":%s;%c%c%c", debug_name
,
717 TREE_PRIVATE (decl
) ? '0'
718 : TREE_PROTECTED (decl
) ? '1' : '2', c1
, c2
);
719 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
)) + 6
720 - (debug_name
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
722 if (DECL_VINDEX (decl
) && host_integerp (DECL_VINDEX (decl
), 0))
724 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
725 tree_low_cst (DECL_VINDEX (decl
), 0));
726 fputc (';', asmfile
);
727 dbxout_type (DECL_CONTEXT (decl
), 0);
728 fprintf (asmfile
, ";");
733 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
737 dbxout_type_methods (type
)
740 /* C++: put out the method names and their parameter lists */
741 tree methods
= TYPE_METHODS (type
);
743 register tree fndecl
;
745 char formatted_type_identifier_length
[16];
746 register int type_identifier_length
;
748 if (methods
== NULL_TREE
)
751 type_encoding
= DECL_NAME (TYPE_NAME (type
));
754 /* C++: Template classes break some assumptions made by this code about
755 the class names, constructor names, and encodings for assembler
756 label names. For now, disable output of dbx info for them. */
758 const char *ptr
= IDENTIFIER_POINTER (type_encoding
);
759 /* This should use index. (mrs) */
760 while (*ptr
&& *ptr
!= '<') ptr
++;
771 type_identifier_length
= IDENTIFIER_LENGTH (type_encoding
);
773 sprintf (formatted_type_identifier_length
, "%d", type_identifier_length
);
775 if (TREE_CODE (methods
) != TREE_VEC
)
777 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
778 fndecl
= TREE_VEC_ELT (methods
, 0);
780 fndecl
= TREE_VEC_ELT (methods
, 1);
786 /* Group together all the methods for the same operation.
787 These differ in the types of the arguments. */
788 for (last
= NULL_TREE
;
789 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
790 fndecl
= TREE_CHAIN (fndecl
))
791 /* Output the name of the field (after overloading), as
792 well as the name of the field before overloading, along
793 with its parameter list */
795 /* This is the "mangled" name of the method.
796 It encodes the argument types. */
797 const char *debug_name
;
799 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
800 include TEMPLATE_DECLs.) The debugger doesn't know what
801 to do with such entities anyhow. */
802 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
806 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
));
812 /* Also ignore abstract methods; those are only interesting to
813 the DWARF backends. */
814 if (DECL_IGNORED_P (fndecl
) || DECL_ABSTRACT (fndecl
))
817 /* Redundantly output the plain name, since that's what gdb
821 tree name
= DECL_NAME (fndecl
);
822 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (name
));
823 CHARS (IDENTIFIER_LENGTH (name
) + 2);
827 dbxout_type (TREE_TYPE (fndecl
), 0);
829 dbxout_type_method_1 (fndecl
, debug_name
);
839 /* Emit a "range" type specification, which has the form:
840 "r<index type>;<lower bound>;<upper bound>;".
841 TYPE is an INTEGER_TYPE. */
844 dbxout_range_type (type
)
847 fprintf (asmfile
, "r");
848 if (TREE_TYPE (type
))
849 dbxout_type (TREE_TYPE (type
), 0);
850 else if (TREE_CODE (type
) != INTEGER_TYPE
)
851 dbxout_type (type
, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
854 /* Traditionally, we made sure 'int' was type 1, and builtin types
855 were defined to be sub-ranges of int. Unfortunately, this
856 does not allow us to distinguish true sub-ranges from integer
857 types. So, instead we define integer (non-sub-range) types as
858 sub-ranges of themselves. This matters for Chill. If this isn't
859 a subrange type, then we want to define it in terms of itself.
860 However, in C, this may be an anonymous integer type, and we don't
861 want to emit debug info referring to it. Just calling
862 dbxout_type_index won't work anyways, because the type hasn't been
863 defined yet. We make this work for both cases by checked to see
864 whether this is a defined type, referring to it if it is, and using
866 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
867 dbxout_type_index (type
);
869 dbxout_type_index (integer_type_node
);
872 if (TYPE_MIN_VALUE (type
) != 0
873 && host_integerp (TYPE_MIN_VALUE (type
), 0))
875 fputc (';', asmfile
);
876 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
877 tree_low_cst (TYPE_MIN_VALUE (type
), 0));
880 fprintf (asmfile
, ";0");
882 if (TYPE_MAX_VALUE (type
) != 0
883 && host_integerp (TYPE_MAX_VALUE (type
), 0))
885 fputc (';', asmfile
);
886 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
887 tree_low_cst (TYPE_MAX_VALUE (type
), 0));
888 fputc (';', asmfile
);
891 fprintf (asmfile
, ";-1;");
894 /* Output a reference to a type. If the type has not yet been
895 described in the dbx output, output its definition now.
896 For a type already defined, just refer to its definition
897 using the type number.
899 If FULL is nonzero, and the type has been described only with
900 a forward-reference, output the definition now.
901 If FULL is zero in this case, just refer to the forward-reference
902 using the number previously allocated. */
905 dbxout_type (type
, full
)
910 static int anonymous_type_number
= 0;
912 if (TREE_CODE (type
) == VECTOR_TYPE
)
913 type
= TYPE_DEBUG_REPRESENTATION_TYPE (type
);
915 /* If there was an input error and we don't really have a type,
916 avoid crashing and write something that is at least valid
917 by assuming `int'. */
918 if (type
== error_mark_node
)
919 type
= integer_type_node
;
922 /* Try to find the "main variant" with the same name but not const
923 or volatile. (Since stabs does not distinguish const and volatile,
924 there is no need to make them separate types. But types with
925 different names are usefully distinguished.) */
927 for (tem
= TYPE_MAIN_VARIANT (type
); tem
; tem
= TYPE_NEXT_VARIANT (tem
))
928 if (!TYPE_READONLY (tem
) && !TYPE_VOLATILE (tem
)
929 && TYPE_NAME (tem
) == TYPE_NAME (type
))
935 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
936 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
940 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
942 /* Type has no dbx number assigned. Assign next available number. */
943 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
945 /* Make sure type vector is long enough to record about this type. */
947 if (next_type_number
== typevec_len
)
950 = (struct typeinfo
*) xrealloc (typevec
,
951 typevec_len
* 2 * sizeof typevec
[0]);
952 memset ((char *) (typevec
+ typevec_len
), 0,
953 typevec_len
* sizeof typevec
[0]);
958 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
959 = current_file
->file_number
;
960 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
961 = current_file
->next_type_number
++;
965 /* Output the number of this type, to refer to it. */
966 dbxout_type_index (type
);
968 #ifdef DBX_TYPE_DEFINED
969 if (DBX_TYPE_DEFINED (type
))
973 /* If this type's definition has been output or is now being output,
976 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
981 /* If we have already had a cross reference,
982 and either that's all we want or that's the best we could do,
983 don't repeat the cross reference.
984 Sun dbx crashes if we do. */
985 if (! full
|| !COMPLETE_TYPE_P (type
)
986 /* No way in DBX fmt to describe a variable size. */
987 || ! host_integerp (TYPE_SIZE (type
), 1))
995 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
996 leave the type-number completely undefined rather than output
997 a cross-reference. If we have already used GNU debug info extensions,
998 then it is OK to output a cross reference. This is necessary to get
999 proper C++ debug output. */
1000 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1001 || TREE_CODE (type
) == QUAL_UNION_TYPE
1002 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1003 && ! use_gnu_debug_info_extensions
)
1004 /* We must use the same test here as we use twice below when deciding
1005 whether to emit a cross-reference. */
1006 if ((TYPE_NAME (type
) != 0
1007 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1008 && DECL_IGNORED_P (TYPE_NAME (type
)))
1010 || !COMPLETE_TYPE_P (type
)
1011 /* No way in DBX fmt to describe a variable size. */
1012 || ! host_integerp (TYPE_SIZE (type
), 1))
1014 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1019 /* Output a definition now. */
1021 fprintf (asmfile
, "=");
1024 /* Mark it as defined, so that if it is self-referent
1025 we will not get into an infinite recursion of definitions. */
1027 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1029 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1030 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1032 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0);
1036 switch (TREE_CODE (type
))
1040 /* For a void type, just define it as itself; ie, "5=5".
1041 This makes us consider it defined
1042 without saying what it is. The debugger will make it
1043 a void type when the reference is seen, and nothing will
1044 ever override that default. */
1045 dbxout_type_index (type
);
1049 if (type
== char_type_node
&& ! TREE_UNSIGNED (type
))
1051 /* Output the type `char' as a subrange of itself!
1052 I don't understand this definition, just copied it
1053 from the output of pcc.
1054 This used to use `r2' explicitly and we used to
1055 take care to make sure that `char' was type number 2. */
1056 fprintf (asmfile
, "r");
1057 dbxout_type_index (type
);
1058 fprintf (asmfile
, ";0;127;");
1061 /* If this is a subtype of another integer type, always prefer to
1062 write it as a subtype. */
1063 else if (TREE_TYPE (type
) != 0
1064 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
1065 dbxout_range_type (type
);
1069 /* If the size is non-standard, say what it is if we can use
1072 if (use_gnu_debug_info_extensions
1073 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1074 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1076 /* If we can use GDB extensions and the size is wider than a
1077 long (the size used by GDB to read them) or we may have
1078 trouble writing the bounds the usual way, write them in
1079 octal. Note the test is for the *target's* size of "long",
1080 not that of the host. The host test is just to make sure we
1081 can write it out in case the host wide int is narrower than the
1084 /* For unsigned types, we use octal if they are the same size or
1085 larger. This is because we print the bounds as signed decimal,
1086 and hence they can't span same size unsigned types. */
1088 if (use_gnu_debug_info_extensions
1089 && TYPE_MIN_VALUE (type
) != 0
1090 && TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
1091 && TYPE_MAX_VALUE (type
) != 0
1092 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
1093 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
1094 || ((TYPE_PRECISION (type
)
1095 == TYPE_PRECISION (integer_type_node
))
1096 && TREE_UNSIGNED (type
))
1097 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
1098 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
1099 && TREE_UNSIGNED (type
))))
1101 fprintf (asmfile
, "r");
1102 dbxout_type_index (type
);
1103 fprintf (asmfile
, ";");
1104 print_int_cst_octal (TYPE_MIN_VALUE (type
));
1105 fprintf (asmfile
, ";");
1106 print_int_cst_octal (TYPE_MAX_VALUE (type
));
1107 fprintf (asmfile
, ";");
1111 /* Output other integer types as subranges of `int'. */
1112 dbxout_range_type (type
);
1119 /* This used to say `r1' and we used to take care
1120 to make sure that `int' was type number 1. */
1121 fprintf (asmfile
, "r");
1122 dbxout_type_index (integer_type_node
);
1123 fputc (';', asmfile
);
1124 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1125 fputs (";0;", asmfile
);
1130 if (use_gnu_debug_info_extensions
)
1132 fputs ("@s", asmfile
);
1133 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1134 BITS_PER_UNIT
* int_size_in_bytes (type
));
1135 fputs (";-20;", asmfile
);
1139 /* Output the type `char' as a subrange of itself.
1140 That is what pcc seems to do. */
1141 fprintf (asmfile
, "r");
1142 dbxout_type_index (char_type_node
);
1143 fprintf (asmfile
, ";0;%d;", TREE_UNSIGNED (type
) ? 255 : 127);
1149 if (use_gnu_debug_info_extensions
)
1151 fputs ("@s", asmfile
);
1152 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1153 BITS_PER_UNIT
* int_size_in_bytes (type
));
1154 fputs (";-16;", asmfile
);
1156 else /* Define as enumeral type (False, True) */
1157 fprintf (asmfile
, "eFalse:0,True:1,;");
1162 putc ('d', asmfile
);
1164 dbxout_type (TREE_TYPE (type
), 0);
1168 /* Differs from the REAL_TYPE by its new data type number */
1170 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1172 fprintf (asmfile
, "r");
1173 dbxout_type_index (type
);
1174 fputc (';', asmfile
);
1175 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1176 2 * int_size_in_bytes (TREE_TYPE (type
)));
1177 fputs (";0;", asmfile
);
1178 CHARS (12); /* The number is probably incorrect here. */
1182 /* Output a complex integer type as a structure,
1183 pending some other way to do it. */
1184 fputc ('s', asmfile
);
1185 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1187 fprintf (asmfile
, "real:");
1189 dbxout_type (TREE_TYPE (type
), 0);
1190 fprintf (asmfile
, ",%d,%d;",
1191 0, TYPE_PRECISION (TREE_TYPE (type
)));
1193 fprintf (asmfile
, "imag:");
1195 dbxout_type (TREE_TYPE (type
), 0);
1196 fprintf (asmfile
, ",%d,%d;;",
1197 TYPE_PRECISION (TREE_TYPE (type
)),
1198 TYPE_PRECISION (TREE_TYPE (type
)));
1204 if (use_gnu_debug_info_extensions
)
1206 have_used_extensions
= 1;
1207 fputs ("@s", asmfile
);
1208 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1209 BITS_PER_UNIT
* int_size_in_bytes (type
));
1210 fputc (';', asmfile
);
1211 /* Check if a bitstring type, which in Chill is
1212 different from a [power]set. */
1213 if (TYPE_STRING_FLAG (type
))
1214 fprintf (asmfile
, "@S;");
1216 putc ('S', asmfile
);
1218 dbxout_type (TYPE_DOMAIN (type
), 0);
1222 /* Make arrays of packed bits look like bitstrings for chill. */
1223 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
1225 have_used_extensions
= 1;
1226 fputs ("@s", asmfile
);
1227 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1228 BITS_PER_UNIT
* int_size_in_bytes (type
));
1229 fputc (';', asmfile
);
1230 fprintf (asmfile
, "@S;");
1231 putc ('S', asmfile
);
1233 dbxout_type (TYPE_DOMAIN (type
), 0);
1236 /* Output "a" followed by a range type definition
1237 for the index type of the array
1238 followed by a reference to the target-type.
1239 ar1;0;N;M for a C array of type M and size N+1. */
1240 /* Check if a character string type, which in Chill is
1241 different from an array of characters. */
1242 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
1244 have_used_extensions
= 1;
1245 fprintf (asmfile
, "@S;");
1247 tem
= TYPE_DOMAIN (type
);
1250 fprintf (asmfile
, "ar");
1251 dbxout_type_index (integer_type_node
);
1252 fprintf (asmfile
, ";0;-1;");
1256 fprintf (asmfile
, "a");
1257 dbxout_range_type (tem
);
1260 dbxout_type (TREE_TYPE (type
), 0);
1265 case QUAL_UNION_TYPE
:
1267 int i
, n_baseclasses
= 0;
1269 if (TYPE_BINFO (type
) != 0
1270 && TREE_CODE (TYPE_BINFO (type
)) == TREE_VEC
1271 && TYPE_BINFO_BASETYPES (type
) != 0)
1272 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
1274 /* Output a structure type. We must use the same test here as we
1275 use in the DBX_NO_XREFS case above. */
1276 if ((TYPE_NAME (type
) != 0
1277 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1278 && DECL_IGNORED_P (TYPE_NAME (type
)))
1280 || !COMPLETE_TYPE_P (type
)
1281 /* No way in DBX fmt to describe a variable size. */
1282 || ! host_integerp (TYPE_SIZE (type
), 1))
1284 /* If the type is just a cross reference, output one
1285 and mark the type as partially described.
1286 If it later becomes defined, we will output
1287 its real definition.
1288 If the type has a name, don't nest its definition within
1289 another type's definition; instead, output an xref
1290 and let the definition come when the name is defined. */
1291 fputs ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu", asmfile
);
1293 #if 0 /* This assertion is legitimately false in C++. */
1294 /* We shouldn't be outputting a reference to a type before its
1295 definition unless the type has a tag name.
1296 A typedef name without a tag name should be impossible. */
1297 if (TREE_CODE (TYPE_NAME (type
)) != IDENTIFIER_NODE
)
1300 if (TYPE_NAME (type
) != 0)
1301 dbxout_type_name (type
);
1303 fprintf (asmfile
, "$$%d", anonymous_type_number
++);
1304 fprintf (asmfile
, ":");
1305 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1309 /* Identify record or union, and print its size. */
1310 fputc (((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u'), asmfile
);
1311 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1312 int_size_in_bytes (type
));
1314 if (use_gnu_debug_info_extensions
)
1318 have_used_extensions
= 1;
1319 fprintf (asmfile
, "!%d,", n_baseclasses
);
1323 for (i
= 0; i
< n_baseclasses
; i
++)
1325 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)), i
);
1327 if (use_gnu_debug_info_extensions
)
1329 have_used_extensions
= 1;
1330 putc (TREE_VIA_VIRTUAL (child
) ? '1' : '0', asmfile
);
1331 putc (TREE_VIA_PUBLIC (child
) ? '2' : '0', asmfile
);
1332 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1333 (tree_low_cst (BINFO_OFFSET (child
), 0)
1335 fputc (',', asmfile
);
1337 dbxout_type (BINFO_TYPE (child
), 0);
1338 putc (';', asmfile
);
1342 /* Print out the base class information with fields
1343 which have the same names at the types they hold. */
1344 dbxout_type_name (BINFO_TYPE (child
));
1345 putc (':', asmfile
);
1346 dbxout_type (BINFO_TYPE (child
), full
);
1347 fputc (',', asmfile
);
1348 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1349 tree_low_cst (BINFO_OFFSET (child
), 0)
1351 fputc (',', asmfile
);
1352 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1353 (tree_low_cst (DECL_SIZE (TYPE_NAME
1354 (BINFO_TYPE (child
))), 0)
1356 fputc (';', asmfile
);
1364 /* Write out the field declarations. */
1365 dbxout_type_fields (type
);
1366 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1368 have_used_extensions
= 1;
1369 dbxout_type_methods (type
);
1372 putc (';', asmfile
);
1374 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1375 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1376 && TYPE_VFIELD (type
))
1378 have_used_extensions
= 1;
1380 /* Tell GDB+ that it may keep reading. */
1381 putc ('~', asmfile
);
1383 /* We need to write out info about what field this class
1384 uses as its "main" vtable pointer field, because if this
1385 field is inherited from a base class, GDB cannot necessarily
1386 figure out which field it's using in time. */
1387 if (TYPE_VFIELD (type
))
1389 putc ('%', asmfile
);
1390 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0);
1392 putc (';', asmfile
);
1398 /* We must use the same test here as we use in the DBX_NO_XREFS case
1399 above. We simplify it a bit since an enum will never have a variable
1401 if ((TYPE_NAME (type
) != 0
1402 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1403 && DECL_IGNORED_P (TYPE_NAME (type
)))
1405 || !COMPLETE_TYPE_P (type
))
1407 fprintf (asmfile
, "xe");
1409 dbxout_type_name (type
);
1410 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1411 fprintf (asmfile
, ":");
1414 #ifdef DBX_OUTPUT_ENUM
1415 DBX_OUTPUT_ENUM (asmfile
, type
);
1417 if (use_gnu_debug_info_extensions
1418 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1419 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1420 putc ('e', asmfile
);
1422 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1424 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)));
1425 if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == 0)
1426 fprintf (asmfile
, HOST_WIDE_INT_PRINT_UNSIGNED
,
1427 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1428 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == -1
1429 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (TREE_VALUE (tem
)) < 0)
1430 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1431 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1433 print_int_cst_octal (TREE_VALUE (tem
));
1434 fprintf (asmfile
, ",");
1435 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)));
1436 if (TREE_CHAIN (tem
) != 0)
1441 putc (';', asmfile
);
1447 putc ('*', asmfile
);
1449 dbxout_type (TREE_TYPE (type
), 0);
1453 if (use_gnu_debug_info_extensions
)
1455 have_used_extensions
= 1;
1456 putc ('#', asmfile
);
1459 /* Write the argument types out longhand. */
1460 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0);
1461 putc (',', asmfile
);
1463 dbxout_type (TREE_TYPE (type
), 0);
1464 dbxout_args (TYPE_ARG_TYPES (type
));
1465 putc (';', asmfile
);
1470 /* Treat it as a function type. */
1471 dbxout_type (TREE_TYPE (type
), 0);
1476 if (use_gnu_debug_info_extensions
)
1478 have_used_extensions
= 1;
1479 putc ('@', asmfile
);
1481 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0);
1482 putc (',', asmfile
);
1484 dbxout_type (TREE_TYPE (type
), 0);
1488 /* Should print as an int, because it is really
1490 dbxout_type (integer_type_node
, 0);
1494 case REFERENCE_TYPE
:
1495 if (use_gnu_debug_info_extensions
)
1496 have_used_extensions
= 1;
1497 putc (use_gnu_debug_info_extensions
? '&' : '*', asmfile
);
1499 dbxout_type (TREE_TYPE (type
), 0);
1503 putc ('f', asmfile
);
1505 dbxout_type (TREE_TYPE (type
), 0);
1513 /* Print the value of integer constant C, in octal,
1514 handling double precision. */
1517 print_int_cst_octal (c
)
1520 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (c
);
1521 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (c
);
1522 int excess
= (3 - (HOST_BITS_PER_WIDE_INT
% 3));
1523 unsigned int width
= TYPE_PRECISION (TREE_TYPE (c
));
1525 /* GDB wants constants with no extra leading "1" bits, so
1526 we need to remove any sign-extension that might be
1528 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
1530 else if (width
> HOST_BITS_PER_WIDE_INT
)
1531 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
1532 else if (width
== HOST_BITS_PER_WIDE_INT
)
1535 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
1537 fprintf (asmfile
, "0");
1541 print_octal (high
, HOST_BITS_PER_WIDE_INT
/ 3);
1542 print_octal (low
, HOST_BITS_PER_WIDE_INT
/ 3);
1546 unsigned HOST_WIDE_INT beg
= high
>> excess
;
1547 unsigned HOST_WIDE_INT middle
1548 = ((high
& (((HOST_WIDE_INT
) 1 << excess
) - 1)) << (3 - excess
)
1549 | (low
>> (HOST_BITS_PER_WIDE_INT
/ 3 * 3)));
1550 unsigned HOST_WIDE_INT end
1551 = low
& (((unsigned HOST_WIDE_INT
) 1
1552 << (HOST_BITS_PER_WIDE_INT
/ 3 * 3))
1555 fprintf (asmfile
, "%o%01o", (int) beg
, (int) middle
);
1556 print_octal (end
, HOST_BITS_PER_WIDE_INT
/ 3);
1561 print_octal (value
, digits
)
1562 unsigned HOST_WIDE_INT value
;
1567 for (i
= digits
- 1; i
>= 0; i
--)
1568 fprintf (asmfile
, "%01o", (int) ((value
>> (3 * i
)) & 7));
1571 /* Output the name of type TYPE, with no punctuation.
1572 Such names can be set up either by typedef declarations
1573 or by struct, enum and union tags. */
1576 dbxout_type_name (type
)
1580 if (TYPE_NAME (type
) == 0)
1582 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
1584 t
= TYPE_NAME (type
);
1586 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1588 t
= DECL_NAME (TYPE_NAME (type
));
1593 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
1594 CHARS (IDENTIFIER_LENGTH (t
));
1597 /* Output a .stabs for the symbol defined by DECL,
1598 which must be a ..._DECL node in the normal namespace.
1599 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1600 LOCAL is nonzero if the scope is less than the entire file.
1601 Return 1 if a stabs might have been emitted. */
1604 dbxout_symbol (decl
, local
)
1606 int local ATTRIBUTE_UNUSED
;
1608 tree type
= TREE_TYPE (decl
);
1609 tree context
= NULL_TREE
;
1612 /* Cast avoids warning in old compilers. */
1613 current_sym_code
= (STAB_CODE_TYPE
) 0;
1614 current_sym_value
= 0;
1615 current_sym_addr
= 0;
1617 /* Ignore nameless syms, but don't ignore type tags. */
1619 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
1620 || DECL_IGNORED_P (decl
))
1623 dbxout_prepare_symbol (decl
);
1625 /* The output will always start with the symbol name,
1626 so always count that in the length-output-so-far. */
1628 if (DECL_NAME (decl
) != 0)
1629 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
1631 switch (TREE_CODE (decl
))
1634 /* Enum values are defined by defining the enum type. */
1638 if (DECL_RTL (decl
) == 0)
1640 if (DECL_EXTERNAL (decl
))
1642 /* Don't mention a nested function under its parent. */
1643 context
= decl_function_context (decl
);
1644 if (context
== current_function_decl
)
1646 if (GET_CODE (DECL_RTL (decl
)) != MEM
1647 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
1651 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
1652 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1653 TREE_PUBLIC (decl
) ? 'F' : 'f');
1656 current_sym_code
= N_FUN
;
1657 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1659 if (TREE_TYPE (type
))
1660 dbxout_type (TREE_TYPE (type
), 0);
1662 dbxout_type (void_type_node
, 0);
1664 /* For a nested function, when that function is compiled,
1665 mention the containing function name
1666 as well as (since dbx wants it) our own assembler-name. */
1668 fprintf (asmfile
, ",%s,%s",
1669 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1670 IDENTIFIER_POINTER (DECL_NAME (context
)));
1672 dbxout_finish_symbol (decl
);
1677 /* This seems all wrong. Outputting most kinds of types gives no name
1678 at all. A true definition gives no name; a cross-ref for a
1679 structure can give the tag name, but not a type name.
1680 It seems that no typedef name is defined by outputting a type. */
1682 /* If this typedef name was defined by outputting the type,
1683 don't duplicate it. */
1684 if (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
== TYPE_DEFINED
1685 && TYPE_NAME (TREE_TYPE (decl
)) == decl
)
1688 /* Don't output the same typedef twice.
1689 And don't output what language-specific stuff doesn't want output. */
1690 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
1699 if (DECL_NAME (decl
))
1701 /* Nonzero means we must output a tag as well as a typedef. */
1704 /* Handle the case of a C++ structure or union
1705 where the TYPE_NAME is a TYPE_DECL
1706 which gives both a typedef name and a tag. */
1707 /* dbx requires the tag first and the typedef second. */
1708 if ((TREE_CODE (type
) == RECORD_TYPE
1709 || TREE_CODE (type
) == UNION_TYPE
1710 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1711 && TYPE_NAME (type
) == decl
1712 && !(use_gnu_debug_info_extensions
&& have_used_extensions
)
1713 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
1714 /* Distinguish the implicit typedefs of C++
1715 from explicit ones that might be found in C. */
1716 && DECL_ARTIFICIAL (decl
)
1717 /* Do not generate a tag for records of variable size,
1718 since this type can not be properly described in the
1719 DBX format, and it confuses some tools such as objdump. */
1720 && host_integerp (TYPE_SIZE (type
), 1))
1722 tree name
= TYPE_NAME (type
);
1723 if (TREE_CODE (name
) == TYPE_DECL
)
1724 name
= DECL_NAME (name
);
1726 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1727 current_sym_value
= 0;
1728 current_sym_addr
= 0;
1729 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1731 fprintf (asmfile
, "%s\"%s:T", ASM_STABS_OP
,
1732 IDENTIFIER_POINTER (name
));
1733 dbxout_type (type
, 1);
1734 dbxout_finish_symbol (NULL_TREE
);
1737 /* Output typedef name. */
1738 fprintf (asmfile
, "%s\"%s:", ASM_STABS_OP
,
1739 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1741 /* Short cut way to output a tag also. */
1742 if ((TREE_CODE (type
) == RECORD_TYPE
1743 || TREE_CODE (type
) == UNION_TYPE
1744 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1745 && TYPE_NAME (type
) == decl
1746 /* Distinguish the implicit typedefs of C++
1747 from explicit ones that might be found in C. */
1748 && DECL_ARTIFICIAL (decl
))
1750 if (use_gnu_debug_info_extensions
&& have_used_extensions
)
1752 putc ('T', asmfile
);
1753 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
1755 #if 0 /* Now we generate the tag for this case up above. */
1761 putc ('t', asmfile
);
1762 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1764 dbxout_type (type
, 1);
1765 dbxout_finish_symbol (decl
);
1769 /* Don't output a tag if this is an incomplete type. This prevents
1770 the sun4 Sun OS 4.x dbx from crashing. */
1772 if (tag_needed
&& TYPE_NAME (type
) != 0
1773 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
1774 || (DECL_NAME (TYPE_NAME (type
)) != 0))
1775 && COMPLETE_TYPE_P (type
)
1776 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1778 /* For a TYPE_DECL with no name, but the type has a name,
1780 This is what represents `struct foo' with no typedef. */
1781 /* In C++, the name of a type is the corresponding typedef.
1782 In C, it is an IDENTIFIER_NODE. */
1783 tree name
= TYPE_NAME (type
);
1784 if (TREE_CODE (name
) == TYPE_DECL
)
1785 name
= DECL_NAME (name
);
1787 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1788 current_sym_value
= 0;
1789 current_sym_addr
= 0;
1790 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1792 fprintf (asmfile
, "%s\"%s:T", ASM_STABS_OP
,
1793 IDENTIFIER_POINTER (name
));
1794 dbxout_type (type
, 1);
1795 dbxout_finish_symbol (NULL_TREE
);
1799 /* If an enum type has no name, it cannot be referred to,
1800 but we must output it anyway, since the enumeration constants
1801 can be referred to. */
1802 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
1804 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1805 current_sym_value
= 0;
1806 current_sym_addr
= 0;
1807 current_sym_nchars
= 2;
1809 /* Some debuggers fail when given NULL names, so give this a
1810 harmless name of ` '. */
1811 fprintf (asmfile
, "%s\" :T", ASM_STABS_OP
);
1812 dbxout_type (type
, 1);
1813 dbxout_finish_symbol (NULL_TREE
);
1816 /* Prevent duplicate output of a typedef. */
1817 TREE_ASM_WRITTEN (decl
) = 1;
1822 /* Parm decls go in their own separate chains
1823 and are output by dbxout_reg_parms and dbxout_parms. */
1827 /* Named return value, treat like a VAR_DECL. */
1829 if (! DECL_RTL_SET_P (decl
))
1831 /* Don't mention a variable that is external.
1832 Let the file that defines it describe it. */
1833 if (DECL_EXTERNAL (decl
))
1836 /* If the variable is really a constant
1837 and not written in memory, inform the debugger. */
1838 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
1839 && DECL_INITIAL (decl
) != 0
1840 && host_integerp (DECL_INITIAL (decl
), 0)
1841 && ! TREE_ASM_WRITTEN (decl
)
1842 && (DECL_CONTEXT (decl
) == NULL_TREE
1843 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
))
1845 if (TREE_PUBLIC (decl
) == 0)
1847 /* The sun4 assembler does not grok this. */
1848 const char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1850 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
1851 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
1853 HOST_WIDE_INT ival
= tree_low_cst (DECL_INITIAL (decl
), 0);
1854 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1855 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile
, name
, ival
);
1857 fprintf (asmfile
, "%s\"%s:c=i", ASM_STABS_OP
, name
);
1859 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, ival
);
1860 fprintf (asmfile
, "\",0x%x,0,0,0\n", N_LSYM
);
1864 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
1866 /* don't know how to do this yet. */
1870 /* else it is something we handle like a normal variable. */
1873 SET_DECL_RTL (decl
, eliminate_regs (DECL_RTL (decl
), 0, NULL_RTX
));
1874 #ifdef LEAF_REG_REMAP
1875 if (current_function_uses_only_leaf_regs
)
1876 leaf_renumber_regs_insn (DECL_RTL (decl
));
1879 result
= dbxout_symbol_location (decl
, type
, 0, DECL_RTL (decl
));
1888 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1889 Add SUFFIX to its name, if SUFFIX is not 0.
1890 Describe the variable as residing in HOME
1891 (usually HOME is DECL_RTL (DECL), but not always).
1892 Returns 1 if the stab was really emitted. */
1895 dbxout_symbol_location (decl
, type
, suffix
, home
)
1903 /* Don't mention a variable at all
1904 if it was completely optimized into nothingness.
1906 If the decl was from an inline function, then its rtl
1907 is not identically the rtl that was used in this
1908 particular compilation. */
1909 if (GET_CODE (home
) == REG
)
1911 regno
= REGNO (home
);
1912 if (regno
>= FIRST_PSEUDO_REGISTER
)
1915 else if (GET_CODE (home
) == SUBREG
)
1919 while (GET_CODE (value
) == SUBREG
)
1920 value
= SUBREG_REG (value
);
1921 if (GET_CODE (value
) == REG
)
1923 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
1926 regno
= REGNO (alter_subreg (home
));
1929 /* The kind-of-variable letter depends on where
1930 the variable is and on the scope of its name:
1931 G and N_GSYM for static storage and global scope,
1932 S for static storage and file scope,
1933 V for static storage and local scope,
1934 for those two, use N_LCSYM if data is in bss segment,
1935 N_STSYM if in data segment, N_FUN otherwise.
1936 (We used N_FUN originally, then changed to N_STSYM
1937 to please GDB. However, it seems that confused ld.
1938 Now GDB has been fixed to like N_FUN, says Kingdon.)
1939 no letter at all, and N_LSYM, for auto variable,
1940 r and N_RSYM for register variable. */
1942 if (GET_CODE (home
) == MEM
1943 && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
1945 if (TREE_PUBLIC (decl
))
1948 current_sym_code
= N_GSYM
;
1952 current_sym_addr
= XEXP (home
, 0);
1954 letter
= decl_function_context (decl
) ? 'V' : 'S';
1956 /* This should be the same condition as in assemble_variable, but
1957 we don't have access to dont_output_data here. So, instead,
1958 we rely on the fact that error_mark_node initializers always
1959 end up in bss for C++ and never end up in bss for C. */
1960 if (DECL_INITIAL (decl
) == 0
1961 || (!strcmp (lang_identify (), "cplusplus")
1962 && DECL_INITIAL (decl
) == error_mark_node
))
1963 current_sym_code
= N_LCSYM
;
1964 else if (DECL_IN_TEXT_SECTION (decl
))
1965 /* This is not quite right, but it's the closest
1966 of all the codes that Unix defines. */
1967 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
1970 /* Ultrix `as' seems to need this. */
1971 #ifdef DBX_STATIC_STAB_DATA_SECTION
1974 current_sym_code
= N_STSYM
;
1978 else if (regno
>= 0)
1981 current_sym_code
= N_RSYM
;
1982 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
1984 else if (GET_CODE (home
) == MEM
1985 && (GET_CODE (XEXP (home
, 0)) == MEM
1986 || (GET_CODE (XEXP (home
, 0)) == REG
1987 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
1988 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
1989 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
1990 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
1993 /* If the value is indirect by memory or by a register
1994 that isn't the frame pointer
1995 then it means the object is variable-sized and address through
1996 that register or stack slot. DBX has no way to represent this
1997 so all we can do is output the variable as a pointer.
1998 If it's not a parameter, ignore it.
1999 (VAR_DECLs like this can be made by integrate.c.) */
2001 if (GET_CODE (XEXP (home
, 0)) == REG
)
2004 current_sym_code
= N_RSYM
;
2005 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
2009 current_sym_code
= N_LSYM
;
2010 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2011 We want the value of that CONST_INT. */
2013 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
2016 /* Effectively do build_pointer_type, but don't cache this type,
2017 since it might be temporary whereas the type it points to
2018 might have been saved for inlining. */
2019 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2020 type
= make_node (POINTER_TYPE
);
2021 TREE_TYPE (type
) = TREE_TYPE (decl
);
2023 else if (GET_CODE (home
) == MEM
2024 && GET_CODE (XEXP (home
, 0)) == REG
)
2026 current_sym_code
= N_LSYM
;
2027 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2029 else if (GET_CODE (home
) == MEM
2030 && GET_CODE (XEXP (home
, 0)) == PLUS
2031 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
2033 current_sym_code
= N_LSYM
;
2034 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2035 We want the value of that CONST_INT. */
2036 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2038 else if (GET_CODE (home
) == MEM
2039 && GET_CODE (XEXP (home
, 0)) == CONST
)
2041 /* Handle an obscure case which can arise when optimizing and
2042 when there are few available registers. (This is *always*
2043 the case for i386/i486 targets). The RTL looks like
2044 (MEM (CONST ...)) even though this variable is a local `auto'
2045 or a local `register' variable. In effect, what has happened
2046 is that the reload pass has seen that all assignments and
2047 references for one such a local variable can be replaced by
2048 equivalent assignments and references to some static storage
2049 variable, thereby avoiding the need for a register. In such
2050 cases we're forced to lie to debuggers and tell them that
2051 this variable was itself `static'. */
2052 current_sym_code
= N_LCSYM
;
2054 current_sym_addr
= XEXP (XEXP (home
, 0), 0);
2056 else if (GET_CODE (home
) == CONCAT
)
2060 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
2061 for example), then there is no easy way to figure out
2062 what SUBTYPE should be. So, we give up. */
2063 if (TREE_CODE (type
) != COMPLEX_TYPE
)
2066 subtype
= TREE_TYPE (type
);
2068 /* If the variable's storage is in two parts,
2069 output each as a separate stab with a modified name. */
2070 if (WORDS_BIG_ENDIAN
)
2071 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
2073 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
2075 /* Cast avoids warning in old compilers. */
2076 current_sym_code
= (STAB_CODE_TYPE
) 0;
2077 current_sym_value
= 0;
2078 current_sym_addr
= 0;
2079 dbxout_prepare_symbol (decl
);
2081 if (WORDS_BIG_ENDIAN
)
2082 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
2084 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
2088 /* Address might be a MEM, when DECL is a variable-sized object.
2089 Or it might be const0_rtx, meaning previous passes
2090 want us to ignore this variable. */
2093 /* Ok, start a symtab entry and output the variable name. */
2096 #ifdef DBX_STATIC_BLOCK_START
2097 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
2100 dbxout_symbol_name (decl
, suffix
, letter
);
2101 dbxout_type (type
, 0);
2102 dbxout_finish_symbol (decl
);
2104 #ifdef DBX_STATIC_BLOCK_END
2105 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
2110 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2111 Then output LETTER to indicate the kind of location the symbol has. */
2114 dbxout_symbol_name (decl
, suffix
, letter
)
2121 if (DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
)))
2122 /* One slight hitch: if this is a VAR_DECL which is a static
2123 class member, we must put out the mangled name instead of the
2124 DECL_NAME. Note also that static member (variable) names DO NOT begin
2125 with underscores in .stabs directives. */
2126 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2128 /* ...but if we're function-local, we don't want to include the junk
2129 added by ASM_FORMAT_PRIVATE_NAME. */
2130 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
2134 fprintf (asmfile
, "%s\"%s%s:", ASM_STABS_OP
, name
,
2135 (suffix
? suffix
: ""));
2137 if (letter
) putc (letter
, asmfile
);
2141 dbxout_prepare_symbol (decl
)
2142 tree decl ATTRIBUTE_UNUSED
;
2145 const char *filename
= DECL_SOURCE_FILE (decl
);
2147 dbxout_source_file (asmfile
, filename
);
2152 dbxout_finish_symbol (sym
)
2155 #ifdef DBX_FINISH_SYMBOL
2156 DBX_FINISH_SYMBOL (sym
);
2159 if (use_gnu_debug_info_extensions
&& sym
!= 0)
2160 line
= DECL_SOURCE_LINE (sym
);
2162 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
2163 if (current_sym_addr
)
2164 output_addr_const (asmfile
, current_sym_addr
);
2166 fprintf (asmfile
, "%d", current_sym_value
);
2167 putc ('\n', asmfile
);
2171 /* Output definitions of all the decls in a chain. Return non-zero if
2172 anything was output */
2181 result
+= dbxout_symbol (syms
, 1);
2182 syms
= TREE_CHAIN (syms
);
2187 /* The following two functions output definitions of function parameters.
2188 Each parameter gets a definition locating it in the parameter list.
2189 Each parameter that is a register variable gets a second definition
2190 locating it in the register.
2192 Printing or argument lists in gdb uses the definitions that
2193 locate in the parameter list. But reference to the variable in
2194 expressions uses preferentially the definition as a register. */
2196 /* Output definitions, referring to storage in the parmlist,
2197 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2200 dbxout_parms (parms
)
2203 for (; parms
; parms
= TREE_CHAIN (parms
))
2204 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
2206 dbxout_prepare_symbol (parms
);
2208 /* Perform any necessary register eliminations on the parameter's rtl,
2209 so that the debugging output will be accurate. */
2210 DECL_INCOMING_RTL (parms
)
2211 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
2212 SET_DECL_RTL (parms
, eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
));
2213 #ifdef LEAF_REG_REMAP
2214 if (current_function_uses_only_leaf_regs
)
2216 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
2217 leaf_renumber_regs_insn (DECL_RTL (parms
));
2221 if (PARM_PASSED_IN_MEMORY (parms
))
2223 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
2225 /* ??? Here we assume that the parm address is indexed
2226 off the frame pointer or arg pointer.
2227 If that is not true, we produce meaningless results,
2228 but do not crash. */
2229 if (GET_CODE (addr
) == PLUS
2230 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
2231 current_sym_value
= INTVAL (XEXP (addr
, 1));
2233 current_sym_value
= 0;
2235 current_sym_code
= N_PSYM
;
2236 current_sym_addr
= 0;
2239 if (DECL_NAME (parms
))
2241 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2243 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2244 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2245 DBX_MEMPARM_STABS_LETTER
);
2249 current_sym_nchars
= 8;
2250 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2251 DBX_MEMPARM_STABS_LETTER
);
2254 /* It is quite tempting to use:
2256 dbxout_type (TREE_TYPE (parms), 0);
2258 as the next statement, rather than using DECL_ARG_TYPE(), so
2259 that gcc reports the actual type of the parameter, rather
2260 than the promoted type. This certainly makes GDB's life
2261 easier, at least for some ports. The change is a bad idea
2262 however, since GDB expects to be able access the type without
2263 performing any conversions. So for example, if we were
2264 passing a float to an unprototyped function, gcc will store a
2265 double on the stack, but if we emit a stab saying the type is a
2266 float, then gdb will only read in a single value, and this will
2267 produce an erropneous value. */
2268 dbxout_type (DECL_ARG_TYPE (parms
), 0);
2269 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
2270 dbxout_finish_symbol (parms
);
2272 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
2275 char regparm_letter
;
2277 /* Parm passed in registers and lives in registers or nowhere. */
2279 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2280 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2281 current_sym_addr
= 0;
2283 /* If parm lives in a register, use that register;
2284 pretend the parm was passed there. It would be more consistent
2285 to describe the register where the parm was passed,
2286 but in practice that register usually holds something else.
2288 If we use DECL_RTL, then we must use the declared type of
2289 the variable, not the type that it arrived in. */
2290 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2292 best_rtl
= DECL_RTL (parms
);
2293 parm_type
= TREE_TYPE (parms
);
2295 /* If the parm lives nowhere, use the register where it was
2296 passed. It is also better to use the declared type here. */
2299 best_rtl
= DECL_INCOMING_RTL (parms
);
2300 parm_type
= TREE_TYPE (parms
);
2302 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
2305 if (DECL_NAME (parms
))
2307 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2308 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2309 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2314 current_sym_nchars
= 8;
2315 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2319 dbxout_type (parm_type
, 0);
2320 dbxout_finish_symbol (parms
);
2322 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2323 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
2324 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
2325 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
2326 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2327 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
2331 /* Parm was passed via invisible reference.
2332 That is, its address was passed in a register.
2333 Output it as if it lived in that register.
2334 The debugger will know from the type
2335 that it was actually passed by invisible reference. */
2337 char regparm_letter
;
2338 /* Parm passed in registers and lives in registers or nowhere. */
2340 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2341 if (use_gnu_debug_info_extensions
)
2342 regparm_letter
= GDB_INV_REF_REGPARM_STABS_LETTER
;
2344 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2346 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2347 If it is an unallocated pseudo-reg, then use the register where
2348 it was passed instead. */
2349 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
2350 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
2352 current_sym_value
= REGNO (DECL_INCOMING_RTL (parms
));
2354 current_sym_addr
= 0;
2357 if (DECL_NAME (parms
))
2359 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2361 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2362 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2367 current_sym_nchars
= 8;
2368 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2372 dbxout_type (TREE_TYPE (parms
), 0);
2373 dbxout_finish_symbol (parms
);
2375 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2376 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
2378 /* Parm was passed via invisible reference, with the reference
2379 living on the stack. DECL_RTL looks like
2380 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
2381 could look like (MEM (MEM (REG))). */
2382 const char *decl_name
= (DECL_NAME (parms
)
2383 ? IDENTIFIER_POINTER (DECL_NAME (parms
))
2385 if (GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 0)) == REG
)
2386 current_sym_value
= 0;
2389 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
2390 current_sym_addr
= 0;
2393 fprintf (asmfile
, "%s\"%s:v", ASM_STABS_OP
, decl_name
);
2394 dbxout_type (TREE_TYPE (parms
), 0);
2395 dbxout_finish_symbol (parms
);
2397 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2398 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
2399 /* ??? A constant address for a parm can happen
2400 when the reg it lives in is equiv to a constant in memory.
2401 Should make this not happen, after 2.4. */
2402 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
2404 /* Parm was passed in registers but lives on the stack. */
2406 current_sym_code
= N_PSYM
;
2407 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2408 in which case we want the value of that CONST_INT,
2410 in which case we use a value of zero. */
2411 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
)
2412 current_sym_value
= 0;
2415 = INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
2417 current_sym_addr
= 0;
2419 /* Make a big endian correction if the mode of the type of the
2420 parameter is not the same as the mode of the rtl. */
2421 if (BYTES_BIG_ENDIAN
2422 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
2423 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
2425 current_sym_value
+=
2426 GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
2427 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
)));
2431 if (DECL_NAME (parms
))
2434 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2436 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2437 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2438 DBX_MEMPARM_STABS_LETTER
);
2442 current_sym_nchars
= 8;
2443 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2444 DBX_MEMPARM_STABS_LETTER
);
2448 = DEBUGGER_ARG_OFFSET (current_sym_value
,
2449 XEXP (DECL_RTL (parms
), 0));
2450 dbxout_type (TREE_TYPE (parms
), 0);
2451 dbxout_finish_symbol (parms
);
2456 /* Output definitions for the places where parms live during the function,
2457 when different from where they were passed, when the parms were passed
2460 It is not useful to do this for parms passed in registers
2461 that live during the function in different registers, because it is
2462 impossible to look in the passed register for the passed value,
2463 so we use the within-the-function register to begin with.
2465 PARMS is a chain of PARM_DECL nodes. */
2468 dbxout_reg_parms (parms
)
2471 for (; parms
; parms
= TREE_CHAIN (parms
))
2472 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
2474 dbxout_prepare_symbol (parms
);
2476 /* Report parms that live in registers during the function
2477 but were passed in memory. */
2478 if (GET_CODE (DECL_RTL (parms
)) == REG
2479 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2480 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2481 0, DECL_RTL (parms
));
2482 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
2483 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2484 0, DECL_RTL (parms
));
2485 /* Report parms that live in memory but not where they were passed. */
2486 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2487 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
2488 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2489 0, DECL_RTL (parms
));
2493 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2494 output definitions of those names, in raw form */
2502 putc (',', asmfile
);
2503 dbxout_type (TREE_VALUE (args
), 0);
2505 args
= TREE_CHAIN (args
);
2509 /* Given a chain of ..._TYPE nodes,
2510 find those which have typedef names and output those names.
2511 This is to ensure those types get output. */
2514 dbxout_types (types
)
2515 register tree types
;
2519 if (TYPE_NAME (types
)
2520 && TREE_CODE (TYPE_NAME (types
)) == TYPE_DECL
2521 && ! TREE_ASM_WRITTEN (TYPE_NAME (types
)))
2522 dbxout_symbol (TYPE_NAME (types
), 1);
2523 types
= TREE_CHAIN (types
);
2527 /* Output everything about a symbol block (a BLOCK node
2528 that represents a scope level),
2529 including recursive output of contained blocks.
2531 BLOCK is the BLOCK node.
2532 DEPTH is its depth within containing symbol blocks.
2533 ARGS is usually zero; but for the outermost block of the
2534 body of a function, it is a chain of PARM_DECLs for the function parameters.
2535 We output definitions of all the register parms
2536 as if they were local variables of that block.
2538 If -g1 was used, we count blocks just the same, but output nothing
2539 except for the outermost block.
2541 Actually, BLOCK may be several blocks chained together.
2542 We handle them all in sequence. */
2545 dbxout_block (block
, depth
, args
)
2546 register tree block
;
2552 #if DBX_BLOCKS_FUNCTION_RELATIVE
2553 const char *begin_label
;
2554 if (current_function_func_begin_label
!= NULL_TREE
)
2555 begin_label
= IDENTIFIER_POINTER (current_function_func_begin_label
);
2557 begin_label
= XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0);
2562 /* Ignore blocks never expanded or otherwise marked as real. */
2563 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
2567 #ifdef DBX_LBRAC_FIRST
2570 /* In dbx format, the syms of a block come before the N_LBRAC.
2571 If nothing is output, we don't need the N_LBRAC, either. */
2573 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2574 did_output
= dbxout_syms (BLOCK_VARS (block
));
2576 dbxout_reg_parms (args
);
2579 /* Now output an N_LBRAC symbol to represent the beginning of
2580 the block. Use the block's tree-walk order to generate
2581 the assembler symbols LBBn and LBEn
2582 that final will define around the code in this block. */
2583 if (depth
> 0 && did_output
)
2586 blocknum
= BLOCK_NUMBER (block
);
2587 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
2589 if (BLOCK_HANDLER_BLOCK (block
))
2591 /* A catch block. Must precede N_LBRAC. */
2592 tree decl
= BLOCK_VARS (block
);
2595 #ifdef DBX_OUTPUT_CATCH
2596 DBX_OUTPUT_CATCH (asmfile
, decl
, buf
);
2598 fprintf (asmfile
, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP
,
2599 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
2600 assemble_name (asmfile
, buf
);
2601 fprintf (asmfile
, "\n");
2603 decl
= TREE_CHAIN (decl
);
2607 #ifdef DBX_OUTPUT_LBRAC
2608 DBX_OUTPUT_LBRAC (asmfile
, buf
);
2610 fprintf (asmfile
, "%s%d,0,0,", ASM_STABN_OP
, N_LBRAC
);
2611 assemble_name (asmfile
, buf
);
2612 #if DBX_BLOCKS_FUNCTION_RELATIVE
2613 fputc ('-', asmfile
);
2614 assemble_name (asmfile
, begin_label
);
2616 fprintf (asmfile
, "\n");
2620 #ifdef DBX_LBRAC_FIRST
2621 /* On some weird machines, the syms of a block
2622 come after the N_LBRAC. */
2623 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2624 dbxout_syms (BLOCK_VARS (block
));
2626 dbxout_reg_parms (args
);
2629 /* Output the subblocks. */
2630 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
2632 /* Refer to the marker for the end of the block. */
2633 if (depth
> 0 && did_output
)
2636 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
2637 #ifdef DBX_OUTPUT_RBRAC
2638 DBX_OUTPUT_RBRAC (asmfile
, buf
);
2640 fprintf (asmfile
, "%s%d,0,0,", ASM_STABN_OP
, N_RBRAC
);
2641 assemble_name (asmfile
, buf
);
2642 #if DBX_BLOCKS_FUNCTION_RELATIVE
2643 fputc ('-', asmfile
);
2644 assemble_name (asmfile
, begin_label
);
2646 fprintf (asmfile
, "\n");
2650 block
= BLOCK_CHAIN (block
);
2654 /* Output the information about a function and its arguments and result.
2655 Usually this follows the function's code,
2656 but on some systems, it comes before. */
2659 dbxout_really_begin_function (decl
)
2662 dbxout_symbol (decl
, 0);
2663 dbxout_parms (DECL_ARGUMENTS (decl
));
2664 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
2665 dbxout_symbol (DECL_RESULT (decl
), 1);
2668 /* Called at beginning of output of function definition. */
2671 dbxout_begin_function (decl
)
2672 tree decl ATTRIBUTE_UNUSED
;
2674 #ifdef DBX_FUNCTION_FIRST
2675 dbxout_really_begin_function (decl
);
2679 /* Output dbx data for a function definition.
2680 This includes a definition of the function name itself (a symbol),
2681 definitions of the parameters (locating them in the parameter list)
2682 and then output the block that makes up the function's body
2683 (including all the auto variables of the function). */
2686 dbxout_function (decl
)
2689 #ifndef DBX_FUNCTION_FIRST
2690 dbxout_really_begin_function (decl
);
2692 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
2693 #ifdef DBX_OUTPUT_FUNCTION_END
2694 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
2696 #if defined(ASM_OUTPUT_SECTION_NAME)
2697 if (use_gnu_debug_info_extensions
2698 #if defined(NO_DBX_FUNCTION_END)
2699 && ! NO_DBX_FUNCTION_END
2702 dbxout_function_end ();
2705 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */