1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987, 88, 92-97, 1998 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
22 /* Output dbx-format symbol table data.
23 This consists of many symbol table entries, each of them
24 a .stabs assembler pseudo-op with four operands:
25 a "name" which is really a description of one symbol and its type,
26 a "code", which is a symbol defined in stab.h whose name starts with N_,
27 an unused operand always 0,
28 and a "value" which is an address or an offset.
29 The name is enclosed in doublequote characters.
31 Each function, variable, typedef, and structure tag
32 has a symbol table entry to define it.
33 The beginning and end of each level of name scoping within
34 a function are also marked by special symbol table entries.
36 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
37 and a data type number. The data type number may be followed by
38 "=" and a type definition; normally this will happen the first time
39 the type number is mentioned. The type definition may refer to
40 other types by number, and those type numbers may be followed
41 by "=" and nested definitions.
43 This can make the "name" quite long.
44 When a name is more than 80 characters, we split the .stabs pseudo-op
45 into two .stabs pseudo-ops, both sharing the same "code" and "value".
46 The first one is marked as continued with a double-backslash at the
49 The kind-of-symbol letter distinguished function names from global
50 variables from file-scope variables from parameters from auto
51 variables in memory from typedef names from register variables.
54 The "code" is mostly redundant with the kind-of-symbol letter
55 that goes in the "name", but not entirely: for symbols located
56 in static storage, the "code" says which segment the address is in,
57 which controls how it is relocated.
59 The "value" for a symbol in static storage
60 is the core address of the symbol (actually, the assembler
61 label for the symbol). For a symbol located in a stack slot
62 it is the stack offset; for one in a register, the register number.
63 For a typedef symbol, it is zero.
65 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
66 output while in the text section.
68 For more on data type definitions, see `dbxout_type'. */
77 #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 ".stabs"
95 #define ASM_STABN_OP ".stabn"
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 /* In dbx output, we must assign symbol-blocks id numbers
276 in the order in which their beginnings are encountered.
277 We output debugging info that refers to the beginning and
278 end of the ranges of code in each block
279 with assembler labels LBBn and LBEn, where n is the block number.
280 The labels are generated in final, which assigns numbers to the
281 blocks in the same way. */
283 static int next_block_number
;
285 /* These variables are for dbxout_symbol to communicate to
286 dbxout_finish_symbol.
287 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
288 current_sym_value and current_sym_addr are two ways to address the
289 value to store in the symtab entry.
290 current_sym_addr if nonzero represents the value as an rtx.
291 If that is zero, current_sym_value is used. This is used
292 when the value is an offset (such as for auto variables,
293 register variables and parms). */
295 static STAB_CODE_TYPE current_sym_code
;
296 static int current_sym_value
;
297 static rtx current_sym_addr
;
299 /* Number of chars of symbol-description generated so far for the
300 current symbol. Used by CHARS and CONTIN. */
302 static int current_sym_nchars
;
304 /* Report having output N chars of the current symbol-description. */
306 #define CHARS(N) (current_sym_nchars += (N))
308 /* Break the current symbol-description, generating a continuation,
309 if it has become long. */
311 #ifndef DBX_CONTIN_LENGTH
312 #define DBX_CONTIN_LENGTH 80
315 #if DBX_CONTIN_LENGTH > 0
317 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
322 #if defined(ASM_OUTPUT_SECTION_NAME)
323 static void dbxout_function_end
PROTO((void));
325 static void dbxout_typedefs
PROTO((tree
));
326 static void dbxout_type_index
PROTO((tree
));
327 #if DBX_CONTIN_LENGTH > 0
328 static void dbxout_continue
PROTO((void));
330 static void dbxout_type_fields
PROTO((tree
));
331 static void dbxout_type_method_1
PROTO((tree
, const char *));
332 static void dbxout_type_methods
PROTO((tree
));
333 static void dbxout_range_type
PROTO((tree
));
334 static void dbxout_type
PROTO((tree
, int, int));
335 static void print_int_cst_octal
PROTO((tree
));
336 static void print_octal
PROTO((unsigned HOST_WIDE_INT
, int));
337 static void dbxout_type_name
PROTO((tree
));
338 static void dbxout_symbol_location
PROTO((tree
, tree
, const char *, rtx
));
339 static void dbxout_symbol_name
PROTO((tree
, const char *, int));
340 static void dbxout_prepare_symbol
PROTO((tree
));
341 static void dbxout_finish_symbol
PROTO((tree
));
342 static void dbxout_block
PROTO((tree
, int, tree
));
343 static void dbxout_really_begin_function
PROTO((tree
));
345 #if defined(ASM_OUTPUT_SECTION_NAME)
347 dbxout_function_end ()
349 static int scope_labelno
= 0;
350 char lscope_label_name
[100];
351 /* Convert Ltext into the appropriate format for local labels in case
352 the system doesn't insert underscores in front of user generated
354 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
355 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Lscope", scope_labelno
);
358 /* By convention, GCC will mark the end of a function with an N_FUN
359 symbol and an empty string. */
360 fprintf (asmfile
, "%s \"\",%d,0,0,", ASM_STABS_OP
, N_FUN
);
361 assemble_name (asmfile
, lscope_label_name
);
362 fputc ('-', asmfile
);
363 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
364 fprintf (asmfile
, "\n");
366 #endif /* ! NO_DBX_FUNCTION_END */
368 /* At the beginning of compilation, start writing the symbol table.
369 Initialize `typevec' and output the standard data types of C. */
372 dbxout_init (asm_file
, input_file_name
, syms
)
374 const char *input_file_name
;
377 char ltext_label_name
[100];
382 typevec
= (struct typeinfo
*) xcalloc (typevec_len
, sizeof typevec
[0]);
384 /* Convert Ltext into the appropriate format for local labels in case
385 the system doesn't insert underscores in front of user generated
387 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
389 /* Put the current working directory in an N_SO symbol. */
390 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
391 but GDB always does. */
392 if (use_gnu_debug_info_extensions
)
395 if (!cwd
&& (cwd
= getpwd ()) && (!*cwd
|| cwd
[strlen (cwd
) - 1] != '/'))
397 char *wdslash
= xmalloc (strlen (cwd
) + sizeof (FILE_NAME_JOINER
));
398 sprintf (wdslash
, "%s%s", cwd
, FILE_NAME_JOINER
);
403 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
404 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile
, cwd
);
405 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
406 fprintf (asmfile
, "%s ", ASM_STABS_OP
);
407 output_quoted_string (asmfile
, cwd
);
408 fprintf (asmfile
, ",%d,0,0,%s\n", N_SO
, <ext_label_name
[1]);
409 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
413 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
414 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
415 would give us an N_SOL, and we want an N_SO. */
416 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile
, input_file_name
);
417 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
418 /* We include outputting `Ltext:' here,
419 because that gives you a way to override it. */
420 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
421 fprintf (asmfile
, "%s ", ASM_STABS_OP
);
422 output_quoted_string (asmfile
, input_file_name
);
423 fprintf (asmfile
, ",%d,0,0,%s\n",
424 N_SO
, <ext_label_name
[1]);
426 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Ltext", 0);
427 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
429 /* Possibly output something to inform GDB that this compilation was by
430 GCC. It's easier for GDB to parse it when after the N_SO's. This
431 is used in Solaris 2. */
432 #ifdef ASM_IDENTIFY_GCC_AFTER_SOURCE
433 ASM_IDENTIFY_GCC_AFTER_SOURCE (asmfile
);
436 lastfile
= input_file_name
;
438 next_type_number
= 1;
439 next_block_number
= 2;
442 current_file
= (struct dbx_file
*) xmalloc (sizeof *current_file
);
443 current_file
->next
= NULL
;
444 current_file
->file_number
= 0;
445 current_file
->next_type_number
= 1;
446 next_file_number
= 1;
449 /* Make sure that types `int' and `char' have numbers 1 and 2.
450 Definitions of other integer types will refer to those numbers.
451 (Actually it should no longer matter what their numbers are.
452 Also, if any types with tags have been defined, dbxout_symbol
453 will output them first, so the numbers won't be 1 and 2. That
454 happens in C++. So it's a good thing it should no longer matter). */
456 #ifdef DBX_OUTPUT_STANDARD_TYPES
457 DBX_OUTPUT_STANDARD_TYPES (syms
);
459 dbxout_symbol (TYPE_NAME (integer_type_node
), 0);
460 dbxout_symbol (TYPE_NAME (char_type_node
), 0);
463 /* Get all permanent types that have typedef names,
464 and output them all, except for those already output. */
466 dbxout_typedefs (syms
);
468 ggc_add_string_root ((char **) &lastfile
, 1);
471 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
472 in the reverse order from that which is found in SYMS. */
475 dbxout_typedefs (syms
)
480 dbxout_typedefs (TREE_CHAIN (syms
));
481 if (TREE_CODE (syms
) == TYPE_DECL
)
483 tree type
= TREE_TYPE (syms
);
485 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
486 && TYPE_SIZE (type
) != NULL_TREE
487 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
488 dbxout_symbol (TYPE_NAME (type
), 0);
493 /* Change to reading from a new source file. Generate a N_BINCL stab. */
496 dbxout_start_new_source_file (filename
)
497 const char *filename ATTRIBUTE_UNUSED
;
500 struct dbx_file
*n
= (struct dbx_file
*) xmalloc (sizeof *n
);
502 n
->next
= current_file
;
503 n
->file_number
= next_file_number
++;
504 n
->next_type_number
= 1;
506 fprintf (asmfile
, "%s ", ASM_STABS_OP
);
507 output_quoted_string (asmfile
, filename
);
508 fprintf (asmfile
, ",%d,0,0,0\n", N_BINCL
);
512 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
515 dbxout_resume_previous_source_file ()
518 struct dbx_file
*next
;
520 fprintf (asmfile
, "%s %d,0,0,0\n", ASM_STABN_OP
, N_EINCL
);
521 next
= current_file
->next
;
527 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
530 dbxout_source_file (file
, filename
)
532 const char *filename
;
534 char ltext_label_name
[100];
536 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
538 #ifdef DBX_OUTPUT_SOURCE_FILENAME
539 DBX_OUTPUT_SOURCE_FILENAME (file
, filename
);
541 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext",
542 source_label_number
);
543 fprintf (file
, "%s ", ASM_STABS_OP
);
544 output_quoted_string (file
, filename
);
545 fprintf (file
, ",%d,0,0,%s\n", N_SOL
, <ext_label_name
[1]);
546 if (current_function_decl
!= NULL_TREE
547 && DECL_SECTION_NAME (current_function_decl
) != NULL_TREE
)
548 ; /* Don't change section amid function. */
551 ASM_OUTPUT_INTERNAL_LABEL (file
, "Ltext", source_label_number
);
552 source_label_number
++;
558 /* Output a line number symbol entry into output stream FILE,
559 for source file FILENAME and line number LINENO. */
562 dbxout_source_line (file
, filename
, lineno
)
564 const char *filename
;
567 dbxout_source_file (file
, filename
);
569 #ifdef ASM_OUTPUT_SOURCE_LINE
570 ASM_OUTPUT_SOURCE_LINE (file
, lineno
);
572 fprintf (file
, "\t%s %d,0,%d\n", ASM_STABD_OP
, N_SLINE
, lineno
);
576 /* At the end of compilation, finish writing the symbol table.
577 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
581 dbxout_finish (file
, filename
)
582 FILE *file ATTRIBUTE_UNUSED
;
583 const char *filename ATTRIBUTE_UNUSED
;
585 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
586 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file
, filename
);
587 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
590 /* Output the index of a type. */
593 dbxout_type_index (type
)
596 #ifndef DBX_USE_BINCL
597 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
600 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
601 fprintf (asmfile
, "(%d,%d)", t
->file_number
, t
->type_number
);
606 #if DBX_CONTIN_LENGTH > 0
607 /* Continue a symbol-description that gets too big.
608 End one symbol table entry with a double-backslash
609 and start a new one, eventually producing something like
610 .stabs "start......\\",code,0,value
611 .stabs "...rest",code,0,value */
616 #ifdef DBX_CONTIN_CHAR
617 fprintf (asmfile
, "%c", DBX_CONTIN_CHAR
);
619 fprintf (asmfile
, "\\\\");
621 dbxout_finish_symbol (NULL_TREE
);
622 fprintf (asmfile
, "%s \"", ASM_STABS_OP
);
623 current_sym_nchars
= 0;
625 #endif /* DBX_CONTIN_LENGTH > 0 */
627 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
628 This must be a separate function because anonymous unions require
632 dbxout_type_fields (type
)
636 /* Output the name, type, position (in bits), size (in bits) of each
638 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
640 /* Omit here local type decls until we know how to support them. */
641 if (TREE_CODE (tem
) == TYPE_DECL
)
643 /* Omit fields whose position or size are variable. */
644 else if (TREE_CODE (tem
) == FIELD_DECL
645 && (TREE_CODE (DECL_FIELD_BITPOS (tem
)) != INTEGER_CST
646 || TREE_CODE (DECL_SIZE (tem
)) != INTEGER_CST
))
648 /* Omit here the nameless fields that are used to skip bits. */
649 else if (DECL_IGNORED_P (tem
))
651 else if (TREE_CODE (tem
) != CONST_DECL
)
653 /* Continue the line if necessary,
654 but not before the first field. */
655 if (tem
!= TYPE_FIELDS (type
))
660 if (use_gnu_debug_info_extensions
661 && flag_minimal_debug
662 && TREE_CODE (tem
) == FIELD_DECL
663 && DECL_VIRTUAL_P (tem
)
664 && DECL_ASSEMBLER_NAME (tem
))
666 have_used_extensions
= 1;
667 CHARS (3 + IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (tem
)));
668 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
)), asmfile
);
669 dbxout_type (DECL_FCONTEXT (tem
), 0, 0);
670 fprintf (asmfile
, ":");
671 dbxout_type (TREE_TYPE (tem
), 0, 0);
672 fputc (',', asmfile
);
673 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
674 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem
)));
675 fputc (';', asmfile
);
681 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem
)));
682 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem
)));
686 fprintf (asmfile
, ":");
690 if (use_gnu_debug_info_extensions
691 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
692 || TREE_CODE (tem
) != FIELD_DECL
))
694 have_used_extensions
= 1;
696 putc ((TREE_PRIVATE (tem
) ? '0'
697 : TREE_PROTECTED (tem
) ? '1' : '2'),
702 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
703 && DECL_BIT_FIELD_TYPE (tem
))
704 ? DECL_BIT_FIELD_TYPE (tem
)
705 : TREE_TYPE (tem
), 0, 0);
707 if (TREE_CODE (tem
) == VAR_DECL
)
709 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
712 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
));
713 have_used_extensions
= 1;
714 fprintf (asmfile
, ":%s;", name
);
715 CHARS (strlen (name
));
719 /* If TEM is non-static, GDB won't understand it. */
720 fprintf (asmfile
, ",0,0;");
723 else if (TREE_CODE (DECL_FIELD_BITPOS (tem
)) == INTEGER_CST
)
725 fputc (',', asmfile
);
726 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
727 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem
)));
728 fputc (',', asmfile
);
729 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
730 TREE_INT_CST_LOW (DECL_SIZE (tem
)));
731 fputc (';', asmfile
);
738 /* Subroutine of `dbxout_type_methods'. Output debug info about the
739 method described DECL. DEBUG_NAME is an encoding of the method's
740 type signature. ??? We may be able to do without DEBUG_NAME altogether
744 dbxout_type_method_1 (decl
, debug_name
)
746 const char *debug_name
;
750 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
752 else /* it's a METHOD_TYPE. */
754 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
755 /* A for normal functions.
756 B for `const' member functions.
757 C for `volatile' member functions.
758 D for `const volatile' member functions. */
759 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
761 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
764 if (DECL_VINDEX (decl
))
770 fprintf (asmfile
, ":%s;%c%c%c", debug_name
,
771 TREE_PRIVATE (decl
) ? '0' : TREE_PROTECTED (decl
) ? '1' : '2', c1
, c2
);
772 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
)) + 6
773 - (debug_name
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
774 if (DECL_VINDEX (decl
))
776 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
777 TREE_INT_CST_LOW (DECL_VINDEX (decl
)));
778 fputc (';', asmfile
);
779 dbxout_type (DECL_CONTEXT (decl
), 0, 0);
780 fprintf (asmfile
, ";");
785 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
789 dbxout_type_methods (type
)
792 /* C++: put out the method names and their parameter lists */
793 tree methods
= TYPE_METHODS (type
);
795 register tree fndecl
;
797 char formatted_type_identifier_length
[16];
798 register int type_identifier_length
;
800 if (methods
== NULL_TREE
)
803 type_encoding
= DECL_NAME (TYPE_NAME (type
));
806 /* C++: Template classes break some assumptions made by this code about
807 the class names, constructor names, and encodings for assembler
808 label names. For now, disable output of dbx info for them. */
810 const char *ptr
= IDENTIFIER_POINTER (type_encoding
);
811 /* This should use index. (mrs) */
812 while (*ptr
&& *ptr
!= '<') ptr
++;
823 type_identifier_length
= IDENTIFIER_LENGTH (type_encoding
);
825 sprintf(formatted_type_identifier_length
, "%d", type_identifier_length
);
827 if (TREE_CODE (methods
) != TREE_VEC
)
829 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
830 fndecl
= TREE_VEC_ELT (methods
, 0);
832 fndecl
= TREE_VEC_ELT (methods
, 1);
836 tree name
= DECL_NAME (fndecl
);
839 /* Group together all the methods for the same operation.
840 These differ in the types of the arguments. */
841 for (last
= NULL_TREE
;
842 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
843 fndecl
= TREE_CHAIN (fndecl
))
844 /* Output the name of the field (after overloading), as
845 well as the name of the field before overloading, along
846 with its parameter list */
848 /* This is the "mangled" name of the method.
849 It encodes the argument types. */
850 const char *debug_name
=
851 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
));
852 int show_arg_types
= 0;
858 if (DECL_IGNORED_P (fndecl
))
861 if (flag_minimal_debug
)
865 /* We can't optimize a method which uses an anonymous
866 class, because the debugger will not be able to
867 associate the arbitrary class name with the actual
869 #ifndef NO_DOLLAR_IN_LABEL
874 if (strchr (debug_name
, marker
))
876 /* Detect ordinary methods because their mangled names
877 start with the operation name. */
878 else if (!strncmp (IDENTIFIER_POINTER (name
), debug_name
,
879 IDENTIFIER_LENGTH (name
)))
881 debug_name
+= IDENTIFIER_LENGTH (name
);
882 if (debug_name
[0] == '_' && debug_name
[1] == '_')
884 const char *method_name
= debug_name
+ 2;
885 const char *length_ptr
=
886 formatted_type_identifier_length
;
887 /* Get past const and volatile qualifiers. */
888 while (*method_name
== 'C' || *method_name
== 'V')
890 /* Skip digits for length of type_encoding. */
891 while (*method_name
== *length_ptr
&& *length_ptr
)
892 length_ptr
++, method_name
++;
893 if (! strncmp (method_name
,
894 IDENTIFIER_POINTER (type_encoding
),
895 type_identifier_length
))
896 method_name
+= type_identifier_length
;
897 debug_name
= method_name
;
900 /* Detect constructors by their style of name mangling. */
901 else if (debug_name
[0] == '_' && debug_name
[1] == '_')
903 const char *ctor_name
= debug_name
+ 2;
904 const char *length_ptr
= formatted_type_identifier_length
;
905 while (*ctor_name
== 'C' || *ctor_name
== 'V')
907 /* Skip digits for length of type_encoding. */
908 while (*ctor_name
== *length_ptr
&& *length_ptr
)
909 length_ptr
++, ctor_name
++;
910 if (!strncmp (IDENTIFIER_POINTER (type_encoding
), ctor_name
,
911 type_identifier_length
))
912 debug_name
= ctor_name
+ type_identifier_length
;
914 /* The other alternative is a destructor. */
918 /* Output the operation name just once, for the first method
922 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (name
));
923 CHARS (IDENTIFIER_LENGTH (name
) + 2);
928 dbxout_type (TREE_TYPE (fndecl
), 0, show_arg_types
);
930 dbxout_type_method_1 (fndecl
, debug_name
);
940 /* Emit a "range" type specification, which has the form:
941 "r<index type>;<lower bound>;<upper bound>;".
942 TYPE is an INTEGER_TYPE. */
945 dbxout_range_type (type
)
948 fprintf (asmfile
, "r");
949 if (TREE_TYPE (type
))
950 dbxout_type (TREE_TYPE (type
), 0, 0);
951 else if (TREE_CODE (type
) != INTEGER_TYPE
)
952 dbxout_type (type
, 0, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
955 /* Traditionally, we made sure 'int' was type 1, and builtin types
956 were defined to be sub-ranges of int. Unfortunately, this
957 does not allow us to distinguish true sub-ranges from integer
958 types. So, instead we define integer (non-sub-range) types as
959 sub-ranges of themselves. This matters for Chill. If this isn't
960 a subrange type, then we want to define it in terms of itself.
961 However, in C, this may be an anonymous integer type, and we don't
962 want to emit debug info referring to it. Just calling
963 dbxout_type_index won't work anyways, because the type hasn't been
964 defined yet. We make this work for both cases by checked to see
965 whether this is a defined type, referring to it if it is, and using
967 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
968 dbxout_type_index (type
);
970 dbxout_type_index (integer_type_node
);
972 if (TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
)
974 fputc (';', asmfile
);
975 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
976 TREE_INT_CST_LOW (TYPE_MIN_VALUE (type
)));
979 fprintf (asmfile
, ";0");
980 if (TYPE_MAX_VALUE (type
)
981 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
)
983 fputc (';', asmfile
);
984 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
985 TREE_INT_CST_LOW (TYPE_MAX_VALUE (type
)));
986 fputc (';', asmfile
);
989 fprintf (asmfile
, ";-1;");
992 /* Output a reference to a type. If the type has not yet been
993 described in the dbx output, output its definition now.
994 For a type already defined, just refer to its definition
995 using the type number.
997 If FULL is nonzero, and the type has been described only with
998 a forward-reference, output the definition now.
999 If FULL is zero in this case, just refer to the forward-reference
1000 using the number previously allocated.
1002 If SHOW_ARG_TYPES is nonzero, we output a description of the argument
1003 types for a METHOD_TYPE. */
1006 dbxout_type (type
, full
, show_arg_types
)
1012 static int anonymous_type_number
= 0;
1014 /* If there was an input error and we don't really have a type,
1015 avoid crashing and write something that is at least valid
1016 by assuming `int'. */
1017 if (type
== error_mark_node
)
1018 type
= integer_type_node
;
1021 /* Try to find the "main variant" with the same name but not const
1022 or volatile. (Since stabs does not distinguish const and volatile,
1023 there is no need to make them separate types. But types with
1024 different names are usefully distinguished.) */
1026 for (tem
= TYPE_MAIN_VARIANT (type
); tem
; tem
= TYPE_NEXT_VARIANT (tem
))
1027 if (!TYPE_READONLY (tem
) && !TYPE_VOLATILE (tem
)
1028 && TYPE_NAME (tem
) == TYPE_NAME (type
))
1033 if (TYPE_NAME (type
)
1034 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1035 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1039 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1041 /* Type has no dbx number assigned. Assign next available number. */
1042 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1044 /* Make sure type vector is long enough to record about this type. */
1046 if (next_type_number
== typevec_len
)
1049 = (struct typeinfo
*) xrealloc (typevec
,
1050 typevec_len
* 2 * sizeof typevec
[0]);
1051 bzero ((char *) (typevec
+ typevec_len
),
1052 typevec_len
* sizeof typevec
[0]);
1056 #ifdef DBX_USE_BINCL
1057 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1058 = current_file
->file_number
;
1059 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1060 = current_file
->next_type_number
++;
1064 /* Output the number of this type, to refer to it. */
1065 dbxout_type_index (type
);
1067 #ifdef DBX_TYPE_DEFINED
1068 if (DBX_TYPE_DEFINED (type
))
1072 /* If this type's definition has been output or is now being output,
1075 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1080 /* If we have already had a cross reference,
1081 and either that's all we want or that's the best we could do,
1082 don't repeat the cross reference.
1083 Sun dbx crashes if we do. */
1084 if (! full
|| TYPE_SIZE (type
) == 0
1085 /* No way in DBX fmt to describe a variable size. */
1086 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1094 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1095 leave the type-number completely undefined rather than output
1096 a cross-reference. If we have already used GNU debug info extensions,
1097 then it is OK to output a cross reference. This is necessary to get
1098 proper C++ debug output. */
1099 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1100 || TREE_CODE (type
) == QUAL_UNION_TYPE
1101 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1102 && ! use_gnu_debug_info_extensions
)
1103 /* We must use the same test here as we use twice below when deciding
1104 whether to emit a cross-reference. */
1105 if ((TYPE_NAME (type
) != 0
1106 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1107 && DECL_IGNORED_P (TYPE_NAME (type
)))
1109 || TYPE_SIZE (type
) == 0
1110 /* No way in DBX fmt to describe a variable size. */
1111 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1113 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1118 /* Output a definition now. */
1120 fprintf (asmfile
, "=");
1123 /* Mark it as defined, so that if it is self-referent
1124 we will not get into an infinite recursion of definitions. */
1126 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1128 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1129 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1131 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0, 0);
1135 switch (TREE_CODE (type
))
1139 /* For a void type, just define it as itself; ie, "5=5".
1140 This makes us consider it defined
1141 without saying what it is. The debugger will make it
1142 a void type when the reference is seen, and nothing will
1143 ever override that default. */
1144 dbxout_type_index (type
);
1148 if (type
== char_type_node
&& ! TREE_UNSIGNED (type
))
1150 /* Output the type `char' as a subrange of itself!
1151 I don't understand this definition, just copied it
1152 from the output of pcc.
1153 This used to use `r2' explicitly and we used to
1154 take care to make sure that `char' was type number 2. */
1155 fprintf (asmfile
, "r");
1156 dbxout_type_index (type
);
1157 fprintf (asmfile
, ";0;127;");
1160 /* If this is a subtype of another integer type, always prefer to
1161 write it as a subtype. */
1162 else if (TREE_TYPE (type
) != 0
1163 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_CST
)
1164 dbxout_range_type (type
);
1168 /* If the size is non-standard, say what it is if we can use
1171 if (use_gnu_debug_info_extensions
1172 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1173 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1175 /* If we can use GDB extensions and the size is wider than a
1176 long (the size used by GDB to read them) or we may have
1177 trouble writing the bounds the usual way, write them in
1178 octal. Note the test is for the *target's* size of "long",
1179 not that of the host. The host test is just to make sure we
1180 can write it out in case the host wide int is narrower than the
1183 if (use_gnu_debug_info_extensions
1184 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
1185 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
))
1187 fprintf (asmfile
, "r");
1188 dbxout_type_index (type
);
1189 fprintf (asmfile
, ";");
1190 print_int_cst_octal (TYPE_MIN_VALUE (type
));
1191 fprintf (asmfile
, ";");
1192 print_int_cst_octal (TYPE_MAX_VALUE (type
));
1193 fprintf (asmfile
, ";");
1197 /* Output other integer types as subranges of `int'. */
1198 dbxout_range_type (type
);
1205 /* This used to say `r1' and we used to take care
1206 to make sure that `int' was type number 1. */
1207 fprintf (asmfile
, "r");
1208 dbxout_type_index (integer_type_node
);
1209 fputc (';', asmfile
);
1210 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1211 fputs (";0;", asmfile
);
1216 if (use_gnu_debug_info_extensions
)
1218 fputs ("@s", asmfile
);
1219 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1220 BITS_PER_UNIT
* int_size_in_bytes (type
));
1221 fputs (";-20;", asmfile
);
1225 /* Output the type `char' as a subrange of itself.
1226 That is what pcc seems to do. */
1227 fprintf (asmfile
, "r");
1228 dbxout_type_index (char_type_node
);
1229 fprintf (asmfile
, ";0;%d;", TREE_UNSIGNED (type
) ? 255 : 127);
1235 if (use_gnu_debug_info_extensions
)
1237 fputs ("@s", asmfile
);
1238 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1239 BITS_PER_UNIT
* int_size_in_bytes (type
));
1240 fputs (";-16;", asmfile
);
1242 else /* Define as enumeral type (False, True) */
1243 fprintf (asmfile
, "eFalse:0,True:1,;");
1248 putc ('d', asmfile
);
1250 dbxout_type (TREE_TYPE (type
), 0, 0);
1254 /* Differs from the REAL_TYPE by its new data type number */
1256 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1258 fprintf (asmfile
, "r");
1259 dbxout_type_index (type
);
1260 fputc (';', asmfile
);
1261 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1262 int_size_in_bytes (TREE_TYPE (type
)));
1263 fputs (";0;", asmfile
);
1264 CHARS (12); /* The number is probably incorrect here. */
1268 /* Output a complex integer type as a structure,
1269 pending some other way to do it. */
1270 fputc ('s', asmfile
);
1271 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1273 fprintf (asmfile
, "real:");
1275 dbxout_type (TREE_TYPE (type
), 0, 0);
1276 fprintf (asmfile
, ",%d,%d;",
1277 0, TYPE_PRECISION (TREE_TYPE (type
)));
1279 fprintf (asmfile
, "imag:");
1281 dbxout_type (TREE_TYPE (type
), 0, 0);
1282 fprintf (asmfile
, ",%d,%d;;",
1283 TYPE_PRECISION (TREE_TYPE (type
)),
1284 TYPE_PRECISION (TREE_TYPE (type
)));
1290 if (use_gnu_debug_info_extensions
)
1292 have_used_extensions
= 1;
1293 fputs ("@s", asmfile
);
1294 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1295 BITS_PER_UNIT
* int_size_in_bytes (type
));
1296 fputc (';', asmfile
);
1297 /* Check if a bitstring type, which in Chill is
1298 different from a [power]set. */
1299 if (TYPE_STRING_FLAG (type
))
1300 fprintf (asmfile
, "@S;");
1302 putc ('S', asmfile
);
1304 dbxout_type (TYPE_DOMAIN (type
), 0, 0);
1308 /* Make arrays of packed bits look like bitstrings for chill. */
1309 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
1311 have_used_extensions
= 1;
1312 fputs ("@s", asmfile
);
1313 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1314 BITS_PER_UNIT
* int_size_in_bytes (type
));
1315 fputc (';', asmfile
);
1316 fprintf (asmfile
, "@S;");
1317 putc ('S', asmfile
);
1319 dbxout_type (TYPE_DOMAIN (type
), 0, 0);
1322 /* Output "a" followed by a range type definition
1323 for the index type of the array
1324 followed by a reference to the target-type.
1325 ar1;0;N;M for a C array of type M and size N+1. */
1326 /* Check if a character string type, which in Chill is
1327 different from an array of characters. */
1328 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
1330 have_used_extensions
= 1;
1331 fprintf (asmfile
, "@S;");
1333 tem
= TYPE_DOMAIN (type
);
1336 fprintf (asmfile
, "ar");
1337 dbxout_type_index (integer_type_node
);
1338 fprintf (asmfile
, ";0;-1;");
1342 fprintf (asmfile
, "a");
1343 dbxout_range_type (tem
);
1346 dbxout_type (TREE_TYPE (type
), 0, 0);
1351 case QUAL_UNION_TYPE
:
1353 int i
, n_baseclasses
= 0;
1355 if (TYPE_BINFO (type
) != 0
1356 && TREE_CODE (TYPE_BINFO (type
)) == TREE_VEC
1357 && TYPE_BINFO_BASETYPES (type
) != 0)
1358 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
1360 /* Output a structure type. We must use the same test here as we
1361 use in the DBX_NO_XREFS case above. */
1362 if ((TYPE_NAME (type
) != 0
1363 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1364 && DECL_IGNORED_P (TYPE_NAME (type
)))
1366 || TYPE_SIZE (type
) == 0
1367 /* No way in DBX fmt to describe a variable size. */
1368 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1370 /* If the type is just a cross reference, output one
1371 and mark the type as partially described.
1372 If it later becomes defined, we will output
1373 its real definition.
1374 If the type has a name, don't nest its definition within
1375 another type's definition; instead, output an xref
1376 and let the definition come when the name is defined. */
1377 fprintf (asmfile
, (TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu");
1379 #if 0 /* This assertion is legitimately false in C++. */
1380 /* We shouldn't be outputting a reference to a type before its
1381 definition unless the type has a tag name.
1382 A typedef name without a tag name should be impossible. */
1383 if (TREE_CODE (TYPE_NAME (type
)) != IDENTIFIER_NODE
)
1386 if (TYPE_NAME (type
) != 0)
1387 dbxout_type_name (type
);
1389 fprintf (asmfile
, "$$%d", anonymous_type_number
++);
1390 fprintf (asmfile
, ":");
1391 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1395 /* Identify record or union, and print its size. */
1396 fputc (((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u'), asmfile
);
1397 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1398 int_size_in_bytes (type
));
1400 if (use_gnu_debug_info_extensions
)
1404 have_used_extensions
= 1;
1405 fprintf (asmfile
, "!%d,", n_baseclasses
);
1409 for (i
= 0; i
< n_baseclasses
; i
++)
1411 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)), i
);
1412 if (use_gnu_debug_info_extensions
)
1414 have_used_extensions
= 1;
1415 putc (TREE_VIA_VIRTUAL (child
) ? '1'
1418 putc (TREE_VIA_PUBLIC (child
) ? '2'
1421 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1422 TREE_INT_CST_LOW (BINFO_OFFSET (child
)) * BITS_PER_UNIT
);
1423 fputc (',', asmfile
);
1425 dbxout_type (BINFO_TYPE (child
), 0, 0);
1426 putc (';', asmfile
);
1430 /* Print out the base class information with fields
1431 which have the same names at the types they hold. */
1432 dbxout_type_name (BINFO_TYPE (child
));
1433 putc (':', asmfile
);
1434 dbxout_type (BINFO_TYPE (child
), full
, 0);
1435 fputc (',', asmfile
);
1436 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1437 TREE_INT_CST_LOW (BINFO_OFFSET (child
)) * BITS_PER_UNIT
);
1438 fputc (',', asmfile
);
1439 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1440 TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child
)))) * BITS_PER_UNIT
);
1441 fputc (';', asmfile
);
1449 /* Write out the field declarations. */
1450 dbxout_type_fields (type
);
1451 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1453 have_used_extensions
= 1;
1454 dbxout_type_methods (type
);
1456 putc (';', asmfile
);
1458 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1459 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1460 && TYPE_VFIELD (type
))
1462 have_used_extensions
= 1;
1464 /* Tell GDB+ that it may keep reading. */
1465 putc ('~', asmfile
);
1467 /* We need to write out info about what field this class
1468 uses as its "main" vtable pointer field, because if this
1469 field is inherited from a base class, GDB cannot necessarily
1470 figure out which field it's using in time. */
1471 if (TYPE_VFIELD (type
))
1473 putc ('%', asmfile
);
1474 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0, 0);
1476 putc (';', asmfile
);
1482 /* We must use the same test here as we use in the DBX_NO_XREFS case
1483 above. We simplify it a bit since an enum will never have a variable
1485 if ((TYPE_NAME (type
) != 0
1486 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1487 && DECL_IGNORED_P (TYPE_NAME (type
)))
1489 || TYPE_SIZE (type
) == 0)
1491 fprintf (asmfile
, "xe");
1493 dbxout_type_name (type
);
1494 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1495 fprintf (asmfile
, ":");
1498 #ifdef DBX_OUTPUT_ENUM
1499 DBX_OUTPUT_ENUM (asmfile
, type
);
1501 if (use_gnu_debug_info_extensions
1502 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1503 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1504 putc ('e', asmfile
);
1506 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1508 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)));
1509 if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == 0)
1510 fprintf (asmfile
, HOST_WIDE_INT_PRINT_UNSIGNED
,
1511 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1512 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == -1
1513 && TREE_INT_CST_LOW (TREE_VALUE (tem
)) < 0)
1514 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1515 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1517 print_int_cst_octal (TREE_VALUE (tem
));
1518 fprintf (asmfile
, ",");
1519 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)));
1520 if (TREE_CHAIN (tem
) != 0)
1525 putc (';', asmfile
);
1531 putc ('*', asmfile
);
1533 dbxout_type (TREE_TYPE (type
), 0, 0);
1537 if (use_gnu_debug_info_extensions
)
1539 have_used_extensions
= 1;
1540 putc ('#', asmfile
);
1542 if (flag_minimal_debug
&& !show_arg_types
)
1544 /* Normally, just output the return type.
1545 The argument types are encoded in the method name. */
1546 putc ('#', asmfile
);
1548 dbxout_type (TREE_TYPE (type
), 0, 0);
1549 putc (';', asmfile
);
1554 /* When outputting destructors, we need to write
1555 the argument types out longhand. */
1556 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0, 0);
1557 putc (',', asmfile
);
1559 dbxout_type (TREE_TYPE (type
), 0, 0);
1560 dbxout_args (TYPE_ARG_TYPES (type
));
1561 putc (';', asmfile
);
1567 /* Treat it as a function type. */
1568 dbxout_type (TREE_TYPE (type
), 0, 0);
1573 if (use_gnu_debug_info_extensions
)
1575 have_used_extensions
= 1;
1576 putc ('@', asmfile
);
1578 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0, 0);
1579 putc (',', asmfile
);
1581 dbxout_type (TREE_TYPE (type
), 0, 0);
1585 /* Should print as an int, because it is really
1587 dbxout_type (integer_type_node
, 0, 0);
1591 case REFERENCE_TYPE
:
1592 if (use_gnu_debug_info_extensions
)
1593 have_used_extensions
= 1;
1594 putc (use_gnu_debug_info_extensions
? '&' : '*', asmfile
);
1596 dbxout_type (TREE_TYPE (type
), 0, 0);
1600 putc ('f', asmfile
);
1602 dbxout_type (TREE_TYPE (type
), 0, 0);
1610 /* Print the value of integer constant C, in octal,
1611 handling double precision. */
1614 print_int_cst_octal (c
)
1617 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (c
);
1618 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (c
);
1619 int excess
= (3 - (HOST_BITS_PER_WIDE_INT
% 3));
1620 int width
= TYPE_PRECISION (TREE_TYPE (c
));
1622 /* GDB wants constants with no extra leading "1" bits, so
1623 we need to remove any sign-extension that might be
1625 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
1627 else if (width
> HOST_BITS_PER_WIDE_INT
)
1628 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
1629 else if (width
== HOST_BITS_PER_WIDE_INT
)
1632 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
1634 fprintf (asmfile
, "0");
1638 print_octal (high
, HOST_BITS_PER_WIDE_INT
/ 3);
1639 print_octal (low
, HOST_BITS_PER_WIDE_INT
/ 3);
1643 unsigned HOST_WIDE_INT beg
= high
>> excess
;
1644 unsigned HOST_WIDE_INT middle
1645 = ((high
& (((HOST_WIDE_INT
) 1 << excess
) - 1)) << (3 - excess
)
1646 | (low
>> (HOST_BITS_PER_WIDE_INT
/ 3 * 3)));
1647 unsigned HOST_WIDE_INT end
1648 = low
& (((unsigned HOST_WIDE_INT
) 1
1649 << (HOST_BITS_PER_WIDE_INT
/ 3 * 3))
1652 fprintf (asmfile
, "%o%01o", (int)beg
, (int)middle
);
1653 print_octal (end
, HOST_BITS_PER_WIDE_INT
/ 3);
1658 print_octal (value
, digits
)
1659 unsigned HOST_WIDE_INT value
;
1664 for (i
= digits
- 1; i
>= 0; i
--)
1665 fprintf (asmfile
, "%01o", (int)((value
>> (3 * i
)) & 7));
1668 /* Output the name of type TYPE, with no punctuation.
1669 Such names can be set up either by typedef declarations
1670 or by struct, enum and union tags. */
1673 dbxout_type_name (type
)
1677 if (TYPE_NAME (type
) == 0)
1679 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
1681 t
= TYPE_NAME (type
);
1683 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1685 t
= DECL_NAME (TYPE_NAME (type
));
1690 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
1691 CHARS (IDENTIFIER_LENGTH (t
));
1694 /* Output a .stabs for the symbol defined by DECL,
1695 which must be a ..._DECL node in the normal namespace.
1696 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1697 LOCAL is nonzero if the scope is less than the entire file. */
1700 dbxout_symbol (decl
, local
)
1702 int local ATTRIBUTE_UNUSED
;
1704 tree type
= TREE_TYPE (decl
);
1705 tree context
= NULL_TREE
;
1707 /* Cast avoids warning in old compilers. */
1708 current_sym_code
= (STAB_CODE_TYPE
) 0;
1709 current_sym_value
= 0;
1710 current_sym_addr
= 0;
1712 /* Ignore nameless syms, but don't ignore type tags. */
1714 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
1715 || DECL_IGNORED_P (decl
))
1718 dbxout_prepare_symbol (decl
);
1720 /* The output will always start with the symbol name,
1721 so always count that in the length-output-so-far. */
1723 if (DECL_NAME (decl
) != 0)
1724 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
1726 switch (TREE_CODE (decl
))
1729 /* Enum values are defined by defining the enum type. */
1733 if (DECL_RTL (decl
) == 0)
1735 if (DECL_EXTERNAL (decl
))
1737 /* Don't mention a nested function under its parent. */
1738 context
= decl_function_context (decl
);
1739 if (context
== current_function_decl
)
1741 if (GET_CODE (DECL_RTL (decl
)) != MEM
1742 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
1746 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
1747 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1748 TREE_PUBLIC (decl
) ? 'F' : 'f');
1750 current_sym_code
= N_FUN
;
1751 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1753 if (TREE_TYPE (type
))
1754 dbxout_type (TREE_TYPE (type
), 0, 0);
1756 dbxout_type (void_type_node
, 0, 0);
1758 /* For a nested function, when that function is compiled,
1759 mention the containing function name
1760 as well as (since dbx wants it) our own assembler-name. */
1762 fprintf (asmfile
, ",%s,%s",
1763 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1764 IDENTIFIER_POINTER (DECL_NAME (context
)));
1766 dbxout_finish_symbol (decl
);
1771 /* This seems all wrong. Outputting most kinds of types gives no name
1772 at all. A true definition gives no name; a cross-ref for a
1773 structure can give the tag name, but not a type name.
1774 It seems that no typedef name is defined by outputting a type. */
1776 /* If this typedef name was defined by outputting the type,
1777 don't duplicate it. */
1778 if (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
== TYPE_DEFINED
1779 && TYPE_NAME (TREE_TYPE (decl
)) == decl
)
1782 /* Don't output the same typedef twice.
1783 And don't output what language-specific stuff doesn't want output. */
1784 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
1793 if (DECL_NAME (decl
))
1795 /* Nonzero means we must output a tag as well as a typedef. */
1798 /* Handle the case of a C++ structure or union
1799 where the TYPE_NAME is a TYPE_DECL
1800 which gives both a typedef name and a tag. */
1801 /* dbx requires the tag first and the typedef second. */
1802 if ((TREE_CODE (type
) == RECORD_TYPE
1803 || TREE_CODE (type
) == UNION_TYPE
1804 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1805 && TYPE_NAME (type
) == decl
1806 && !(use_gnu_debug_info_extensions
&& have_used_extensions
)
1807 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
1808 /* Distinguish the implicit typedefs of C++
1809 from explicit ones that might be found in C. */
1810 && DECL_ARTIFICIAL (decl
))
1812 tree name
= TYPE_NAME (type
);
1813 if (TREE_CODE (name
) == TYPE_DECL
)
1814 name
= DECL_NAME (name
);
1816 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1817 current_sym_value
= 0;
1818 current_sym_addr
= 0;
1819 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1821 fprintf (asmfile
, "%s \"%s:T", ASM_STABS_OP
,
1822 IDENTIFIER_POINTER (name
));
1823 dbxout_type (type
, 1, 0);
1824 dbxout_finish_symbol (NULL_TREE
);
1827 /* Output typedef name. */
1828 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
,
1829 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1831 /* Short cut way to output a tag also. */
1832 if ((TREE_CODE (type
) == RECORD_TYPE
1833 || TREE_CODE (type
) == UNION_TYPE
1834 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1835 && TYPE_NAME (type
) == decl
1836 /* Distinguish the implicit typedefs of C++
1837 from explicit ones that might be found in C. */
1838 && DECL_ARTIFICIAL (decl
))
1840 if (use_gnu_debug_info_extensions
&& have_used_extensions
)
1842 putc ('T', asmfile
);
1843 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
1845 #if 0 /* Now we generate the tag for this case up above. */
1851 putc ('t', asmfile
);
1852 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1854 dbxout_type (type
, 1, 0);
1855 dbxout_finish_symbol (decl
);
1859 /* Don't output a tag if this is an incomplete type (TYPE_SIZE is
1860 zero). This prevents the sun4 Sun OS 4.x dbx from crashing. */
1862 if (tag_needed
&& TYPE_NAME (type
) != 0
1863 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
1864 || (DECL_NAME (TYPE_NAME (type
)) != 0))
1865 && TYPE_SIZE (type
) != 0
1866 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1868 /* For a TYPE_DECL with no name, but the type has a name,
1870 This is what represents `struct foo' with no typedef. */
1871 /* In C++, the name of a type is the corresponding typedef.
1872 In C, it is an IDENTIFIER_NODE. */
1873 tree name
= TYPE_NAME (type
);
1874 if (TREE_CODE (name
) == TYPE_DECL
)
1875 name
= DECL_NAME (name
);
1877 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1878 current_sym_value
= 0;
1879 current_sym_addr
= 0;
1880 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1882 fprintf (asmfile
, "%s \"%s:T", ASM_STABS_OP
,
1883 IDENTIFIER_POINTER (name
));
1884 dbxout_type (type
, 1, 0);
1885 dbxout_finish_symbol (NULL_TREE
);
1889 /* If an enum type has no name, it cannot be referred to,
1890 but we must output it anyway, since the enumeration constants
1891 can be referred to. */
1892 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
1894 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1895 current_sym_value
= 0;
1896 current_sym_addr
= 0;
1897 current_sym_nchars
= 2;
1899 /* Some debuggers fail when given NULL names, so give this a
1900 harmless name of ` '. */
1901 fprintf (asmfile
, "%s \" :T", ASM_STABS_OP
);
1902 dbxout_type (type
, 1, 0);
1903 dbxout_finish_symbol (NULL_TREE
);
1906 /* Prevent duplicate output of a typedef. */
1907 TREE_ASM_WRITTEN (decl
) = 1;
1912 /* Parm decls go in their own separate chains
1913 and are output by dbxout_reg_parms and dbxout_parms. */
1917 /* Named return value, treat like a VAR_DECL. */
1919 if (DECL_RTL (decl
) == 0)
1921 /* Don't mention a variable that is external.
1922 Let the file that defines it describe it. */
1923 if (DECL_EXTERNAL (decl
))
1926 /* If the variable is really a constant
1927 and not written in memory, inform the debugger. */
1928 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
1929 && DECL_INITIAL (decl
) != 0
1930 && ! TREE_ASM_WRITTEN (decl
)
1931 && (DECL_FIELD_CONTEXT (decl
) == NULL_TREE
1932 || TREE_CODE (DECL_FIELD_CONTEXT (decl
)) == BLOCK
))
1934 if (TREE_PUBLIC (decl
) == 0)
1936 /* The sun4 assembler does not grok this. */
1937 const char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1938 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
1939 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
1941 HOST_WIDE_INT ival
= TREE_INT_CST_LOW (DECL_INITIAL (decl
));
1942 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1943 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile
, name
, ival
);
1945 fprintf (asmfile
, "%s \"%s:c=i", ASM_STABS_OP
, name
);
1947 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, ival
);
1948 fprintf (asmfile
, "\",0x%x,0,0,0\n", N_LSYM
);
1952 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
1954 /* don't know how to do this yet. */
1958 /* else it is something we handle like a normal variable. */
1961 DECL_RTL (decl
) = eliminate_regs (DECL_RTL (decl
), 0, NULL_RTX
);
1962 #ifdef LEAF_REG_REMAP
1963 if (current_function_uses_only_leaf_regs
)
1964 leaf_renumber_regs_insn (DECL_RTL (decl
));
1967 dbxout_symbol_location (decl
, type
, 0, DECL_RTL (decl
));
1975 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1976 Add SUFFIX to its name, if SUFFIX is not 0.
1977 Describe the variable as residing in HOME
1978 (usually HOME is DECL_RTL (DECL), but not always). */
1981 dbxout_symbol_location (decl
, type
, suffix
, home
)
1989 /* Don't mention a variable at all
1990 if it was completely optimized into nothingness.
1992 If the decl was from an inline function, then its rtl
1993 is not identically the rtl that was used in this
1994 particular compilation. */
1995 if (GET_CODE (home
) == REG
)
1997 regno
= REGNO (home
);
1998 if (regno
>= FIRST_PSEUDO_REGISTER
)
2001 else if (GET_CODE (home
) == SUBREG
)
2005 while (GET_CODE (value
) == SUBREG
)
2007 offset
+= SUBREG_WORD (value
);
2008 value
= SUBREG_REG (value
);
2010 if (GET_CODE (value
) == REG
)
2012 regno
= REGNO (value
);
2013 if (regno
>= FIRST_PSEUDO_REGISTER
)
2017 alter_subreg (home
);
2020 /* The kind-of-variable letter depends on where
2021 the variable is and on the scope of its name:
2022 G and N_GSYM for static storage and global scope,
2023 S for static storage and file scope,
2024 V for static storage and local scope,
2025 for those two, use N_LCSYM if data is in bss segment,
2026 N_STSYM if in data segment, N_FUN otherwise.
2027 (We used N_FUN originally, then changed to N_STSYM
2028 to please GDB. However, it seems that confused ld.
2029 Now GDB has been fixed to like N_FUN, says Kingdon.)
2030 no letter at all, and N_LSYM, for auto variable,
2031 r and N_RSYM for register variable. */
2033 if (GET_CODE (home
) == MEM
2034 && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2036 if (TREE_PUBLIC (decl
))
2039 current_sym_code
= N_GSYM
;
2043 current_sym_addr
= XEXP (home
, 0);
2045 letter
= decl_function_context (decl
) ? 'V' : 'S';
2047 /* This should be the same condition as in assemble_variable, but
2048 we don't have access to dont_output_data here. So, instead,
2049 we rely on the fact that error_mark_node initializers always
2050 end up in bss for C++ and never end up in bss for C. */
2051 if (DECL_INITIAL (decl
) == 0
2052 || (!strcmp (lang_identify (), "cplusplus")
2053 && DECL_INITIAL (decl
) == error_mark_node
))
2054 current_sym_code
= N_LCSYM
;
2055 else if (DECL_IN_TEXT_SECTION (decl
))
2056 /* This is not quite right, but it's the closest
2057 of all the codes that Unix defines. */
2058 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
2061 /* Ultrix `as' seems to need this. */
2062 #ifdef DBX_STATIC_STAB_DATA_SECTION
2065 current_sym_code
= N_STSYM
;
2069 else if (regno
>= 0)
2072 current_sym_code
= N_RSYM
;
2073 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
2075 else if (GET_CODE (home
) == MEM
2076 && (GET_CODE (XEXP (home
, 0)) == MEM
2077 || (GET_CODE (XEXP (home
, 0)) == REG
2078 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
2079 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
2080 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2081 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
2084 /* If the value is indirect by memory or by a register
2085 that isn't the frame pointer
2086 then it means the object is variable-sized and address through
2087 that register or stack slot. DBX has no way to represent this
2088 so all we can do is output the variable as a pointer.
2089 If it's not a parameter, ignore it.
2090 (VAR_DECLs like this can be made by integrate.c.) */
2092 if (GET_CODE (XEXP (home
, 0)) == REG
)
2095 current_sym_code
= N_RSYM
;
2096 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
2100 current_sym_code
= N_LSYM
;
2101 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2102 We want the value of that CONST_INT. */
2104 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
2107 /* Effectively do build_pointer_type, but don't cache this type,
2108 since it might be temporary whereas the type it points to
2109 might have been saved for inlining. */
2110 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2111 type
= make_node (POINTER_TYPE
);
2112 TREE_TYPE (type
) = TREE_TYPE (decl
);
2114 else if (GET_CODE (home
) == MEM
2115 && GET_CODE (XEXP (home
, 0)) == REG
)
2117 current_sym_code
= N_LSYM
;
2118 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2120 else if (GET_CODE (home
) == MEM
2121 && GET_CODE (XEXP (home
, 0)) == PLUS
2122 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
2124 current_sym_code
= N_LSYM
;
2125 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2126 We want the value of that CONST_INT. */
2127 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2129 else if (GET_CODE (home
) == MEM
2130 && GET_CODE (XEXP (home
, 0)) == CONST
)
2132 /* Handle an obscure case which can arise when optimizing and
2133 when there are few available registers. (This is *always*
2134 the case for i386/i486 targets). The RTL looks like
2135 (MEM (CONST ...)) even though this variable is a local `auto'
2136 or a local `register' variable. In effect, what has happened
2137 is that the reload pass has seen that all assignments and
2138 references for one such a local variable can be replaced by
2139 equivalent assignments and references to some static storage
2140 variable, thereby avoiding the need for a register. In such
2141 cases we're forced to lie to debuggers and tell them that
2142 this variable was itself `static'. */
2143 current_sym_code
= N_LCSYM
;
2145 current_sym_addr
= XEXP (XEXP (home
, 0), 0);
2147 else if (GET_CODE (home
) == CONCAT
)
2149 tree subtype
= TREE_TYPE (type
);
2151 /* If the variable's storage is in two parts,
2152 output each as a separate stab with a modified name. */
2153 if (WORDS_BIG_ENDIAN
)
2154 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
2156 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
2158 /* Cast avoids warning in old compilers. */
2159 current_sym_code
= (STAB_CODE_TYPE
) 0;
2160 current_sym_value
= 0;
2161 current_sym_addr
= 0;
2162 dbxout_prepare_symbol (decl
);
2164 if (WORDS_BIG_ENDIAN
)
2165 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
2167 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
2171 /* Address might be a MEM, when DECL is a variable-sized object.
2172 Or it might be const0_rtx, meaning previous passes
2173 want us to ignore this variable. */
2176 /* Ok, start a symtab entry and output the variable name. */
2179 #ifdef DBX_STATIC_BLOCK_START
2180 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
2183 dbxout_symbol_name (decl
, suffix
, letter
);
2184 dbxout_type (type
, 0, 0);
2185 dbxout_finish_symbol (decl
);
2187 #ifdef DBX_STATIC_BLOCK_END
2188 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
2192 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2193 Then output LETTER to indicate the kind of location the symbol has. */
2196 dbxout_symbol_name (decl
, suffix
, letter
)
2201 /* One slight hitch: if this is a VAR_DECL which is a static
2202 class member, we must put out the mangled name instead of the
2203 DECL_NAME. Note also that static member (variable) names DO NOT begin
2204 with underscores in .stabs directives. */
2205 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2208 fprintf (asmfile
, "%s \"%s%s:", ASM_STABS_OP
, name
,
2209 (suffix
? suffix
: ""));
2211 if (letter
) putc (letter
, asmfile
);
2215 dbxout_prepare_symbol (decl
)
2216 tree decl ATTRIBUTE_UNUSED
;
2219 const char *filename
= DECL_SOURCE_FILE (decl
);
2221 dbxout_source_file (asmfile
, filename
);
2226 dbxout_finish_symbol (sym
)
2229 #ifdef DBX_FINISH_SYMBOL
2230 DBX_FINISH_SYMBOL (sym
);
2233 if (use_gnu_debug_info_extensions
&& sym
!= 0)
2234 line
= DECL_SOURCE_LINE (sym
);
2236 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
2237 if (current_sym_addr
)
2238 output_addr_const (asmfile
, current_sym_addr
);
2240 fprintf (asmfile
, "%d", current_sym_value
);
2241 putc ('\n', asmfile
);
2245 /* Output definitions of all the decls in a chain. */
2253 dbxout_symbol (syms
, 1);
2254 syms
= TREE_CHAIN (syms
);
2258 /* The following two functions output definitions of function parameters.
2259 Each parameter gets a definition locating it in the parameter list.
2260 Each parameter that is a register variable gets a second definition
2261 locating it in the register.
2263 Printing or argument lists in gdb uses the definitions that
2264 locate in the parameter list. But reference to the variable in
2265 expressions uses preferentially the definition as a register. */
2267 /* Output definitions, referring to storage in the parmlist,
2268 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2271 dbxout_parms (parms
)
2274 for (; parms
; parms
= TREE_CHAIN (parms
))
2275 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
2277 dbxout_prepare_symbol (parms
);
2279 /* Perform any necessary register eliminations on the parameter's rtl,
2280 so that the debugging output will be accurate. */
2281 DECL_INCOMING_RTL (parms
)
2282 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
2283 DECL_RTL (parms
) = eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
);
2284 #ifdef LEAF_REG_REMAP
2285 if (current_function_uses_only_leaf_regs
)
2287 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
2288 leaf_renumber_regs_insn (DECL_RTL (parms
));
2292 if (PARM_PASSED_IN_MEMORY (parms
))
2294 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
2296 /* ??? Here we assume that the parm address is indexed
2297 off the frame pointer or arg pointer.
2298 If that is not true, we produce meaningless results,
2299 but do not crash. */
2300 if (GET_CODE (addr
) == PLUS
2301 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
2302 current_sym_value
= INTVAL (XEXP (addr
, 1));
2304 current_sym_value
= 0;
2306 current_sym_code
= N_PSYM
;
2307 current_sym_addr
= 0;
2310 if (DECL_NAME (parms
))
2312 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2314 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2315 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2316 DBX_MEMPARM_STABS_LETTER
);
2320 current_sym_nchars
= 8;
2321 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2322 DBX_MEMPARM_STABS_LETTER
);
2325 /* It is quite tempting to use:
2327 dbxout_type (TREE_TYPE (parms), 0, 0);
2329 as the next statement, rather than using DECL_ARG_TYPE(), so
2330 that gcc reports the actual type of the parameter, rather
2331 than the promoted type. This certainly makes GDB's life
2332 easier, at least for some ports. The change is a bad idea
2333 however, since GDB expects to be able access the type without
2334 performing any conversions. So for example, if we were
2335 passing a float to an unprototyped function, gcc will store a
2336 double on the stack, but if we emit a stab saying the type is a
2337 float, then gdb will only read in a single value, and this will
2338 produce an erropneous value. */
2339 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
2340 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
2341 dbxout_finish_symbol (parms
);
2343 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
2346 char regparm_letter
;
2348 /* Parm passed in registers and lives in registers or nowhere. */
2350 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2351 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2352 current_sym_addr
= 0;
2354 /* If parm lives in a register, use that register;
2355 pretend the parm was passed there. It would be more consistent
2356 to describe the register where the parm was passed,
2357 but in practice that register usually holds something else.
2359 If we use DECL_RTL, then we must use the declared type of
2360 the variable, not the type that it arrived in. */
2361 if (REGNO (DECL_RTL (parms
)) >= 0
2362 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2364 best_rtl
= DECL_RTL (parms
);
2365 parm_type
= TREE_TYPE (parms
);
2367 /* If the parm lives nowhere, use the register where it was
2368 passed. It is also better to use the declared type here. */
2371 best_rtl
= DECL_INCOMING_RTL (parms
);
2372 parm_type
= TREE_TYPE (parms
);
2374 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
2377 if (DECL_NAME (parms
))
2379 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2380 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2381 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2386 current_sym_nchars
= 8;
2387 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2391 dbxout_type (parm_type
, 0, 0);
2392 dbxout_finish_symbol (parms
);
2394 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2395 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
2396 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
2397 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
2398 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2399 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
2403 /* Parm was passed via invisible reference.
2404 That is, its address was passed in a register.
2405 Output it as if it lived in that register.
2406 The debugger will know from the type
2407 that it was actually passed by invisible reference. */
2409 char regparm_letter
;
2410 /* Parm passed in registers and lives in registers or nowhere. */
2412 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2413 if (use_gnu_debug_info_extensions
)
2414 regparm_letter
= GDB_INV_REF_REGPARM_STABS_LETTER
;
2416 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2418 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2419 If it is an unallocated pseudo-reg, then use the register where
2420 it was passed instead. */
2421 if (REGNO (XEXP (DECL_RTL (parms
), 0)) >= 0
2422 && REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
2423 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
2425 current_sym_value
= REGNO (DECL_INCOMING_RTL (parms
));
2427 current_sym_addr
= 0;
2430 if (DECL_NAME (parms
))
2432 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2434 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2435 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2440 current_sym_nchars
= 8;
2441 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2445 dbxout_type (TREE_TYPE (parms
), 0, 0);
2446 dbxout_finish_symbol (parms
);
2448 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2449 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
2450 /* ??? A constant address for a parm can happen
2451 when the reg it lives in is equiv to a constant in memory.
2452 Should make this not happen, after 2.4. */
2453 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
2455 /* Parm was passed in registers but lives on the stack. */
2456 int aux_sym_value
= 0;
2458 current_sym_code
= N_PSYM
;
2459 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2460 in which case we want the value of that CONST_INT,
2461 or (MEM (REG ...)) or (MEM (MEM ...)),
2462 in which case we use a value of zero. */
2463 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
)
2464 current_sym_value
= 0;
2465 else if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
2467 /* Remember the location on the stack the parm is moved to */
2469 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
2470 current_sym_value
= 0;
2474 = INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
2476 current_sym_addr
= 0;
2478 /* Make a big endian correction if the mode of the type of the
2479 parameter is not the same as the mode of the rtl. */
2480 if (BYTES_BIG_ENDIAN
2481 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
2482 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
2484 current_sym_value
+= UNITS_PER_WORD
- GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
)));
2488 if (DECL_NAME (parms
))
2491 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2493 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2494 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2495 DBX_MEMPARM_STABS_LETTER
);
2499 current_sym_nchars
= 8;
2500 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2501 DBX_MEMPARM_STABS_LETTER
);
2505 = DEBUGGER_ARG_OFFSET (current_sym_value
,
2506 XEXP (DECL_RTL (parms
), 0));
2507 dbxout_type (TREE_TYPE (parms
), 0, 0);
2508 dbxout_finish_symbol (parms
);
2509 if (aux_sym_value
!= 0)
2511 /* Generate an entry for the stack location */
2513 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
,
2514 IDENTIFIER_POINTER (DECL_NAME (parms
)));
2515 current_sym_value
= aux_sym_value
;
2516 current_sym_code
= N_LSYM
;
2517 dbxout_type (build_reference_type (TREE_TYPE (parms
)), 0, 0);
2518 dbxout_finish_symbol (parms
);
2524 /* Output definitions for the places where parms live during the function,
2525 when different from where they were passed, when the parms were passed
2528 It is not useful to do this for parms passed in registers
2529 that live during the function in different registers, because it is
2530 impossible to look in the passed register for the passed value,
2531 so we use the within-the-function register to begin with.
2533 PARMS is a chain of PARM_DECL nodes. */
2536 dbxout_reg_parms (parms
)
2539 for (; parms
; parms
= TREE_CHAIN (parms
))
2540 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
2542 dbxout_prepare_symbol (parms
);
2544 /* Report parms that live in registers during the function
2545 but were passed in memory. */
2546 if (GET_CODE (DECL_RTL (parms
)) == REG
2547 && REGNO (DECL_RTL (parms
)) >= 0
2548 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2549 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2550 0, DECL_RTL (parms
));
2551 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
2552 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2553 0, DECL_RTL (parms
));
2554 /* Report parms that live in memory but not where they were passed. */
2555 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2556 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
2557 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2558 0, DECL_RTL (parms
));
2562 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2563 output definitions of those names, in raw form */
2571 putc (',', asmfile
);
2572 dbxout_type (TREE_VALUE (args
), 0, 0);
2574 args
= TREE_CHAIN (args
);
2578 /* Given a chain of ..._TYPE nodes,
2579 find those which have typedef names and output those names.
2580 This is to ensure those types get output. */
2583 dbxout_types (types
)
2584 register tree types
;
2588 if (TYPE_NAME (types
)
2589 && TREE_CODE (TYPE_NAME (types
)) == TYPE_DECL
2590 && ! TREE_ASM_WRITTEN (TYPE_NAME (types
)))
2591 dbxout_symbol (TYPE_NAME (types
), 1);
2592 types
= TREE_CHAIN (types
);
2596 /* Output everything about a symbol block (a BLOCK node
2597 that represents a scope level),
2598 including recursive output of contained blocks.
2600 BLOCK is the BLOCK node.
2601 DEPTH is its depth within containing symbol blocks.
2602 ARGS is usually zero; but for the outermost block of the
2603 body of a function, it is a chain of PARM_DECLs for the function parameters.
2604 We output definitions of all the register parms
2605 as if they were local variables of that block.
2607 If -g1 was used, we count blocks just the same, but output nothing
2608 except for the outermost block.
2610 Actually, BLOCK may be several blocks chained together.
2611 We handle them all in sequence. */
2614 dbxout_block (block
, depth
, args
)
2615 register tree block
;
2623 /* Ignore blocks never expanded or otherwise marked as real. */
2624 if (TREE_USED (block
))
2626 #ifndef DBX_LBRAC_FIRST
2627 /* In dbx format, the syms of a block come before the N_LBRAC. */
2628 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2629 dbxout_syms (BLOCK_VARS (block
));
2631 dbxout_reg_parms (args
);
2634 /* Now output an N_LBRAC symbol to represent the beginning of
2635 the block. Use the block's tree-walk order to generate
2636 the assembler symbols LBBn and LBEn
2637 that final will define around the code in this block. */
2638 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2641 blocknum
= next_block_number
++;
2642 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
2644 if (BLOCK_HANDLER_BLOCK (block
))
2646 /* A catch block. Must precede N_LBRAC. */
2647 tree decl
= BLOCK_VARS (block
);
2650 #ifdef DBX_OUTPUT_CATCH
2651 DBX_OUTPUT_CATCH (asmfile
, decl
, buf
);
2653 fprintf (asmfile
, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP
,
2654 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
2655 assemble_name (asmfile
, buf
);
2656 fprintf (asmfile
, "\n");
2658 decl
= TREE_CHAIN (decl
);
2662 #ifdef DBX_OUTPUT_LBRAC
2663 DBX_OUTPUT_LBRAC (asmfile
, buf
);
2665 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_LBRAC
);
2666 assemble_name (asmfile
, buf
);
2667 #if DBX_BLOCKS_FUNCTION_RELATIVE
2668 fputc ('-', asmfile
);
2669 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
2671 fprintf (asmfile
, "\n");
2675 /* Count blocks the same way regardless of debug_info_level. */
2676 next_block_number
++;
2678 #ifdef DBX_LBRAC_FIRST
2679 /* On some weird machines, the syms of a block
2680 come after the N_LBRAC. */
2681 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2682 dbxout_syms (BLOCK_VARS (block
));
2684 dbxout_reg_parms (args
);
2687 /* Output the subblocks. */
2688 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
2690 /* Refer to the marker for the end of the block. */
2691 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2694 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
2695 #ifdef DBX_OUTPUT_RBRAC
2696 DBX_OUTPUT_RBRAC (asmfile
, buf
);
2698 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_RBRAC
);
2699 assemble_name (asmfile
, buf
);
2700 #if DBX_BLOCKS_FUNCTION_RELATIVE
2701 fputc ('-', asmfile
);
2702 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
2704 fprintf (asmfile
, "\n");
2708 block
= BLOCK_CHAIN (block
);
2712 /* Output the information about a function and its arguments and result.
2713 Usually this follows the function's code,
2714 but on some systems, it comes before. */
2717 dbxout_really_begin_function (decl
)
2720 dbxout_symbol (decl
, 0);
2721 dbxout_parms (DECL_ARGUMENTS (decl
));
2722 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
2723 dbxout_symbol (DECL_RESULT (decl
), 1);
2726 /* Called at beginning of output of function definition. */
2729 dbxout_begin_function (decl
)
2730 tree decl ATTRIBUTE_UNUSED
;
2732 #ifdef DBX_FUNCTION_FIRST
2733 dbxout_really_begin_function (decl
);
2737 /* Output dbx data for a function definition.
2738 This includes a definition of the function name itself (a symbol),
2739 definitions of the parameters (locating them in the parameter list)
2740 and then output the block that makes up the function's body
2741 (including all the auto variables of the function). */
2744 dbxout_function (decl
)
2747 #ifndef DBX_FUNCTION_FIRST
2748 dbxout_really_begin_function (decl
);
2750 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
2751 #ifdef DBX_OUTPUT_FUNCTION_END
2752 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
2754 #if defined(ASM_OUTPUT_SECTION_NAME)
2755 if (use_gnu_debug_info_extensions
2756 #if defined(NO_DBX_FUNCTION_END)
2757 && ! NO_DBX_FUNCTION_END
2760 dbxout_function_end ();
2763 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */