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. */
86 #ifdef XCOFF_DEBUGGING_INFO
91 #define ASM_STABS_OP "\t.stabs\t"
95 #define ASM_STABN_OP "\t.stabn\t"
98 #ifndef DBX_TYPE_DECL_STABS_CODE
99 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
102 #ifndef DBX_STATIC_CONST_VAR_CODE
103 #define DBX_STATIC_CONST_VAR_CODE N_FUN
106 #ifndef DBX_REGPARM_STABS_CODE
107 #define DBX_REGPARM_STABS_CODE N_RSYM
110 #ifndef DBX_REGPARM_STABS_LETTER
111 #define DBX_REGPARM_STABS_LETTER 'P'
114 /* This is used for parameters passed by invisible reference in a register. */
115 #ifndef GDB_INV_REF_REGPARM_STABS_LETTER
116 #define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
119 #ifndef DBX_MEMPARM_STABS_LETTER
120 #define DBX_MEMPARM_STABS_LETTER 'p'
123 #ifndef FILE_NAME_JOINER
124 #define FILE_NAME_JOINER "/"
127 /* Nonzero means if the type has methods, only output debugging
128 information if methods are actually written to the asm file. This
129 optimization only works if the debugger can detect the special C++
132 #define MINIMAL_DEBUG 1
134 #ifdef NO_DOLLAR_IN_LABEL
135 #ifdef NO_DOT_IN_LABEL
137 #define MINIMAL_DEBUG 0
141 /* Typical USG systems don't have stab.h, and they also have
142 no use for DBX-format debugging info. */
144 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
146 static int flag_minimal_debug
= MINIMAL_DEBUG
;
148 /* Nonzero if we have actually used any of the GDB extensions
149 to the debugging format. The idea is that we use them for the
150 first time only if there's a strong reason, but once we have done that,
151 we use them whenever convenient. */
153 static int have_used_extensions
= 0;
155 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
156 for the N_SO filename stabs label. */
158 static int source_label_number
= 1;
160 #ifdef DEBUG_SYMS_TEXT
161 #define FORCE_TEXT text_section ();
166 /* If there is a system stab.h, use it. Otherwise, use our own. */
167 /* ??? This is supposed to describe the target's stab format, so using
168 the host HAVE_STAB_H appears to be wrong. For now, we use our own file
169 when cross compiling. */
170 #if defined (USG) || !defined (HAVE_STAB_H) || defined (CROSS_COMPILE)
171 #include "gstab.h" /* If doing DBX on sysV, use our own stab.h. */
175 /* This is a GNU extension we need to reference in this file. */
182 #define STAB_CODE_TYPE enum __stab_debug_code
184 #define STAB_CODE_TYPE int
187 /* 1 if PARM is passed to this function in memory. */
189 #define PARM_PASSED_IN_MEMORY(PARM) \
190 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
192 /* A C expression for the integer offset value of an automatic variable
193 (N_LSYM) having address X (an RTX). */
194 #ifndef DEBUGGER_AUTO_OFFSET
195 #define DEBUGGER_AUTO_OFFSET(X) \
196 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
199 /* A C expression for the integer offset value of an argument (N_PSYM)
200 having address X (an RTX). The nominal offset is OFFSET. */
201 #ifndef DEBUGGER_ARG_OFFSET
202 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
205 /* Stream for writing to assembler file. */
207 static FILE *asmfile
;
209 /* Last source file name mentioned in a NOTE insn. */
211 static const char *lastfile
;
213 /* Current working directory. */
215 static const char *cwd
;
217 enum typestatus
{TYPE_UNSEEN
, TYPE_XREF
, TYPE_DEFINED
};
219 /* Structure recording information about a C data type.
220 The status element says whether we have yet output
221 the definition of the type. TYPE_XREF says we have
222 output it as a cross-reference only.
223 The file_number and type_number elements are used if DBX_USE_BINCL
228 enum typestatus status
;
235 /* Vector recording information about C data types.
236 When we first notice a data type (a tree node),
237 we assign it a number using next_type_number.
238 That is its index in this vector. */
240 struct typeinfo
*typevec
;
242 /* Number of elements of space allocated in `typevec'. */
244 static int typevec_len
;
246 /* In dbx output, each type gets a unique number.
247 This is the number for the next type output.
248 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
250 static int next_type_number
;
254 /* When using N_BINCL in dbx output, each type number is actually a
255 pair of the file number and the type number within the file.
256 This is a stack of input files. */
260 struct dbx_file
*next
;
262 int next_type_number
;
265 /* This is the top of the stack. */
267 static struct dbx_file
*current_file
;
269 /* This is the next file number to use. */
271 static int next_file_number
;
273 #endif /* DBX_USE_BINCL */
275 /* These variables are for dbxout_symbol to communicate to
276 dbxout_finish_symbol.
277 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
278 current_sym_value and current_sym_addr are two ways to address the
279 value to store in the symtab entry.
280 current_sym_addr if nonzero represents the value as an rtx.
281 If that is zero, current_sym_value is used. This is used
282 when the value is an offset (such as for auto variables,
283 register variables and parms). */
285 static STAB_CODE_TYPE current_sym_code
;
286 static int current_sym_value
;
287 static rtx current_sym_addr
;
289 /* Number of chars of symbol-description generated so far for the
290 current symbol. Used by CHARS and CONTIN. */
292 static int current_sym_nchars
;
294 /* Report having output N chars of the current symbol-description. */
296 #define CHARS(N) (current_sym_nchars += (N))
298 /* Break the current symbol-description, generating a continuation,
299 if it has become long. */
301 #ifndef DBX_CONTIN_LENGTH
302 #define DBX_CONTIN_LENGTH 80
305 #if DBX_CONTIN_LENGTH > 0
307 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
309 #define CONTIN do { } while (0)
312 #if defined(ASM_OUTPUT_SECTION_NAME)
313 static void dbxout_function_end
PARAMS ((void));
315 static void dbxout_typedefs
PARAMS ((tree
));
316 static void dbxout_type_index
PARAMS ((tree
));
317 #if DBX_CONTIN_LENGTH > 0
318 static void dbxout_continue
PARAMS ((void));
320 static void dbxout_type_fields
PARAMS ((tree
));
321 static void dbxout_type_method_1
PARAMS ((tree
, const char *));
322 static void dbxout_type_methods
PARAMS ((tree
));
323 static void dbxout_range_type
PARAMS ((tree
));
324 static void dbxout_type
PARAMS ((tree
, int, int));
325 static void print_int_cst_octal
PARAMS ((tree
));
326 static void print_octal
PARAMS ((unsigned HOST_WIDE_INT
, int));
327 static void dbxout_type_name
PARAMS ((tree
));
328 static int dbxout_symbol_location
PARAMS ((tree
, tree
, const char *, rtx
));
329 static void dbxout_symbol_name
PARAMS ((tree
, const char *, int));
330 static void dbxout_prepare_symbol
PARAMS ((tree
));
331 static void dbxout_finish_symbol
PARAMS ((tree
));
332 static void dbxout_block
PARAMS ((tree
, int, tree
));
333 static void dbxout_really_begin_function
PARAMS ((tree
));
335 #if defined(ASM_OUTPUT_SECTION_NAME)
337 dbxout_function_end ()
339 static int scope_labelno
= 0;
340 char lscope_label_name
[100];
341 /* Convert Ltext into the appropriate format for local labels in case
342 the system doesn't insert underscores in front of user generated
344 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
345 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Lscope", scope_labelno
);
348 /* By convention, GCC will mark the end of a function with an N_FUN
349 symbol and an empty string. */
350 fprintf (asmfile
, "%s\"\",%d,0,0,", ASM_STABS_OP
, N_FUN
);
351 assemble_name (asmfile
, lscope_label_name
);
352 fputc ('-', asmfile
);
353 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
354 fprintf (asmfile
, "\n");
356 #endif /* ! NO_DBX_FUNCTION_END */
358 /* At the beginning of compilation, start writing the symbol table.
359 Initialize `typevec' and output the standard data types of C. */
362 dbxout_init (asm_file
, input_file_name
, syms
)
364 const char *input_file_name
;
367 char ltext_label_name
[100];
372 typevec
= (struct typeinfo
*) xcalloc (typevec_len
, sizeof typevec
[0]);
374 /* Convert Ltext into the appropriate format for local labels in case
375 the system doesn't insert underscores in front of user generated
377 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
379 /* Put the current working directory in an N_SO symbol. */
380 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
381 but GDB always does. */
382 if (use_gnu_debug_info_extensions
)
385 if (!cwd
&& (cwd
= getpwd ()) && (!*cwd
|| cwd
[strlen (cwd
) - 1] != '/'))
387 char *wdslash
= xmalloc (strlen (cwd
) + sizeof (FILE_NAME_JOINER
));
388 sprintf (wdslash
, "%s%s", cwd
, FILE_NAME_JOINER
);
393 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
394 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile
, cwd
);
395 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
396 fprintf (asmfile
, "%s", ASM_STABS_OP
);
397 output_quoted_string (asmfile
, cwd
);
398 fprintf (asmfile
, ",%d,0,0,%s\n", N_SO
, <ext_label_name
[1]);
399 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
403 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
404 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
405 would give us an N_SOL, and we want an N_SO. */
406 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile
, input_file_name
);
407 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
408 /* We include outputting `Ltext:' here,
409 because that gives you a way to override it. */
410 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
411 fprintf (asmfile
, "%s", ASM_STABS_OP
);
412 output_quoted_string (asmfile
, input_file_name
);
413 fprintf (asmfile
, ",%d,0,0,%s\n",
414 N_SO
, <ext_label_name
[1]);
416 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Ltext", 0);
417 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
419 /* Possibly output something to inform GDB that this compilation was by
420 GCC. It's easier for GDB to parse it when after the N_SO's. This
421 is used in Solaris 2. */
422 #ifdef ASM_IDENTIFY_GCC_AFTER_SOURCE
423 ASM_IDENTIFY_GCC_AFTER_SOURCE (asmfile
);
426 lastfile
= input_file_name
;
428 next_type_number
= 1;
431 current_file
= (struct dbx_file
*) xmalloc (sizeof *current_file
);
432 current_file
->next
= NULL
;
433 current_file
->file_number
= 0;
434 current_file
->next_type_number
= 1;
435 next_file_number
= 1;
438 /* Make sure that types `int' and `char' have numbers 1 and 2.
439 Definitions of other integer types will refer to those numbers.
440 (Actually it should no longer matter what their numbers are.
441 Also, if any types with tags have been defined, dbxout_symbol
442 will output them first, so the numbers won't be 1 and 2. That
443 happens in C++. So it's a good thing it should no longer matter). */
445 #ifdef DBX_OUTPUT_STANDARD_TYPES
446 DBX_OUTPUT_STANDARD_TYPES (syms
);
448 dbxout_symbol (TYPE_NAME (integer_type_node
), 0);
449 dbxout_symbol (TYPE_NAME (char_type_node
), 0);
452 /* Get all permanent types that have typedef names,
453 and output them all, except for those already output. */
455 dbxout_typedefs (syms
);
458 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
459 in the reverse order from that which is found in SYMS. */
462 dbxout_typedefs (syms
)
467 dbxout_typedefs (TREE_CHAIN (syms
));
468 if (TREE_CODE (syms
) == TYPE_DECL
)
470 tree type
= TREE_TYPE (syms
);
472 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
473 && COMPLETE_TYPE_P (type
)
474 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
475 dbxout_symbol (TYPE_NAME (type
), 0);
480 /* Change to reading from a new source file. Generate a N_BINCL stab. */
483 dbxout_start_new_source_file (filename
)
484 const char *filename ATTRIBUTE_UNUSED
;
487 struct dbx_file
*n
= (struct dbx_file
*) xmalloc (sizeof *n
);
489 n
->next
= current_file
;
490 n
->file_number
= next_file_number
++;
491 n
->next_type_number
= 1;
493 fprintf (asmfile
, "%s", ASM_STABS_OP
);
494 output_quoted_string (asmfile
, filename
);
495 fprintf (asmfile
, ",%d,0,0,0\n", N_BINCL
);
499 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
502 dbxout_resume_previous_source_file ()
505 struct dbx_file
*next
;
507 fprintf (asmfile
, "%s%d,0,0,0\n", ASM_STABN_OP
, N_EINCL
);
508 next
= current_file
->next
;
514 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
517 dbxout_source_file (file
, filename
)
519 const char *filename
;
521 char ltext_label_name
[100];
523 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
525 #ifdef DBX_OUTPUT_SOURCE_FILENAME
526 DBX_OUTPUT_SOURCE_FILENAME (file
, filename
);
528 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext",
529 source_label_number
);
530 fprintf (file
, "%s", ASM_STABS_OP
);
531 output_quoted_string (file
, filename
);
532 fprintf (file
, ",%d,0,0,%s\n", N_SOL
, <ext_label_name
[1]);
533 if (current_function_decl
!= NULL_TREE
534 && DECL_SECTION_NAME (current_function_decl
) != NULL_TREE
)
535 ; /* Don't change section amid function. */
538 ASM_OUTPUT_INTERNAL_LABEL (file
, "Ltext", source_label_number
);
539 source_label_number
++;
545 /* Output a line number symbol entry into output stream FILE,
546 for source file FILENAME and line number LINENO. */
549 dbxout_source_line (file
, filename
, lineno
)
551 const char *filename
;
554 dbxout_source_file (file
, filename
);
556 #ifdef ASM_OUTPUT_SOURCE_LINE
557 ASM_OUTPUT_SOURCE_LINE (file
, lineno
);
559 fprintf (file
, "%s%d,0,%d\n", ASM_STABD_OP
, N_SLINE
, lineno
);
563 /* At the end of compilation, finish writing the symbol table.
564 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
568 dbxout_finish (file
, filename
)
569 FILE *file ATTRIBUTE_UNUSED
;
570 const char *filename ATTRIBUTE_UNUSED
;
572 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
573 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file
, filename
);
574 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
577 /* Output the index of a type. */
580 dbxout_type_index (type
)
583 #ifndef DBX_USE_BINCL
584 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
587 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
588 fprintf (asmfile
, "(%d,%d)", t
->file_number
, t
->type_number
);
593 #if DBX_CONTIN_LENGTH > 0
594 /* Continue a symbol-description that gets too big.
595 End one symbol table entry with a double-backslash
596 and start a new one, eventually producing something like
597 .stabs "start......\\",code,0,value
598 .stabs "...rest",code,0,value */
603 #ifdef DBX_CONTIN_CHAR
604 fprintf (asmfile
, "%c", DBX_CONTIN_CHAR
);
606 fprintf (asmfile
, "\\\\");
608 dbxout_finish_symbol (NULL_TREE
);
609 fprintf (asmfile
, "%s\"", ASM_STABS_OP
);
610 current_sym_nchars
= 0;
612 #endif /* DBX_CONTIN_LENGTH > 0 */
614 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
615 This must be a separate function because anonymous unions require
619 dbxout_type_fields (type
)
624 /* Output the name, type, position (in bits), size (in bits) of each
625 field that we can support. */
626 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
628 /* Omit here local type decls until we know how to support them. */
629 if (TREE_CODE (tem
) == TYPE_DECL
630 /* Omit fields whose position or size are variable or too large to
632 || (TREE_CODE (tem
) == FIELD_DECL
633 && (! host_integerp (bit_position (tem
), 0)
635 || ! host_integerp (DECL_SIZE (tem
), 1)))
636 /* Omit here the nameless fields that are used to skip bits. */
637 || DECL_IGNORED_P (tem
))
640 else if (TREE_CODE (tem
) != CONST_DECL
)
642 /* Continue the line if necessary,
643 but not before the first field. */
644 if (tem
!= TYPE_FIELDS (type
))
647 if (use_gnu_debug_info_extensions
648 && flag_minimal_debug
649 && TREE_CODE (tem
) == FIELD_DECL
650 && DECL_VIRTUAL_P (tem
)
651 && DECL_ASSEMBLER_NAME (tem
))
653 have_used_extensions
= 1;
654 CHARS (3 + IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (tem
)));
655 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
)), asmfile
);
656 dbxout_type (DECL_FCONTEXT (tem
), 0, 0);
657 fprintf (asmfile
, ":");
658 dbxout_type (TREE_TYPE (tem
), 0, 0);
659 fputc (',', asmfile
);
660 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
661 int_bit_position (tem
));
662 fputc (';', asmfile
);
668 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem
)));
669 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem
)));
673 fprintf (asmfile
, ":");
677 if (use_gnu_debug_info_extensions
678 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
679 || TREE_CODE (tem
) != FIELD_DECL
))
681 have_used_extensions
= 1;
683 putc ((TREE_PRIVATE (tem
) ? '0'
684 : TREE_PROTECTED (tem
) ? '1' : '2'),
689 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
690 && DECL_BIT_FIELD_TYPE (tem
))
691 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0, 0);
693 if (TREE_CODE (tem
) == VAR_DECL
)
695 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
698 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
));
699 have_used_extensions
= 1;
700 fprintf (asmfile
, ":%s;", name
);
701 CHARS (strlen (name
));
704 /* If TEM is non-static, GDB won't understand it. */
705 fprintf (asmfile
, ",0,0;");
709 fputc (',', asmfile
);
710 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
711 int_bit_position (tem
));
712 fputc (',', asmfile
);
713 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
714 tree_low_cst (DECL_SIZE (tem
), 1));
715 fputc (';', asmfile
);
722 /* Subroutine of `dbxout_type_methods'. Output debug info about the
723 method described DECL. DEBUG_NAME is an encoding of the method's
724 type signature. ??? We may be able to do without DEBUG_NAME altogether
728 dbxout_type_method_1 (decl
, debug_name
)
730 const char *debug_name
;
734 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
736 else /* it's a METHOD_TYPE. */
738 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
739 /* A for normal functions.
740 B for `const' member functions.
741 C for `volatile' member functions.
742 D for `const volatile' member functions. */
743 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
745 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
748 if (DECL_VINDEX (decl
))
754 fprintf (asmfile
, ":%s;%c%c%c", debug_name
,
755 TREE_PRIVATE (decl
) ? '0'
756 : TREE_PROTECTED (decl
) ? '1' : '2', c1
, c2
);
757 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
)) + 6
758 - (debug_name
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
760 if (DECL_VINDEX (decl
) && host_integerp (DECL_VINDEX (decl
), 0))
762 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
763 tree_low_cst (DECL_VINDEX (decl
), 0));
764 fputc (';', asmfile
);
765 dbxout_type (DECL_CONTEXT (decl
), 0, 0);
766 fprintf (asmfile
, ";");
771 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
775 dbxout_type_methods (type
)
778 /* C++: put out the method names and their parameter lists */
779 tree methods
= TYPE_METHODS (type
);
781 register tree fndecl
;
783 char formatted_type_identifier_length
[16];
784 register int type_identifier_length
;
786 if (methods
== NULL_TREE
)
789 type_encoding
= DECL_NAME (TYPE_NAME (type
));
792 /* C++: Template classes break some assumptions made by this code about
793 the class names, constructor names, and encodings for assembler
794 label names. For now, disable output of dbx info for them. */
796 const char *ptr
= IDENTIFIER_POINTER (type_encoding
);
797 /* This should use index. (mrs) */
798 while (*ptr
&& *ptr
!= '<') ptr
++;
809 type_identifier_length
= IDENTIFIER_LENGTH (type_encoding
);
811 sprintf(formatted_type_identifier_length
, "%d", type_identifier_length
);
813 if (TREE_CODE (methods
) != TREE_VEC
)
815 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
816 fndecl
= TREE_VEC_ELT (methods
, 0);
818 fndecl
= TREE_VEC_ELT (methods
, 1);
822 tree name
= DECL_NAME (fndecl
);
825 /* Group together all the methods for the same operation.
826 These differ in the types of the arguments. */
827 for (last
= NULL_TREE
;
828 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
829 fndecl
= TREE_CHAIN (fndecl
))
830 /* Output the name of the field (after overloading), as
831 well as the name of the field before overloading, along
832 with its parameter list */
834 /* This is the "mangled" name of the method.
835 It encodes the argument types. */
836 const char *debug_name
=
837 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
));
838 int show_arg_types
= 0;
844 if (DECL_IGNORED_P (fndecl
))
847 if (flag_minimal_debug
)
851 /* We can't optimize a method which uses an anonymous
852 class, because the debugger will not be able to
853 associate the arbitrary class name with the actual
855 #ifndef NO_DOLLAR_IN_LABEL
860 if (strchr (debug_name
, marker
))
862 /* Detect ordinary methods because their mangled names
863 start with the operation name. */
864 else if (!strncmp (IDENTIFIER_POINTER (name
), debug_name
,
865 IDENTIFIER_LENGTH (name
)))
867 debug_name
+= IDENTIFIER_LENGTH (name
);
868 if (debug_name
[0] == '_' && debug_name
[1] == '_')
870 const char *method_name
= debug_name
+ 2;
871 const char *length_ptr
=
872 formatted_type_identifier_length
;
873 /* Get past const and volatile qualifiers. */
874 while (*method_name
== 'C' || *method_name
== 'V')
876 /* Skip digits for length of type_encoding. */
877 while (*method_name
== *length_ptr
&& *length_ptr
)
878 length_ptr
++, method_name
++;
879 if (! strncmp (method_name
,
880 IDENTIFIER_POINTER (type_encoding
),
881 type_identifier_length
))
882 method_name
+= type_identifier_length
;
883 debug_name
= method_name
;
886 /* Detect constructors by their style of name mangling. */
887 else if (debug_name
[0] == '_' && debug_name
[1] == '_')
889 const char *ctor_name
= debug_name
+ 2;
890 const char *length_ptr
= formatted_type_identifier_length
;
891 while (*ctor_name
== 'C' || *ctor_name
== 'V')
893 /* Skip digits for length of type_encoding. */
894 while (*ctor_name
== *length_ptr
&& *length_ptr
)
895 length_ptr
++, ctor_name
++;
896 if (!strncmp (IDENTIFIER_POINTER (type_encoding
), ctor_name
,
897 type_identifier_length
))
898 debug_name
= ctor_name
+ type_identifier_length
;
900 /* The other alternative is a destructor. */
904 /* Output the operation name just once, for the first method
908 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (name
));
909 CHARS (IDENTIFIER_LENGTH (name
) + 2);
914 dbxout_type (TREE_TYPE (fndecl
), 0, show_arg_types
);
916 dbxout_type_method_1 (fndecl
, debug_name
);
926 /* Emit a "range" type specification, which has the form:
927 "r<index type>;<lower bound>;<upper bound>;".
928 TYPE is an INTEGER_TYPE. */
931 dbxout_range_type (type
)
934 fprintf (asmfile
, "r");
935 if (TREE_TYPE (type
))
936 dbxout_type (TREE_TYPE (type
), 0, 0);
937 else if (TREE_CODE (type
) != INTEGER_TYPE
)
938 dbxout_type (type
, 0, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
941 /* Traditionally, we made sure 'int' was type 1, and builtin types
942 were defined to be sub-ranges of int. Unfortunately, this
943 does not allow us to distinguish true sub-ranges from integer
944 types. So, instead we define integer (non-sub-range) types as
945 sub-ranges of themselves. This matters for Chill. If this isn't
946 a subrange type, then we want to define it in terms of itself.
947 However, in C, this may be an anonymous integer type, and we don't
948 want to emit debug info referring to it. Just calling
949 dbxout_type_index won't work anyways, because the type hasn't been
950 defined yet. We make this work for both cases by checked to see
951 whether this is a defined type, referring to it if it is, and using
953 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
954 dbxout_type_index (type
);
956 dbxout_type_index (integer_type_node
);
959 if (TYPE_MIN_VALUE (type
) != 0
960 && host_integerp (TYPE_MIN_VALUE (type
), 0))
962 fputc (';', asmfile
);
963 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
964 tree_low_cst (TYPE_MIN_VALUE (type
), 0));
967 fprintf (asmfile
, ";0");
969 if (TYPE_MAX_VALUE (type
) != 0
970 && host_integerp (TYPE_MAX_VALUE (type
), 0))
972 fputc (';', asmfile
);
973 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
974 tree_low_cst (TYPE_MAX_VALUE (type
), 0));
975 fputc (';', asmfile
);
978 fprintf (asmfile
, ";-1;");
981 /* Output a reference to a type. If the type has not yet been
982 described in the dbx output, output its definition now.
983 For a type already defined, just refer to its definition
984 using the type number.
986 If FULL is nonzero, and the type has been described only with
987 a forward-reference, output the definition now.
988 If FULL is zero in this case, just refer to the forward-reference
989 using the number previously allocated.
991 If SHOW_ARG_TYPES is nonzero, we output a description of the argument
992 types for a METHOD_TYPE. */
995 dbxout_type (type
, full
, show_arg_types
)
1001 static int anonymous_type_number
= 0;
1003 if (TREE_CODE (type
) == VECTOR_TYPE
)
1004 type
= TYPE_DEBUG_REPRESENTATION_TYPE (type
);
1006 /* If there was an input error and we don't really have a type,
1007 avoid crashing and write something that is at least valid
1008 by assuming `int'. */
1009 if (type
== error_mark_node
)
1010 type
= integer_type_node
;
1013 /* Try to find the "main variant" with the same name but not const
1014 or volatile. (Since stabs does not distinguish const and volatile,
1015 there is no need to make them separate types. But types with
1016 different names are usefully distinguished.) */
1018 for (tem
= TYPE_MAIN_VARIANT (type
); tem
; tem
= TYPE_NEXT_VARIANT (tem
))
1019 if (!TYPE_READONLY (tem
) && !TYPE_VOLATILE (tem
)
1020 && TYPE_NAME (tem
) == TYPE_NAME (type
))
1025 if (TYPE_NAME (type
)
1026 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1027 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1031 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1033 /* Type has no dbx number assigned. Assign next available number. */
1034 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1036 /* Make sure type vector is long enough to record about this type. */
1038 if (next_type_number
== typevec_len
)
1041 = (struct typeinfo
*) xrealloc (typevec
,
1042 typevec_len
* 2 * sizeof typevec
[0]);
1043 memset ((char *) (typevec
+ typevec_len
), 0,
1044 typevec_len
* sizeof typevec
[0]);
1048 #ifdef DBX_USE_BINCL
1049 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1050 = current_file
->file_number
;
1051 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1052 = current_file
->next_type_number
++;
1056 /* Output the number of this type, to refer to it. */
1057 dbxout_type_index (type
);
1059 #ifdef DBX_TYPE_DEFINED
1060 if (DBX_TYPE_DEFINED (type
))
1064 /* If this type's definition has been output or is now being output,
1067 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1072 /* If we have already had a cross reference,
1073 and either that's all we want or that's the best we could do,
1074 don't repeat the cross reference.
1075 Sun dbx crashes if we do. */
1076 if (! full
|| !COMPLETE_TYPE_P (type
)
1077 /* No way in DBX fmt to describe a variable size. */
1078 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1086 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1087 leave the type-number completely undefined rather than output
1088 a cross-reference. If we have already used GNU debug info extensions,
1089 then it is OK to output a cross reference. This is necessary to get
1090 proper C++ debug output. */
1091 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1092 || TREE_CODE (type
) == QUAL_UNION_TYPE
1093 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1094 && ! use_gnu_debug_info_extensions
)
1095 /* We must use the same test here as we use twice below when deciding
1096 whether to emit a cross-reference. */
1097 if ((TYPE_NAME (type
) != 0
1098 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1099 && DECL_IGNORED_P (TYPE_NAME (type
)))
1101 || !COMPLETE_TYPE_P (type
)
1102 /* No way in DBX fmt to describe a variable size. */
1103 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1105 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1110 /* Output a definition now. */
1112 fprintf (asmfile
, "=");
1115 /* Mark it as defined, so that if it is self-referent
1116 we will not get into an infinite recursion of definitions. */
1118 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1120 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1121 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1123 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0, 0);
1127 switch (TREE_CODE (type
))
1131 /* For a void type, just define it as itself; ie, "5=5".
1132 This makes us consider it defined
1133 without saying what it is. The debugger will make it
1134 a void type when the reference is seen, and nothing will
1135 ever override that default. */
1136 dbxout_type_index (type
);
1140 if (type
== char_type_node
&& ! TREE_UNSIGNED (type
))
1142 /* Output the type `char' as a subrange of itself!
1143 I don't understand this definition, just copied it
1144 from the output of pcc.
1145 This used to use `r2' explicitly and we used to
1146 take care to make sure that `char' was type number 2. */
1147 fprintf (asmfile
, "r");
1148 dbxout_type_index (type
);
1149 fprintf (asmfile
, ";0;127;");
1152 /* If this is a subtype of another integer type, always prefer to
1153 write it as a subtype. */
1154 else if (TREE_TYPE (type
) != 0
1155 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_CST
)
1156 dbxout_range_type (type
);
1160 /* If the size is non-standard, say what it is if we can use
1163 if (use_gnu_debug_info_extensions
1164 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1165 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1167 /* If we can use GDB extensions and the size is wider than a
1168 long (the size used by GDB to read them) or we may have
1169 trouble writing the bounds the usual way, write them in
1170 octal. Note the test is for the *target's* size of "long",
1171 not that of the host. The host test is just to make sure we
1172 can write it out in case the host wide int is narrower than the
1175 /* For unsigned types, we use octal if they are the same size or
1176 larger. This is because we print the bounds as signed decimal,
1177 and hence they can't span same size unsigned types. */
1179 if (use_gnu_debug_info_extensions
1180 && TYPE_MIN_VALUE (type
) != 0
1181 && TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
1182 && TYPE_MAX_VALUE (type
) != 0
1183 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
1184 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
1185 || (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
)
1186 && TREE_UNSIGNED (type
))
1187 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
1188 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
1189 && TREE_UNSIGNED (type
))))
1191 fprintf (asmfile
, "r");
1192 dbxout_type_index (type
);
1193 fprintf (asmfile
, ";");
1194 print_int_cst_octal (TYPE_MIN_VALUE (type
));
1195 fprintf (asmfile
, ";");
1196 print_int_cst_octal (TYPE_MAX_VALUE (type
));
1197 fprintf (asmfile
, ";");
1201 /* Output other integer types as subranges of `int'. */
1202 dbxout_range_type (type
);
1209 /* This used to say `r1' and we used to take care
1210 to make sure that `int' was type number 1. */
1211 fprintf (asmfile
, "r");
1212 dbxout_type_index (integer_type_node
);
1213 fputc (';', asmfile
);
1214 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1215 fputs (";0;", asmfile
);
1220 if (use_gnu_debug_info_extensions
)
1222 fputs ("@s", asmfile
);
1223 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1224 BITS_PER_UNIT
* int_size_in_bytes (type
));
1225 fputs (";-20;", asmfile
);
1229 /* Output the type `char' as a subrange of itself.
1230 That is what pcc seems to do. */
1231 fprintf (asmfile
, "r");
1232 dbxout_type_index (char_type_node
);
1233 fprintf (asmfile
, ";0;%d;", TREE_UNSIGNED (type
) ? 255 : 127);
1239 if (use_gnu_debug_info_extensions
)
1241 fputs ("@s", asmfile
);
1242 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1243 BITS_PER_UNIT
* int_size_in_bytes (type
));
1244 fputs (";-16;", asmfile
);
1246 else /* Define as enumeral type (False, True) */
1247 fprintf (asmfile
, "eFalse:0,True:1,;");
1252 putc ('d', asmfile
);
1254 dbxout_type (TREE_TYPE (type
), 0, 0);
1258 /* Differs from the REAL_TYPE by its new data type number */
1260 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1262 fprintf (asmfile
, "r");
1263 dbxout_type_index (type
);
1264 fputc (';', asmfile
);
1265 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1266 2 * int_size_in_bytes (TREE_TYPE (type
)));
1267 fputs (";0;", asmfile
);
1268 CHARS (12); /* The number is probably incorrect here. */
1272 /* Output a complex integer type as a structure,
1273 pending some other way to do it. */
1274 fputc ('s', asmfile
);
1275 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1277 fprintf (asmfile
, "real:");
1279 dbxout_type (TREE_TYPE (type
), 0, 0);
1280 fprintf (asmfile
, ",%d,%d;",
1281 0, TYPE_PRECISION (TREE_TYPE (type
)));
1283 fprintf (asmfile
, "imag:");
1285 dbxout_type (TREE_TYPE (type
), 0, 0);
1286 fprintf (asmfile
, ",%d,%d;;",
1287 TYPE_PRECISION (TREE_TYPE (type
)),
1288 TYPE_PRECISION (TREE_TYPE (type
)));
1294 if (use_gnu_debug_info_extensions
)
1296 have_used_extensions
= 1;
1297 fputs ("@s", asmfile
);
1298 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1299 BITS_PER_UNIT
* int_size_in_bytes (type
));
1300 fputc (';', asmfile
);
1301 /* Check if a bitstring type, which in Chill is
1302 different from a [power]set. */
1303 if (TYPE_STRING_FLAG (type
))
1304 fprintf (asmfile
, "@S;");
1306 putc ('S', asmfile
);
1308 dbxout_type (TYPE_DOMAIN (type
), 0, 0);
1312 /* Make arrays of packed bits look like bitstrings for chill. */
1313 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
1315 have_used_extensions
= 1;
1316 fputs ("@s", asmfile
);
1317 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1318 BITS_PER_UNIT
* int_size_in_bytes (type
));
1319 fputc (';', asmfile
);
1320 fprintf (asmfile
, "@S;");
1321 putc ('S', asmfile
);
1323 dbxout_type (TYPE_DOMAIN (type
), 0, 0);
1326 /* Output "a" followed by a range type definition
1327 for the index type of the array
1328 followed by a reference to the target-type.
1329 ar1;0;N;M for a C array of type M and size N+1. */
1330 /* Check if a character string type, which in Chill is
1331 different from an array of characters. */
1332 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
1334 have_used_extensions
= 1;
1335 fprintf (asmfile
, "@S;");
1337 tem
= TYPE_DOMAIN (type
);
1340 fprintf (asmfile
, "ar");
1341 dbxout_type_index (integer_type_node
);
1342 fprintf (asmfile
, ";0;-1;");
1346 fprintf (asmfile
, "a");
1347 dbxout_range_type (tem
);
1350 dbxout_type (TREE_TYPE (type
), 0, 0);
1355 case QUAL_UNION_TYPE
:
1357 int i
, n_baseclasses
= 0;
1359 if (TYPE_BINFO (type
) != 0
1360 && TREE_CODE (TYPE_BINFO (type
)) == TREE_VEC
1361 && TYPE_BINFO_BASETYPES (type
) != 0)
1362 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
1364 /* Output a structure type. We must use the same test here as we
1365 use in the DBX_NO_XREFS case above. */
1366 if ((TYPE_NAME (type
) != 0
1367 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1368 && DECL_IGNORED_P (TYPE_NAME (type
)))
1370 || !COMPLETE_TYPE_P (type
)
1371 /* No way in DBX fmt to describe a variable size. */
1372 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1374 /* If the type is just a cross reference, output one
1375 and mark the type as partially described.
1376 If it later becomes defined, we will output
1377 its real definition.
1378 If the type has a name, don't nest its definition within
1379 another type's definition; instead, output an xref
1380 and let the definition come when the name is defined. */
1381 fputs ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu", asmfile
);
1383 #if 0 /* This assertion is legitimately false in C++. */
1384 /* We shouldn't be outputting a reference to a type before its
1385 definition unless the type has a tag name.
1386 A typedef name without a tag name should be impossible. */
1387 if (TREE_CODE (TYPE_NAME (type
)) != IDENTIFIER_NODE
)
1390 if (TYPE_NAME (type
) != 0)
1391 dbxout_type_name (type
);
1393 fprintf (asmfile
, "$$%d", anonymous_type_number
++);
1394 fprintf (asmfile
, ":");
1395 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1399 /* Identify record or union, and print its size. */
1400 fputc (((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u'), asmfile
);
1401 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1402 int_size_in_bytes (type
));
1404 if (use_gnu_debug_info_extensions
)
1408 have_used_extensions
= 1;
1409 fprintf (asmfile
, "!%d,", n_baseclasses
);
1413 for (i
= 0; i
< n_baseclasses
; i
++)
1415 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)), i
);
1417 if (use_gnu_debug_info_extensions
)
1419 have_used_extensions
= 1;
1420 putc (TREE_VIA_VIRTUAL (child
) ? '1' : '0', asmfile
);
1421 putc (TREE_VIA_PUBLIC (child
) ? '2' : '0', asmfile
);
1422 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1423 (tree_low_cst (BINFO_OFFSET (child
), 0)
1425 fputc (',', asmfile
);
1427 dbxout_type (BINFO_TYPE (child
), 0, 0);
1428 putc (';', asmfile
);
1432 /* Print out the base class information with fields
1433 which have the same names at the types they hold. */
1434 dbxout_type_name (BINFO_TYPE (child
));
1435 putc (':', asmfile
);
1436 dbxout_type (BINFO_TYPE (child
), full
, 0);
1437 fputc (',', asmfile
);
1438 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1439 tree_low_cst (BINFO_OFFSET (child
), 0)
1441 fputc (',', asmfile
);
1442 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1443 (tree_low_cst (DECL_SIZE (TYPE_NAME
1444 (BINFO_TYPE (child
))), 0)
1446 fputc (';', asmfile
);
1454 /* Write out the field declarations. */
1455 dbxout_type_fields (type
);
1456 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1458 have_used_extensions
= 1;
1459 dbxout_type_methods (type
);
1462 putc (';', asmfile
);
1464 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1465 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1466 && TYPE_VFIELD (type
))
1468 have_used_extensions
= 1;
1470 /* Tell GDB+ that it may keep reading. */
1471 putc ('~', asmfile
);
1473 /* We need to write out info about what field this class
1474 uses as its "main" vtable pointer field, because if this
1475 field is inherited from a base class, GDB cannot necessarily
1476 figure out which field it's using in time. */
1477 if (TYPE_VFIELD (type
))
1479 putc ('%', asmfile
);
1480 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0, 0);
1482 putc (';', asmfile
);
1488 /* We must use the same test here as we use in the DBX_NO_XREFS case
1489 above. We simplify it a bit since an enum will never have a variable
1491 if ((TYPE_NAME (type
) != 0
1492 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1493 && DECL_IGNORED_P (TYPE_NAME (type
)))
1495 || !COMPLETE_TYPE_P (type
))
1497 fprintf (asmfile
, "xe");
1499 dbxout_type_name (type
);
1500 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1501 fprintf (asmfile
, ":");
1504 #ifdef DBX_OUTPUT_ENUM
1505 DBX_OUTPUT_ENUM (asmfile
, type
);
1507 if (use_gnu_debug_info_extensions
1508 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1509 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1510 putc ('e', asmfile
);
1512 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1514 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)));
1515 if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == 0)
1516 fprintf (asmfile
, HOST_WIDE_INT_PRINT_UNSIGNED
,
1517 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1518 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == -1
1519 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (TREE_VALUE (tem
)) < 0)
1520 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1521 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1523 print_int_cst_octal (TREE_VALUE (tem
));
1524 fprintf (asmfile
, ",");
1525 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)));
1526 if (TREE_CHAIN (tem
) != 0)
1531 putc (';', asmfile
);
1537 putc ('*', asmfile
);
1539 dbxout_type (TREE_TYPE (type
), 0, 0);
1543 if (use_gnu_debug_info_extensions
)
1545 have_used_extensions
= 1;
1546 putc ('#', asmfile
);
1548 if (flag_minimal_debug
&& !show_arg_types
)
1550 /* Normally, just output the return type.
1551 The argument types are encoded in the method name. */
1552 putc ('#', asmfile
);
1554 dbxout_type (TREE_TYPE (type
), 0, 0);
1555 putc (';', asmfile
);
1560 /* When outputting destructors, we need to write
1561 the argument types out longhand. */
1562 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0, 0);
1563 putc (',', asmfile
);
1565 dbxout_type (TREE_TYPE (type
), 0, 0);
1566 dbxout_args (TYPE_ARG_TYPES (type
));
1567 putc (';', asmfile
);
1573 /* Treat it as a function type. */
1574 dbxout_type (TREE_TYPE (type
), 0, 0);
1579 if (use_gnu_debug_info_extensions
)
1581 have_used_extensions
= 1;
1582 putc ('@', asmfile
);
1584 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0, 0);
1585 putc (',', asmfile
);
1587 dbxout_type (TREE_TYPE (type
), 0, 0);
1591 /* Should print as an int, because it is really
1593 dbxout_type (integer_type_node
, 0, 0);
1597 case REFERENCE_TYPE
:
1598 if (use_gnu_debug_info_extensions
)
1599 have_used_extensions
= 1;
1600 putc (use_gnu_debug_info_extensions
? '&' : '*', asmfile
);
1602 dbxout_type (TREE_TYPE (type
), 0, 0);
1606 putc ('f', asmfile
);
1608 dbxout_type (TREE_TYPE (type
), 0, 0);
1616 /* Print the value of integer constant C, in octal,
1617 handling double precision. */
1620 print_int_cst_octal (c
)
1623 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (c
);
1624 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (c
);
1625 int excess
= (3 - (HOST_BITS_PER_WIDE_INT
% 3));
1626 unsigned int width
= TYPE_PRECISION (TREE_TYPE (c
));
1628 /* GDB wants constants with no extra leading "1" bits, so
1629 we need to remove any sign-extension that might be
1631 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
1633 else if (width
> HOST_BITS_PER_WIDE_INT
)
1634 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
1635 else if (width
== HOST_BITS_PER_WIDE_INT
)
1638 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
1640 fprintf (asmfile
, "0");
1644 print_octal (high
, HOST_BITS_PER_WIDE_INT
/ 3);
1645 print_octal (low
, HOST_BITS_PER_WIDE_INT
/ 3);
1649 unsigned HOST_WIDE_INT beg
= high
>> excess
;
1650 unsigned HOST_WIDE_INT middle
1651 = ((high
& (((HOST_WIDE_INT
) 1 << excess
) - 1)) << (3 - excess
)
1652 | (low
>> (HOST_BITS_PER_WIDE_INT
/ 3 * 3)));
1653 unsigned HOST_WIDE_INT end
1654 = low
& (((unsigned HOST_WIDE_INT
) 1
1655 << (HOST_BITS_PER_WIDE_INT
/ 3 * 3))
1658 fprintf (asmfile
, "%o%01o", (int) beg
, (int) middle
);
1659 print_octal (end
, HOST_BITS_PER_WIDE_INT
/ 3);
1664 print_octal (value
, digits
)
1665 unsigned HOST_WIDE_INT value
;
1670 for (i
= digits
- 1; i
>= 0; i
--)
1671 fprintf (asmfile
, "%01o", (int) ((value
>> (3 * i
)) & 7));
1674 /* Output the name of type TYPE, with no punctuation.
1675 Such names can be set up either by typedef declarations
1676 or by struct, enum and union tags. */
1679 dbxout_type_name (type
)
1683 if (TYPE_NAME (type
) == 0)
1685 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
1687 t
= TYPE_NAME (type
);
1689 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1691 t
= DECL_NAME (TYPE_NAME (type
));
1696 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
1697 CHARS (IDENTIFIER_LENGTH (t
));
1700 /* Output a .stabs for the symbol defined by DECL,
1701 which must be a ..._DECL node in the normal namespace.
1702 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1703 LOCAL is nonzero if the scope is less than the entire file.
1704 Return 1 if a stabs might have been emitted. */
1707 dbxout_symbol (decl
, local
)
1709 int local ATTRIBUTE_UNUSED
;
1711 tree type
= TREE_TYPE (decl
);
1712 tree context
= NULL_TREE
;
1715 /* Cast avoids warning in old compilers. */
1716 current_sym_code
= (STAB_CODE_TYPE
) 0;
1717 current_sym_value
= 0;
1718 current_sym_addr
= 0;
1720 /* Ignore nameless syms, but don't ignore type tags. */
1722 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
1723 || DECL_IGNORED_P (decl
))
1726 dbxout_prepare_symbol (decl
);
1728 /* The output will always start with the symbol name,
1729 so always count that in the length-output-so-far. */
1731 if (DECL_NAME (decl
) != 0)
1732 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
1734 switch (TREE_CODE (decl
))
1737 /* Enum values are defined by defining the enum type. */
1741 if (DECL_RTL (decl
) == 0)
1743 if (DECL_EXTERNAL (decl
))
1745 /* Don't mention a nested function under its parent. */
1746 context
= decl_function_context (decl
);
1747 if (context
== current_function_decl
)
1749 if (GET_CODE (DECL_RTL (decl
)) != MEM
1750 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
1754 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
1755 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1756 TREE_PUBLIC (decl
) ? 'F' : 'f');
1759 current_sym_code
= N_FUN
;
1760 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1762 if (TREE_TYPE (type
))
1763 dbxout_type (TREE_TYPE (type
), 0, 0);
1765 dbxout_type (void_type_node
, 0, 0);
1767 /* For a nested function, when that function is compiled,
1768 mention the containing function name
1769 as well as (since dbx wants it) our own assembler-name. */
1771 fprintf (asmfile
, ",%s,%s",
1772 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1773 IDENTIFIER_POINTER (DECL_NAME (context
)));
1775 dbxout_finish_symbol (decl
);
1780 /* This seems all wrong. Outputting most kinds of types gives no name
1781 at all. A true definition gives no name; a cross-ref for a
1782 structure can give the tag name, but not a type name.
1783 It seems that no typedef name is defined by outputting a type. */
1785 /* If this typedef name was defined by outputting the type,
1786 don't duplicate it. */
1787 if (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
== TYPE_DEFINED
1788 && TYPE_NAME (TREE_TYPE (decl
)) == decl
)
1791 /* Don't output the same typedef twice.
1792 And don't output what language-specific stuff doesn't want output. */
1793 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
1802 if (DECL_NAME (decl
))
1804 /* Nonzero means we must output a tag as well as a typedef. */
1807 /* Handle the case of a C++ structure or union
1808 where the TYPE_NAME is a TYPE_DECL
1809 which gives both a typedef name and a tag. */
1810 /* dbx requires the tag first and the typedef second. */
1811 if ((TREE_CODE (type
) == RECORD_TYPE
1812 || TREE_CODE (type
) == UNION_TYPE
1813 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1814 && TYPE_NAME (type
) == decl
1815 && !(use_gnu_debug_info_extensions
&& have_used_extensions
)
1816 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
1817 /* Distinguish the implicit typedefs of C++
1818 from explicit ones that might be found in C. */
1819 && DECL_ARTIFICIAL (decl
))
1821 tree name
= TYPE_NAME (type
);
1822 if (TREE_CODE (name
) == TYPE_DECL
)
1823 name
= DECL_NAME (name
);
1825 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1826 current_sym_value
= 0;
1827 current_sym_addr
= 0;
1828 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1830 fprintf (asmfile
, "%s\"%s:T", ASM_STABS_OP
,
1831 IDENTIFIER_POINTER (name
));
1832 dbxout_type (type
, 1, 0);
1833 dbxout_finish_symbol (NULL_TREE
);
1836 /* Output typedef name. */
1837 fprintf (asmfile
, "%s\"%s:", ASM_STABS_OP
,
1838 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1840 /* Short cut way to output a tag also. */
1841 if ((TREE_CODE (type
) == RECORD_TYPE
1842 || TREE_CODE (type
) == UNION_TYPE
1843 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1844 && TYPE_NAME (type
) == decl
1845 /* Distinguish the implicit typedefs of C++
1846 from explicit ones that might be found in C. */
1847 && DECL_ARTIFICIAL (decl
))
1849 if (use_gnu_debug_info_extensions
&& have_used_extensions
)
1851 putc ('T', asmfile
);
1852 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
1854 #if 0 /* Now we generate the tag for this case up above. */
1860 putc ('t', asmfile
);
1861 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1863 dbxout_type (type
, 1, 0);
1864 dbxout_finish_symbol (decl
);
1868 /* Don't output a tag if this is an incomplete type (TYPE_SIZE is
1869 zero). This prevents the sun4 Sun OS 4.x dbx from crashing. */
1871 if (tag_needed
&& TYPE_NAME (type
) != 0
1872 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
1873 || (DECL_NAME (TYPE_NAME (type
)) != 0))
1874 && COMPLETE_TYPE_P (type
)
1875 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1877 /* For a TYPE_DECL with no name, but the type has a name,
1879 This is what represents `struct foo' with no typedef. */
1880 /* In C++, the name of a type is the corresponding typedef.
1881 In C, it is an IDENTIFIER_NODE. */
1882 tree name
= TYPE_NAME (type
);
1883 if (TREE_CODE (name
) == TYPE_DECL
)
1884 name
= DECL_NAME (name
);
1886 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1887 current_sym_value
= 0;
1888 current_sym_addr
= 0;
1889 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1891 fprintf (asmfile
, "%s\"%s:T", ASM_STABS_OP
,
1892 IDENTIFIER_POINTER (name
));
1893 dbxout_type (type
, 1, 0);
1894 dbxout_finish_symbol (NULL_TREE
);
1898 /* If an enum type has no name, it cannot be referred to,
1899 but we must output it anyway, since the enumeration constants
1900 can be referred to. */
1901 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
1903 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1904 current_sym_value
= 0;
1905 current_sym_addr
= 0;
1906 current_sym_nchars
= 2;
1908 /* Some debuggers fail when given NULL names, so give this a
1909 harmless name of ` '. */
1910 fprintf (asmfile
, "%s\" :T", ASM_STABS_OP
);
1911 dbxout_type (type
, 1, 0);
1912 dbxout_finish_symbol (NULL_TREE
);
1915 /* Prevent duplicate output of a typedef. */
1916 TREE_ASM_WRITTEN (decl
) = 1;
1921 /* Parm decls go in their own separate chains
1922 and are output by dbxout_reg_parms and dbxout_parms. */
1926 /* Named return value, treat like a VAR_DECL. */
1928 if (DECL_RTL (decl
) == 0)
1930 /* Don't mention a variable that is external.
1931 Let the file that defines it describe it. */
1932 if (DECL_EXTERNAL (decl
))
1935 /* If the variable is really a constant
1936 and not written in memory, inform the debugger. */
1937 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
1938 && DECL_INITIAL (decl
) != 0
1939 && host_integerp (DECL_INITIAL (decl
), 0)
1940 && ! TREE_ASM_WRITTEN (decl
)
1941 && (DECL_CONTEXT (decl
) == NULL_TREE
1942 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
))
1944 if (TREE_PUBLIC (decl
) == 0)
1946 /* The sun4 assembler does not grok this. */
1947 const char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1949 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
1950 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
1952 HOST_WIDE_INT ival
= tree_low_cst (DECL_INITIAL (decl
), 0);
1953 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1954 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile
, name
, ival
);
1956 fprintf (asmfile
, "%s\"%s:c=i", ASM_STABS_OP
, name
);
1958 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, ival
);
1959 fprintf (asmfile
, "\",0x%x,0,0,0\n", N_LSYM
);
1963 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
1965 /* don't know how to do this yet. */
1969 /* else it is something we handle like a normal variable. */
1972 DECL_RTL (decl
) = eliminate_regs (DECL_RTL (decl
), 0, NULL_RTX
);
1973 #ifdef LEAF_REG_REMAP
1974 if (current_function_uses_only_leaf_regs
)
1975 leaf_renumber_regs_insn (DECL_RTL (decl
));
1978 result
= dbxout_symbol_location (decl
, type
, 0, DECL_RTL (decl
));
1987 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1988 Add SUFFIX to its name, if SUFFIX is not 0.
1989 Describe the variable as residing in HOME
1990 (usually HOME is DECL_RTL (DECL), but not always).
1991 Returns 1 if the stab was really emitted. */
1994 dbxout_symbol_location (decl
, type
, suffix
, home
)
2002 /* Don't mention a variable at all
2003 if it was completely optimized into nothingness.
2005 If the decl was from an inline function, then its rtl
2006 is not identically the rtl that was used in this
2007 particular compilation. */
2008 if (GET_CODE (home
) == REG
)
2010 regno
= REGNO (home
);
2011 if (regno
>= FIRST_PSEUDO_REGISTER
)
2014 else if (GET_CODE (home
) == SUBREG
)
2018 while (GET_CODE (value
) == SUBREG
)
2020 offset
+= SUBREG_WORD (value
);
2021 value
= SUBREG_REG (value
);
2023 if (GET_CODE (value
) == REG
)
2025 regno
= REGNO (value
);
2026 if (regno
>= FIRST_PSEUDO_REGISTER
)
2030 alter_subreg (home
);
2033 /* The kind-of-variable letter depends on where
2034 the variable is and on the scope of its name:
2035 G and N_GSYM for static storage and global scope,
2036 S for static storage and file scope,
2037 V for static storage and local scope,
2038 for those two, use N_LCSYM if data is in bss segment,
2039 N_STSYM if in data segment, N_FUN otherwise.
2040 (We used N_FUN originally, then changed to N_STSYM
2041 to please GDB. However, it seems that confused ld.
2042 Now GDB has been fixed to like N_FUN, says Kingdon.)
2043 no letter at all, and N_LSYM, for auto variable,
2044 r and N_RSYM for register variable. */
2046 if (GET_CODE (home
) == MEM
2047 && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2049 if (TREE_PUBLIC (decl
))
2052 current_sym_code
= N_GSYM
;
2056 current_sym_addr
= XEXP (home
, 0);
2058 letter
= decl_function_context (decl
) ? 'V' : 'S';
2060 /* This should be the same condition as in assemble_variable, but
2061 we don't have access to dont_output_data here. So, instead,
2062 we rely on the fact that error_mark_node initializers always
2063 end up in bss for C++ and never end up in bss for C. */
2064 if (DECL_INITIAL (decl
) == 0
2065 || (!strcmp (lang_identify (), "cplusplus")
2066 && DECL_INITIAL (decl
) == error_mark_node
))
2067 current_sym_code
= N_LCSYM
;
2068 else if (DECL_IN_TEXT_SECTION (decl
))
2069 /* This is not quite right, but it's the closest
2070 of all the codes that Unix defines. */
2071 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
2074 /* Ultrix `as' seems to need this. */
2075 #ifdef DBX_STATIC_STAB_DATA_SECTION
2078 current_sym_code
= N_STSYM
;
2082 else if (regno
>= 0)
2085 current_sym_code
= N_RSYM
;
2086 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
2088 else if (GET_CODE (home
) == MEM
2089 && (GET_CODE (XEXP (home
, 0)) == MEM
2090 || (GET_CODE (XEXP (home
, 0)) == REG
2091 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
2092 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
2093 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2094 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
2097 /* If the value is indirect by memory or by a register
2098 that isn't the frame pointer
2099 then it means the object is variable-sized and address through
2100 that register or stack slot. DBX has no way to represent this
2101 so all we can do is output the variable as a pointer.
2102 If it's not a parameter, ignore it.
2103 (VAR_DECLs like this can be made by integrate.c.) */
2105 if (GET_CODE (XEXP (home
, 0)) == REG
)
2108 current_sym_code
= N_RSYM
;
2109 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
2113 current_sym_code
= N_LSYM
;
2114 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2115 We want the value of that CONST_INT. */
2117 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
2120 /* Effectively do build_pointer_type, but don't cache this type,
2121 since it might be temporary whereas the type it points to
2122 might have been saved for inlining. */
2123 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2124 type
= make_node (POINTER_TYPE
);
2125 TREE_TYPE (type
) = TREE_TYPE (decl
);
2127 else if (GET_CODE (home
) == MEM
2128 && GET_CODE (XEXP (home
, 0)) == REG
)
2130 current_sym_code
= N_LSYM
;
2131 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2133 else if (GET_CODE (home
) == MEM
2134 && GET_CODE (XEXP (home
, 0)) == PLUS
2135 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
2137 current_sym_code
= N_LSYM
;
2138 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2139 We want the value of that CONST_INT. */
2140 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2142 else if (GET_CODE (home
) == MEM
2143 && GET_CODE (XEXP (home
, 0)) == CONST
)
2145 /* Handle an obscure case which can arise when optimizing and
2146 when there are few available registers. (This is *always*
2147 the case for i386/i486 targets). The RTL looks like
2148 (MEM (CONST ...)) even though this variable is a local `auto'
2149 or a local `register' variable. In effect, what has happened
2150 is that the reload pass has seen that all assignments and
2151 references for one such a local variable can be replaced by
2152 equivalent assignments and references to some static storage
2153 variable, thereby avoiding the need for a register. In such
2154 cases we're forced to lie to debuggers and tell them that
2155 this variable was itself `static'. */
2156 current_sym_code
= N_LCSYM
;
2158 current_sym_addr
= XEXP (XEXP (home
, 0), 0);
2160 else if (GET_CODE (home
) == CONCAT
)
2162 tree subtype
= TREE_TYPE (type
);
2164 /* If the variable's storage is in two parts,
2165 output each as a separate stab with a modified name. */
2166 if (WORDS_BIG_ENDIAN
)
2167 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
2169 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
2171 /* Cast avoids warning in old compilers. */
2172 current_sym_code
= (STAB_CODE_TYPE
) 0;
2173 current_sym_value
= 0;
2174 current_sym_addr
= 0;
2175 dbxout_prepare_symbol (decl
);
2177 if (WORDS_BIG_ENDIAN
)
2178 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
2180 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
2184 /* Address might be a MEM, when DECL is a variable-sized object.
2185 Or it might be const0_rtx, meaning previous passes
2186 want us to ignore this variable. */
2189 /* Ok, start a symtab entry and output the variable name. */
2192 #ifdef DBX_STATIC_BLOCK_START
2193 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
2196 dbxout_symbol_name (decl
, suffix
, letter
);
2197 dbxout_type (type
, 0, 0);
2198 dbxout_finish_symbol (decl
);
2200 #ifdef DBX_STATIC_BLOCK_END
2201 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
2206 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2207 Then output LETTER to indicate the kind of location the symbol has. */
2210 dbxout_symbol_name (decl
, suffix
, letter
)
2217 if (DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
)))
2218 /* One slight hitch: if this is a VAR_DECL which is a static
2219 class member, we must put out the mangled name instead of the
2220 DECL_NAME. Note also that static member (variable) names DO NOT begin
2221 with underscores in .stabs directives. */
2222 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2224 /* ...but if we're function-local, we don't want to include the junk
2225 added by ASM_FORMAT_PRIVATE_NAME. */
2226 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
2230 fprintf (asmfile
, "%s\"%s%s:", ASM_STABS_OP
, name
,
2231 (suffix
? suffix
: ""));
2233 if (letter
) putc (letter
, asmfile
);
2237 dbxout_prepare_symbol (decl
)
2238 tree decl ATTRIBUTE_UNUSED
;
2241 const char *filename
= DECL_SOURCE_FILE (decl
);
2243 dbxout_source_file (asmfile
, filename
);
2248 dbxout_finish_symbol (sym
)
2251 #ifdef DBX_FINISH_SYMBOL
2252 DBX_FINISH_SYMBOL (sym
);
2255 if (use_gnu_debug_info_extensions
&& sym
!= 0)
2256 line
= DECL_SOURCE_LINE (sym
);
2258 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
2259 if (current_sym_addr
)
2260 output_addr_const (asmfile
, current_sym_addr
);
2262 fprintf (asmfile
, "%d", current_sym_value
);
2263 putc ('\n', asmfile
);
2267 /* Output definitions of all the decls in a chain. Return non-zero if
2268 anything was output */
2277 result
+= dbxout_symbol (syms
, 1);
2278 syms
= TREE_CHAIN (syms
);
2283 /* The following two functions output definitions of function parameters.
2284 Each parameter gets a definition locating it in the parameter list.
2285 Each parameter that is a register variable gets a second definition
2286 locating it in the register.
2288 Printing or argument lists in gdb uses the definitions that
2289 locate in the parameter list. But reference to the variable in
2290 expressions uses preferentially the definition as a register. */
2292 /* Output definitions, referring to storage in the parmlist,
2293 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2296 dbxout_parms (parms
)
2299 for (; parms
; parms
= TREE_CHAIN (parms
))
2300 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
2302 dbxout_prepare_symbol (parms
);
2304 /* Perform any necessary register eliminations on the parameter's rtl,
2305 so that the debugging output will be accurate. */
2306 DECL_INCOMING_RTL (parms
)
2307 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
2308 DECL_RTL (parms
) = eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
);
2309 #ifdef LEAF_REG_REMAP
2310 if (current_function_uses_only_leaf_regs
)
2312 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
2313 leaf_renumber_regs_insn (DECL_RTL (parms
));
2317 if (PARM_PASSED_IN_MEMORY (parms
))
2319 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
2321 /* ??? Here we assume that the parm address is indexed
2322 off the frame pointer or arg pointer.
2323 If that is not true, we produce meaningless results,
2324 but do not crash. */
2325 if (GET_CODE (addr
) == PLUS
2326 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
2327 current_sym_value
= INTVAL (XEXP (addr
, 1));
2329 current_sym_value
= 0;
2331 current_sym_code
= N_PSYM
;
2332 current_sym_addr
= 0;
2335 if (DECL_NAME (parms
))
2337 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2339 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2340 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2341 DBX_MEMPARM_STABS_LETTER
);
2345 current_sym_nchars
= 8;
2346 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2347 DBX_MEMPARM_STABS_LETTER
);
2350 /* It is quite tempting to use:
2352 dbxout_type (TREE_TYPE (parms), 0, 0);
2354 as the next statement, rather than using DECL_ARG_TYPE(), so
2355 that gcc reports the actual type of the parameter, rather
2356 than the promoted type. This certainly makes GDB's life
2357 easier, at least for some ports. The change is a bad idea
2358 however, since GDB expects to be able access the type without
2359 performing any conversions. So for example, if we were
2360 passing a float to an unprototyped function, gcc will store a
2361 double on the stack, but if we emit a stab saying the type is a
2362 float, then gdb will only read in a single value, and this will
2363 produce an erropneous value. */
2364 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
2365 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
2366 dbxout_finish_symbol (parms
);
2368 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
2371 char regparm_letter
;
2373 /* Parm passed in registers and lives in registers or nowhere. */
2375 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2376 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2377 current_sym_addr
= 0;
2379 /* If parm lives in a register, use that register;
2380 pretend the parm was passed there. It would be more consistent
2381 to describe the register where the parm was passed,
2382 but in practice that register usually holds something else.
2384 If we use DECL_RTL, then we must use the declared type of
2385 the variable, not the type that it arrived in. */
2386 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2388 best_rtl
= DECL_RTL (parms
);
2389 parm_type
= TREE_TYPE (parms
);
2391 /* If the parm lives nowhere, use the register where it was
2392 passed. It is also better to use the declared type here. */
2395 best_rtl
= DECL_INCOMING_RTL (parms
);
2396 parm_type
= TREE_TYPE (parms
);
2398 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
2401 if (DECL_NAME (parms
))
2403 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2404 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2405 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2410 current_sym_nchars
= 8;
2411 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2415 dbxout_type (parm_type
, 0, 0);
2416 dbxout_finish_symbol (parms
);
2418 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2419 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
2420 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
2421 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
2422 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2423 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
2427 /* Parm was passed via invisible reference.
2428 That is, its address was passed in a register.
2429 Output it as if it lived in that register.
2430 The debugger will know from the type
2431 that it was actually passed by invisible reference. */
2433 char regparm_letter
;
2434 /* Parm passed in registers and lives in registers or nowhere. */
2436 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2437 if (use_gnu_debug_info_extensions
)
2438 regparm_letter
= GDB_INV_REF_REGPARM_STABS_LETTER
;
2440 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2442 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2443 If it is an unallocated pseudo-reg, then use the register where
2444 it was passed instead. */
2445 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
2446 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
2448 current_sym_value
= REGNO (DECL_INCOMING_RTL (parms
));
2450 current_sym_addr
= 0;
2453 if (DECL_NAME (parms
))
2455 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2457 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2458 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2463 current_sym_nchars
= 8;
2464 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2468 dbxout_type (TREE_TYPE (parms
), 0, 0);
2469 dbxout_finish_symbol (parms
);
2471 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2472 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
2474 /* Parm was passed via invisible reference, with the reference
2475 living on the stack. DECL_RTL looks like
2476 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
2477 could look like (MEM (MEM (REG))). */
2478 const char *decl_name
= (DECL_NAME (parms
)
2479 ? IDENTIFIER_POINTER (DECL_NAME (parms
))
2481 if (GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 0)) == REG
)
2482 current_sym_value
= 0;
2485 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
2486 current_sym_addr
= 0;
2489 fprintf (asmfile
, "%s\"%s:v", ASM_STABS_OP
, decl_name
);
2490 dbxout_type (TREE_TYPE (parms
), 0, 0);
2491 dbxout_finish_symbol (parms
);
2493 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2494 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
2495 /* ??? A constant address for a parm can happen
2496 when the reg it lives in is equiv to a constant in memory.
2497 Should make this not happen, after 2.4. */
2498 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
2500 /* Parm was passed in registers but lives on the stack. */
2502 current_sym_code
= N_PSYM
;
2503 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2504 in which case we want the value of that CONST_INT,
2506 in which case we use a value of zero. */
2507 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
)
2508 current_sym_value
= 0;
2511 = INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
2513 current_sym_addr
= 0;
2515 /* Make a big endian correction if the mode of the type of the
2516 parameter is not the same as the mode of the rtl. */
2517 if (BYTES_BIG_ENDIAN
2518 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
2519 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
2521 current_sym_value
+=
2522 GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
2523 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
)));
2527 if (DECL_NAME (parms
))
2530 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2532 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2533 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2534 DBX_MEMPARM_STABS_LETTER
);
2538 current_sym_nchars
= 8;
2539 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2540 DBX_MEMPARM_STABS_LETTER
);
2544 = DEBUGGER_ARG_OFFSET (current_sym_value
,
2545 XEXP (DECL_RTL (parms
), 0));
2546 dbxout_type (TREE_TYPE (parms
), 0, 0);
2547 dbxout_finish_symbol (parms
);
2552 /* Output definitions for the places where parms live during the function,
2553 when different from where they were passed, when the parms were passed
2556 It is not useful to do this for parms passed in registers
2557 that live during the function in different registers, because it is
2558 impossible to look in the passed register for the passed value,
2559 so we use the within-the-function register to begin with.
2561 PARMS is a chain of PARM_DECL nodes. */
2564 dbxout_reg_parms (parms
)
2567 for (; parms
; parms
= TREE_CHAIN (parms
))
2568 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
2570 dbxout_prepare_symbol (parms
);
2572 /* Report parms that live in registers during the function
2573 but were passed in memory. */
2574 if (GET_CODE (DECL_RTL (parms
)) == REG
2575 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2576 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2577 0, DECL_RTL (parms
));
2578 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
2579 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2580 0, DECL_RTL (parms
));
2581 /* Report parms that live in memory but not where they were passed. */
2582 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2583 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
2584 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2585 0, DECL_RTL (parms
));
2589 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2590 output definitions of those names, in raw form */
2598 putc (',', asmfile
);
2599 dbxout_type (TREE_VALUE (args
), 0, 0);
2601 args
= TREE_CHAIN (args
);
2605 /* Given a chain of ..._TYPE nodes,
2606 find those which have typedef names and output those names.
2607 This is to ensure those types get output. */
2610 dbxout_types (types
)
2611 register tree types
;
2615 if (TYPE_NAME (types
)
2616 && TREE_CODE (TYPE_NAME (types
)) == TYPE_DECL
2617 && ! TREE_ASM_WRITTEN (TYPE_NAME (types
)))
2618 dbxout_symbol (TYPE_NAME (types
), 1);
2619 types
= TREE_CHAIN (types
);
2623 /* Output everything about a symbol block (a BLOCK node
2624 that represents a scope level),
2625 including recursive output of contained blocks.
2627 BLOCK is the BLOCK node.
2628 DEPTH is its depth within containing symbol blocks.
2629 ARGS is usually zero; but for the outermost block of the
2630 body of a function, it is a chain of PARM_DECLs for the function parameters.
2631 We output definitions of all the register parms
2632 as if they were local variables of that block.
2634 If -g1 was used, we count blocks just the same, but output nothing
2635 except for the outermost block.
2637 Actually, BLOCK may be several blocks chained together.
2638 We handle them all in sequence. */
2641 dbxout_block (block
, depth
, args
)
2642 register tree block
;
2648 #if DBX_BLOCKS_FUNCTION_RELATIVE
2649 const char *begin_label
;
2650 if (current_function_func_begin_label
!= NULL_TREE
)
2651 begin_label
= IDENTIFIER_POINTER (current_function_func_begin_label
);
2653 begin_label
= XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0);
2658 /* Ignore blocks never expanded or otherwise marked as real. */
2659 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
2663 #ifdef DBX_LBRAC_FIRST
2666 /* In dbx format, the syms of a block come before the N_LBRAC.
2667 If nothing is output, we don't need the N_LBRAC, either. */
2669 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2670 did_output
= dbxout_syms (BLOCK_VARS (block
));
2672 dbxout_reg_parms (args
);
2675 /* Now output an N_LBRAC symbol to represent the beginning of
2676 the block. Use the block's tree-walk order to generate
2677 the assembler symbols LBBn and LBEn
2678 that final will define around the code in this block. */
2679 if (depth
> 0 && did_output
)
2682 blocknum
= BLOCK_NUMBER (block
);
2683 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
2685 if (BLOCK_HANDLER_BLOCK (block
))
2687 /* A catch block. Must precede N_LBRAC. */
2688 tree decl
= BLOCK_VARS (block
);
2691 #ifdef DBX_OUTPUT_CATCH
2692 DBX_OUTPUT_CATCH (asmfile
, decl
, buf
);
2694 fprintf (asmfile
, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP
,
2695 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
2696 assemble_name (asmfile
, buf
);
2697 fprintf (asmfile
, "\n");
2699 decl
= TREE_CHAIN (decl
);
2703 #ifdef DBX_OUTPUT_LBRAC
2704 DBX_OUTPUT_LBRAC (asmfile
, buf
);
2706 fprintf (asmfile
, "%s%d,0,0,", ASM_STABN_OP
, N_LBRAC
);
2707 assemble_name (asmfile
, buf
);
2708 #if DBX_BLOCKS_FUNCTION_RELATIVE
2709 fputc ('-', asmfile
);
2710 assemble_name (asmfile
, begin_label
);
2712 fprintf (asmfile
, "\n");
2716 #ifdef DBX_LBRAC_FIRST
2717 /* On some weird machines, the syms of a block
2718 come after the N_LBRAC. */
2719 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2720 dbxout_syms (BLOCK_VARS (block
));
2722 dbxout_reg_parms (args
);
2725 /* Output the subblocks. */
2726 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
2728 /* Refer to the marker for the end of the block. */
2729 if (depth
> 0 && did_output
)
2732 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
2733 #ifdef DBX_OUTPUT_RBRAC
2734 DBX_OUTPUT_RBRAC (asmfile
, buf
);
2736 fprintf (asmfile
, "%s%d,0,0,", ASM_STABN_OP
, N_RBRAC
);
2737 assemble_name (asmfile
, buf
);
2738 #if DBX_BLOCKS_FUNCTION_RELATIVE
2739 fputc ('-', asmfile
);
2740 assemble_name (asmfile
, begin_label
);
2742 fprintf (asmfile
, "\n");
2746 block
= BLOCK_CHAIN (block
);
2750 /* Output the information about a function and its arguments and result.
2751 Usually this follows the function's code,
2752 but on some systems, it comes before. */
2755 dbxout_really_begin_function (decl
)
2758 dbxout_symbol (decl
, 0);
2759 dbxout_parms (DECL_ARGUMENTS (decl
));
2760 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
2761 dbxout_symbol (DECL_RESULT (decl
), 1);
2764 /* Called at beginning of output of function definition. */
2767 dbxout_begin_function (decl
)
2768 tree decl ATTRIBUTE_UNUSED
;
2770 #ifdef DBX_FUNCTION_FIRST
2771 dbxout_really_begin_function (decl
);
2775 /* Output dbx data for a function definition.
2776 This includes a definition of the function name itself (a symbol),
2777 definitions of the parameters (locating them in the parameter list)
2778 and then output the block that makes up the function's body
2779 (including all the auto variables of the function). */
2782 dbxout_function (decl
)
2785 #ifndef DBX_FUNCTION_FIRST
2786 dbxout_really_begin_function (decl
);
2788 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
2789 #ifdef DBX_OUTPUT_FUNCTION_END
2790 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
2792 #if defined(ASM_OUTPUT_SECTION_NAME)
2793 if (use_gnu_debug_info_extensions
2794 #if defined(NO_DBX_FUNCTION_END)
2795 && ! NO_DBX_FUNCTION_END
2798 dbxout_function_end ();
2801 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */