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. */
84 #ifdef XCOFF_DEBUGGING_INFO
89 #define ASM_STABS_OP ".stabs"
93 #define ASM_STABN_OP ".stabn"
96 #ifndef DBX_TYPE_DECL_STABS_CODE
97 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
100 #ifndef DBX_STATIC_CONST_VAR_CODE
101 #define DBX_STATIC_CONST_VAR_CODE N_FUN
104 #ifndef DBX_REGPARM_STABS_CODE
105 #define DBX_REGPARM_STABS_CODE N_RSYM
108 #ifndef DBX_REGPARM_STABS_LETTER
109 #define DBX_REGPARM_STABS_LETTER 'P'
112 /* This is used for parameters passed by invisible reference in a register. */
113 #ifndef GDB_INV_REF_REGPARM_STABS_LETTER
114 #define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
117 #ifndef DBX_MEMPARM_STABS_LETTER
118 #define DBX_MEMPARM_STABS_LETTER 'p'
121 #ifndef FILE_NAME_JOINER
122 #define FILE_NAME_JOINER "/"
125 /* Nonzero means if the type has methods, only output debugging
126 information if methods are actually written to the asm file. This
127 optimization only works if the debugger can detect the special C++
130 #define MINIMAL_DEBUG 1
132 #ifdef NO_DOLLAR_IN_LABEL
133 #ifdef NO_DOT_IN_LABEL
135 #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 char *lastfile
;
213 /* Current working directory. */
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 void dbxout_types ();
324 void dbxout_symbol ();
326 #if defined(ASM_OUTPUT_SECTION_NAME)
327 static void dbxout_function_end
PROTO((void));
329 static void dbxout_typedefs
PROTO((tree
));
330 static void dbxout_type_index
PROTO((tree
));
331 #if DBX_CONTIN_LENGTH > 0
332 static void dbxout_continue
PROTO((void));
334 static void dbxout_type_fields
PROTO((tree
));
335 static void dbxout_type_method_1
PROTO((tree
, char *));
336 static void dbxout_type_methods
PROTO((tree
));
337 static void dbxout_range_type
PROTO((tree
));
338 static void dbxout_type
PROTO((tree
, int, int));
339 static void print_int_cst_octal
PROTO((tree
));
340 static void print_octal
PROTO((unsigned HOST_WIDE_INT
, int));
341 static void dbxout_type_name
PROTO((tree
));
342 static void dbxout_symbol_location
PROTO((tree
, tree
, char *, rtx
));
343 static void dbxout_symbol_name
PROTO((tree
, char *, int));
344 static void dbxout_prepare_symbol
PROTO((tree
));
345 static void dbxout_finish_symbol
PROTO((tree
));
346 static void dbxout_block
PROTO((tree
, int, tree
));
347 static void dbxout_really_begin_function
PROTO((tree
));
349 #if defined(ASM_OUTPUT_SECTION_NAME)
351 dbxout_function_end ()
353 static int scope_labelno
= 0;
354 char lscope_label_name
[100];
355 /* Convert Ltext into the appropriate format for local labels in case
356 the system doesn't insert underscores in front of user generated
358 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
359 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Lscope", scope_labelno
);
362 /* By convention, GCC will mark the end of a function with an N_FUN
363 symbol and an empty string. */
364 fprintf (asmfile
, "%s \"\",%d,0,0,", ASM_STABS_OP
, N_FUN
);
365 assemble_name (asmfile
, lscope_label_name
);
366 fputc ('-', asmfile
);
367 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
368 fprintf (asmfile
, "\n");
370 #endif /* ! NO_DBX_FUNCTION_END */
372 /* At the beginning of compilation, start writing the symbol table.
373 Initialize `typevec' and output the standard data types of C. */
376 dbxout_init (asm_file
, input_file_name
, syms
)
378 char *input_file_name
;
381 char ltext_label_name
[100];
386 typevec
= (struct typeinfo
*) xmalloc (typevec_len
* sizeof typevec
[0]);
387 bzero ((char *) typevec
, typevec_len
* sizeof typevec
[0]);
389 /* Convert Ltext into the appropriate format for local labels in case
390 the system doesn't insert underscores in front of user generated
392 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
394 /* Put the current working directory in an N_SO symbol. */
395 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
396 but GDB always does. */
397 if (use_gnu_debug_info_extensions
)
400 if (!cwd
&& (cwd
= getpwd ()) && (!*cwd
|| cwd
[strlen (cwd
) - 1] != '/'))
402 char *wdslash
= xmalloc (strlen (cwd
) + sizeof (FILE_NAME_JOINER
));
403 sprintf (wdslash
, "%s%s", cwd
, FILE_NAME_JOINER
);
408 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
409 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile
, cwd
);
410 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
411 fprintf (asmfile
, "%s ", ASM_STABS_OP
);
412 output_quoted_string (asmfile
, cwd
);
413 fprintf (asmfile
, ",%d,0,0,%s\n", N_SO
, <ext_label_name
[1]);
414 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
418 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
419 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
420 would give us an N_SOL, and we want an N_SO. */
421 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile
, input_file_name
);
422 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
423 /* We include outputting `Ltext:' here,
424 because that gives you a way to override it. */
425 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
426 fprintf (asmfile
, "%s ", ASM_STABS_OP
);
427 output_quoted_string (asmfile
, input_file_name
);
428 fprintf (asmfile
, ",%d,0,0,%s\n",
429 N_SO
, <ext_label_name
[1]);
431 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Ltext", 0);
432 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
434 /* Possibly output something to inform GDB that this compilation was by
435 GCC. It's easier for GDB to parse it when after the N_SO's. This
436 is used in Solaris 2. */
437 #ifdef ASM_IDENTIFY_GCC_AFTER_SOURCE
438 ASM_IDENTIFY_GCC_AFTER_SOURCE (asmfile
);
441 lastfile
= input_file_name
;
443 next_type_number
= 1;
444 next_block_number
= 2;
447 current_file
= (struct dbx_file
*) xmalloc (sizeof *current_file
);
448 current_file
->next
= NULL
;
449 current_file
->file_number
= 0;
450 current_file
->next_type_number
= 1;
451 next_file_number
= 1;
454 /* Make sure that types `int' and `char' have numbers 1 and 2.
455 Definitions of other integer types will refer to those numbers.
456 (Actually it should no longer matter what their numbers are.
457 Also, if any types with tags have been defined, dbxout_symbol
458 will output them first, so the numbers won't be 1 and 2. That
459 happens in C++. So it's a good thing it should no longer matter). */
461 #ifdef DBX_OUTPUT_STANDARD_TYPES
462 DBX_OUTPUT_STANDARD_TYPES (syms
);
464 dbxout_symbol (TYPE_NAME (integer_type_node
), 0);
465 dbxout_symbol (TYPE_NAME (char_type_node
), 0);
468 /* Get all permanent types that have typedef names,
469 and output them all, except for those already output. */
471 dbxout_typedefs (syms
);
474 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
475 in the reverse order from that which is found in SYMS. */
478 dbxout_typedefs (syms
)
483 dbxout_typedefs (TREE_CHAIN (syms
));
484 if (TREE_CODE (syms
) == TYPE_DECL
)
486 tree type
= TREE_TYPE (syms
);
488 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
489 && TYPE_SIZE (type
) != NULL_TREE
490 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
491 dbxout_symbol (TYPE_NAME (type
), 0);
496 /* Change to reading from a new source file. Generate a N_BINCL stab. */
499 dbxout_start_new_source_file (filename
)
500 char *filename ATTRIBUTE_UNUSED
;
503 struct dbx_file
*n
= (struct dbx_file
*) xmalloc (sizeof *n
);
505 n
->next
= current_file
;
506 n
->file_number
= next_file_number
++;
507 n
->next_type_number
= 1;
509 fprintf (asmfile
, "%s ", ASM_STABS_OP
);
510 output_quoted_string (asmfile
, filename
);
511 fprintf (asmfile
, ",%d,0,0,0\n", N_BINCL
);
515 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
518 dbxout_resume_previous_source_file ()
521 struct dbx_file
*next
;
523 fprintf (asmfile
, "%s %d,0,0,0\n", ASM_STABN_OP
, N_EINCL
);
524 next
= current_file
->next
;
530 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
533 dbxout_source_file (file
, filename
)
537 char ltext_label_name
[100];
539 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
541 #ifdef DBX_OUTPUT_SOURCE_FILENAME
542 DBX_OUTPUT_SOURCE_FILENAME (file
, filename
);
544 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext",
545 source_label_number
);
546 fprintf (file
, "%s ", ASM_STABS_OP
);
547 output_quoted_string (file
, filename
);
548 fprintf (file
, ",%d,0,0,%s\n", N_SOL
, <ext_label_name
[1]);
549 if (current_function_decl
!= NULL_TREE
550 && DECL_SECTION_NAME (current_function_decl
) != NULL_TREE
)
551 ; /* Don't change section amid function. */
554 ASM_OUTPUT_INTERNAL_LABEL (file
, "Ltext", source_label_number
);
555 source_label_number
++;
561 /* Output a line number symbol entry into output stream FILE,
562 for source file FILENAME and line number LINENO. */
565 dbxout_source_line (file
, filename
, lineno
)
570 dbxout_source_file (file
, filename
);
572 #ifdef ASM_OUTPUT_SOURCE_LINE
573 ASM_OUTPUT_SOURCE_LINE (file
, lineno
);
575 fprintf (file
, "\t%s %d,0,%d\n", ASM_STABD_OP
, N_SLINE
, lineno
);
579 /* At the end of compilation, finish writing the symbol table.
580 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
584 dbxout_finish (file
, filename
)
585 FILE *file ATTRIBUTE_UNUSED
;
586 char *filename ATTRIBUTE_UNUSED
;
588 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
589 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file
, filename
);
590 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
593 /* Output the index of a type. */
596 dbxout_type_index (type
)
599 #ifndef DBX_USE_BINCL
600 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
603 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
604 fprintf (asmfile
, "(%d,%d)", t
->file_number
, t
->type_number
);
609 #if DBX_CONTIN_LENGTH > 0
610 /* Continue a symbol-description that gets too big.
611 End one symbol table entry with a double-backslash
612 and start a new one, eventually producing something like
613 .stabs "start......\\",code,0,value
614 .stabs "...rest",code,0,value */
619 #ifdef DBX_CONTIN_CHAR
620 fprintf (asmfile
, "%c", DBX_CONTIN_CHAR
);
622 fprintf (asmfile
, "\\\\");
624 dbxout_finish_symbol (NULL_TREE
);
625 fprintf (asmfile
, "%s \"", ASM_STABS_OP
);
626 current_sym_nchars
= 0;
628 #endif /* DBX_CONTIN_LENGTH > 0 */
630 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
631 This must be a separate function because anonymous unions require
635 dbxout_type_fields (type
)
639 /* Output the name, type, position (in bits), size (in bits) of each
641 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
643 /* Omit here local type decls until we know how to support them. */
644 if (TREE_CODE (tem
) == TYPE_DECL
)
646 /* Omit fields whose position or size are variable. */
647 else if (TREE_CODE (tem
) == FIELD_DECL
648 && (TREE_CODE (DECL_FIELD_BITPOS (tem
)) != INTEGER_CST
649 || TREE_CODE (DECL_SIZE (tem
)) != INTEGER_CST
))
651 /* Omit here the nameless fields that are used to skip bits. */
652 else if (DECL_IGNORED_P (tem
))
654 else if (TREE_CODE (tem
) != CONST_DECL
)
656 /* Continue the line if necessary,
657 but not before the first field. */
658 if (tem
!= TYPE_FIELDS (type
))
663 if (use_gnu_debug_info_extensions
664 && flag_minimal_debug
665 && TREE_CODE (tem
) == FIELD_DECL
666 && DECL_VIRTUAL_P (tem
)
667 && DECL_ASSEMBLER_NAME (tem
))
669 have_used_extensions
= 1;
670 CHARS (3 + IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (tem
)));
671 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
)), asmfile
);
672 dbxout_type (DECL_FCONTEXT (tem
), 0, 0);
673 fprintf (asmfile
, ":");
674 dbxout_type (TREE_TYPE (tem
), 0, 0);
675 fputc (',', asmfile
);
676 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
677 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem
)));
678 fputc (';', asmfile
);
684 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem
)));
685 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem
)));
689 fprintf (asmfile
, ":");
693 if (use_gnu_debug_info_extensions
694 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
695 || TREE_CODE (tem
) != FIELD_DECL
))
697 have_used_extensions
= 1;
699 putc ((TREE_PRIVATE (tem
) ? '0'
700 : TREE_PROTECTED (tem
) ? '1' : '2'),
705 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
706 && DECL_BIT_FIELD_TYPE (tem
))
707 ? DECL_BIT_FIELD_TYPE (tem
)
708 : TREE_TYPE (tem
), 0, 0);
710 if (TREE_CODE (tem
) == VAR_DECL
)
712 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
714 char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
));
715 have_used_extensions
= 1;
716 fprintf (asmfile
, ":%s;", name
);
717 CHARS (strlen (name
));
721 /* If TEM is non-static, GDB won't understand it. */
722 fprintf (asmfile
, ",0,0;");
725 else if (TREE_CODE (DECL_FIELD_BITPOS (tem
)) == INTEGER_CST
)
727 fputc (',', asmfile
);
728 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
729 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem
)));
730 fputc (',', asmfile
);
731 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
732 TREE_INT_CST_LOW (DECL_SIZE (tem
)));
733 fputc (';', asmfile
);
740 /* Subroutine of `dbxout_type_methods'. Output debug info about the
741 method described DECL. DEBUG_NAME is an encoding of the method's
742 type signature. ??? We may be able to do without DEBUG_NAME altogether
746 dbxout_type_method_1 (decl
, debug_name
)
752 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
754 else /* it's a METHOD_TYPE. */
756 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
757 /* A for normal functions.
758 B for `const' member functions.
759 C for `volatile' member functions.
760 D for `const volatile' member functions. */
761 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
763 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
766 if (DECL_VINDEX (decl
))
772 fprintf (asmfile
, ":%s;%c%c%c", debug_name
,
773 TREE_PRIVATE (decl
) ? '0' : TREE_PROTECTED (decl
) ? '1' : '2', c1
, c2
);
774 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
)) + 6
775 - (debug_name
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
776 if (DECL_VINDEX (decl
))
778 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
779 TREE_INT_CST_LOW (DECL_VINDEX (decl
)));
780 fputc (';', asmfile
);
781 dbxout_type (DECL_CONTEXT (decl
), 0, 0);
782 fprintf (asmfile
, ";");
787 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
791 dbxout_type_methods (type
)
794 /* C++: put out the method names and their parameter lists */
795 tree methods
= TYPE_METHODS (type
);
797 register tree fndecl
;
799 char formatted_type_identifier_length
[16];
800 register int type_identifier_length
;
802 if (methods
== NULL_TREE
)
805 type_encoding
= DECL_NAME (TYPE_NAME (type
));
808 /* C++: Template classes break some assumptions made by this code about
809 the class names, constructor names, and encodings for assembler
810 label names. For now, disable output of dbx info for them. */
812 char *ptr
= IDENTIFIER_POINTER (type_encoding
);
813 /* This should use index. (mrs) */
814 while (*ptr
&& *ptr
!= '<') ptr
++;
825 type_identifier_length
= IDENTIFIER_LENGTH (type_encoding
);
827 sprintf(formatted_type_identifier_length
, "%d", type_identifier_length
);
829 if (TREE_CODE (methods
) != TREE_VEC
)
831 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
832 fndecl
= TREE_VEC_ELT (methods
, 0);
834 fndecl
= TREE_VEC_ELT (methods
, 1);
838 tree name
= DECL_NAME (fndecl
);
841 /* Group together all the methods for the same operation.
842 These differ in the types of the arguments. */
843 for (last
= NULL_TREE
;
844 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
845 fndecl
= TREE_CHAIN (fndecl
))
846 /* Output the name of the field (after overloading), as
847 well as the name of the field before overloading, along
848 with its parameter list */
850 /* This is the "mangled" name of the method.
851 It encodes the argument types. */
852 char *debug_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
));
853 int show_arg_types
= 0;
859 if (DECL_IGNORED_P (fndecl
))
862 if (flag_minimal_debug
)
866 /* We can't optimize a method which uses an anonymous
867 class, because the debugger will not be able to
868 associate the arbitrary class name with the actual
870 #ifndef NO_DOLLAR_IN_LABEL
875 if (strchr (debug_name
, marker
))
877 /* Detect ordinary methods because their mangled names
878 start with the operation name. */
879 else if (!strncmp (IDENTIFIER_POINTER (name
), debug_name
,
880 IDENTIFIER_LENGTH (name
)))
882 debug_name
+= IDENTIFIER_LENGTH (name
);
883 if (debug_name
[0] == '_' && debug_name
[1] == '_')
885 char *method_name
= debug_name
+ 2;
886 char *length_ptr
= 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 char *ctor_name
= debug_name
+ 2;
904 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;");
1159 /* This used to check if the type's precision was more than
1160 HOST_BITS_PER_WIDE_INT. That is wrong since gdb uses a
1161 long (it has no concept of HOST_BITS_PER_WIDE_INT). */
1162 else if (use_gnu_debug_info_extensions
1163 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
1164 || TYPE_PRECISION (type
) >= HOST_BITS_PER_LONG
))
1166 /* This used to say `r1' and we used to take care
1167 to make sure that `int' was type number 1. */
1168 fprintf (asmfile
, "r");
1169 dbxout_type_index (integer_type_node
);
1170 fprintf (asmfile
, ";");
1171 print_int_cst_octal (TYPE_MIN_VALUE (type
));
1172 fprintf (asmfile
, ";");
1173 print_int_cst_octal (TYPE_MAX_VALUE (type
));
1174 fprintf (asmfile
, ";");
1176 else /* Output other integer types as subranges of `int'. */
1177 dbxout_range_type (type
);
1182 /* This used to say `r1' and we used to take care
1183 to make sure that `int' was type number 1. */
1184 fprintf (asmfile
, "r");
1185 dbxout_type_index (integer_type_node
);
1186 fputc (';', asmfile
);
1187 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1188 fputs (";0;", asmfile
);
1193 if (use_gnu_debug_info_extensions
)
1195 fputs ("@s", asmfile
);
1196 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1197 BITS_PER_UNIT
* int_size_in_bytes (type
));
1198 fputs (";-20;", asmfile
);
1202 /* Output the type `char' as a subrange of itself.
1203 That is what pcc seems to do. */
1204 fprintf (asmfile
, "r");
1205 dbxout_type_index (char_type_node
);
1206 fprintf (asmfile
, ";0;%d;", TREE_UNSIGNED (type
) ? 255 : 127);
1212 if (use_gnu_debug_info_extensions
)
1214 fputs ("@s", asmfile
);
1215 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1216 BITS_PER_UNIT
* int_size_in_bytes (type
));
1217 fputs (";-16;", asmfile
);
1219 else /* Define as enumeral type (False, True) */
1220 fprintf (asmfile
, "eFalse:0,True:1,;");
1225 putc ('d', asmfile
);
1227 dbxout_type (TREE_TYPE (type
), 0, 0);
1231 /* Differs from the REAL_TYPE by its new data type number */
1233 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1235 fprintf (asmfile
, "r");
1236 dbxout_type_index (type
);
1237 fputc (';', asmfile
);
1238 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1239 int_size_in_bytes (TREE_TYPE (type
)));
1240 fputs (";0;", asmfile
);
1241 CHARS (12); /* The number is probably incorrect here. */
1245 /* Output a complex integer type as a structure,
1246 pending some other way to do it. */
1247 fputc ('s', asmfile
);
1248 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1250 fprintf (asmfile
, "real:");
1252 dbxout_type (TREE_TYPE (type
), 0, 0);
1253 fprintf (asmfile
, ",%d,%d;",
1254 0, TYPE_PRECISION (TREE_TYPE (type
)));
1256 fprintf (asmfile
, "imag:");
1258 dbxout_type (TREE_TYPE (type
), 0, 0);
1259 fprintf (asmfile
, ",%d,%d;;",
1260 TYPE_PRECISION (TREE_TYPE (type
)),
1261 TYPE_PRECISION (TREE_TYPE (type
)));
1267 if (use_gnu_debug_info_extensions
)
1269 have_used_extensions
= 1;
1270 fputs ("@s", asmfile
);
1271 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1272 BITS_PER_UNIT
* int_size_in_bytes (type
));
1273 fputc (';', asmfile
);
1274 /* Check if a bitstring type, which in Chill is
1275 different from a [power]set. */
1276 if (TYPE_STRING_FLAG (type
))
1277 fprintf (asmfile
, "@S;");
1279 putc ('S', asmfile
);
1281 dbxout_type (TYPE_DOMAIN (type
), 0, 0);
1285 /* Make arrays of packed bits look like bitstrings for chill. */
1286 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
1288 have_used_extensions
= 1;
1289 fputs ("@s", asmfile
);
1290 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1291 BITS_PER_UNIT
* int_size_in_bytes (type
));
1292 fputc (';', asmfile
);
1293 fprintf (asmfile
, "@S;");
1294 putc ('S', asmfile
);
1296 dbxout_type (TYPE_DOMAIN (type
), 0, 0);
1299 /* Output "a" followed by a range type definition
1300 for the index type of the array
1301 followed by a reference to the target-type.
1302 ar1;0;N;M for a C array of type M and size N+1. */
1303 /* Check if a character string type, which in Chill is
1304 different from an array of characters. */
1305 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
1307 have_used_extensions
= 1;
1308 fprintf (asmfile
, "@S;");
1310 tem
= TYPE_DOMAIN (type
);
1313 fprintf (asmfile
, "ar");
1314 dbxout_type_index (integer_type_node
);
1315 fprintf (asmfile
, ";0;-1;");
1319 fprintf (asmfile
, "a");
1320 dbxout_range_type (tem
);
1323 dbxout_type (TREE_TYPE (type
), 0, 0);
1328 case QUAL_UNION_TYPE
:
1330 int i
, n_baseclasses
= 0;
1332 if (TYPE_BINFO (type
) != 0
1333 && TREE_CODE (TYPE_BINFO (type
)) == TREE_VEC
1334 && TYPE_BINFO_BASETYPES (type
) != 0)
1335 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
1337 /* Output a structure type. We must use the same test here as we
1338 use in the DBX_NO_XREFS case above. */
1339 if ((TYPE_NAME (type
) != 0
1340 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1341 && DECL_IGNORED_P (TYPE_NAME (type
)))
1343 || TYPE_SIZE (type
) == 0
1344 /* No way in DBX fmt to describe a variable size. */
1345 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1347 /* If the type is just a cross reference, output one
1348 and mark the type as partially described.
1349 If it later becomes defined, we will output
1350 its real definition.
1351 If the type has a name, don't nest its definition within
1352 another type's definition; instead, output an xref
1353 and let the definition come when the name is defined. */
1354 fprintf (asmfile
, (TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu");
1356 #if 0 /* This assertion is legitimately false in C++. */
1357 /* We shouldn't be outputting a reference to a type before its
1358 definition unless the type has a tag name.
1359 A typedef name without a tag name should be impossible. */
1360 if (TREE_CODE (TYPE_NAME (type
)) != IDENTIFIER_NODE
)
1363 if (TYPE_NAME (type
) != 0)
1364 dbxout_type_name (type
);
1366 fprintf (asmfile
, "$$%d", anonymous_type_number
++);
1367 fprintf (asmfile
, ":");
1368 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1372 /* Identify record or union, and print its size. */
1373 fputc (((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u'), asmfile
);
1374 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1375 int_size_in_bytes (type
));
1377 if (use_gnu_debug_info_extensions
)
1381 have_used_extensions
= 1;
1382 fprintf (asmfile
, "!%d,", n_baseclasses
);
1386 for (i
= 0; i
< n_baseclasses
; i
++)
1388 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)), i
);
1389 if (use_gnu_debug_info_extensions
)
1391 have_used_extensions
= 1;
1392 putc (TREE_VIA_VIRTUAL (child
) ? '1'
1395 putc (TREE_VIA_PUBLIC (child
) ? '2'
1398 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1399 TREE_INT_CST_LOW (BINFO_OFFSET (child
)) * BITS_PER_UNIT
);
1400 fputc (',', asmfile
);
1402 dbxout_type (BINFO_TYPE (child
), 0, 0);
1403 putc (';', asmfile
);
1407 /* Print out the base class information with fields
1408 which have the same names at the types they hold. */
1409 dbxout_type_name (BINFO_TYPE (child
));
1410 putc (':', asmfile
);
1411 dbxout_type (BINFO_TYPE (child
), full
, 0);
1412 fputc (',', asmfile
);
1413 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1414 TREE_INT_CST_LOW (BINFO_OFFSET (child
)) * BITS_PER_UNIT
);
1415 fputc (',', asmfile
);
1416 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1417 TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child
)))) * BITS_PER_UNIT
);
1418 fputc (';', asmfile
);
1426 /* Write out the field declarations. */
1427 dbxout_type_fields (type
);
1428 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1430 have_used_extensions
= 1;
1431 dbxout_type_methods (type
);
1433 putc (';', asmfile
);
1435 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1436 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1437 && TYPE_VFIELD (type
))
1439 have_used_extensions
= 1;
1441 /* Tell GDB+ that it may keep reading. */
1442 putc ('~', asmfile
);
1444 /* We need to write out info about what field this class
1445 uses as its "main" vtable pointer field, because if this
1446 field is inherited from a base class, GDB cannot necessarily
1447 figure out which field it's using in time. */
1448 if (TYPE_VFIELD (type
))
1450 putc ('%', asmfile
);
1451 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0, 0);
1453 putc (';', asmfile
);
1459 /* We must use the same test here as we use in the DBX_NO_XREFS case
1460 above. We simplify it a bit since an enum will never have a variable
1462 if ((TYPE_NAME (type
) != 0
1463 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1464 && DECL_IGNORED_P (TYPE_NAME (type
)))
1466 || TYPE_SIZE (type
) == 0)
1468 fprintf (asmfile
, "xe");
1470 dbxout_type_name (type
);
1471 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1472 fprintf (asmfile
, ":");
1475 #ifdef DBX_OUTPUT_ENUM
1476 DBX_OUTPUT_ENUM (asmfile
, type
);
1478 if (use_gnu_debug_info_extensions
1479 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1480 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1481 putc ('e', asmfile
);
1483 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1485 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)));
1486 if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == 0)
1487 fprintf (asmfile
, HOST_WIDE_INT_PRINT_UNSIGNED
,
1488 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1489 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == -1
1490 && TREE_INT_CST_LOW (TREE_VALUE (tem
)) < 0)
1491 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1492 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1494 print_int_cst_octal (TREE_VALUE (tem
));
1495 fprintf (asmfile
, ",");
1496 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)));
1497 if (TREE_CHAIN (tem
) != 0)
1502 putc (';', asmfile
);
1508 putc ('*', asmfile
);
1510 dbxout_type (TREE_TYPE (type
), 0, 0);
1514 if (use_gnu_debug_info_extensions
)
1516 have_used_extensions
= 1;
1517 putc ('#', asmfile
);
1519 if (flag_minimal_debug
&& !show_arg_types
)
1521 /* Normally, just output the return type.
1522 The argument types are encoded in the method name. */
1523 putc ('#', asmfile
);
1525 dbxout_type (TREE_TYPE (type
), 0, 0);
1526 putc (';', asmfile
);
1531 /* When outputting destructors, we need to write
1532 the argument types out longhand. */
1533 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0, 0);
1534 putc (',', asmfile
);
1536 dbxout_type (TREE_TYPE (type
), 0, 0);
1537 dbxout_args (TYPE_ARG_TYPES (type
));
1538 putc (';', asmfile
);
1544 /* Treat it as a function type. */
1545 dbxout_type (TREE_TYPE (type
), 0, 0);
1550 if (use_gnu_debug_info_extensions
)
1552 have_used_extensions
= 1;
1553 putc ('@', asmfile
);
1555 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0, 0);
1556 putc (',', asmfile
);
1558 dbxout_type (TREE_TYPE (type
), 0, 0);
1562 /* Should print as an int, because it is really
1564 dbxout_type (integer_type_node
, 0, 0);
1568 case REFERENCE_TYPE
:
1569 if (use_gnu_debug_info_extensions
)
1570 have_used_extensions
= 1;
1571 putc (use_gnu_debug_info_extensions
? '&' : '*', asmfile
);
1573 dbxout_type (TREE_TYPE (type
), 0, 0);
1577 putc ('f', asmfile
);
1579 dbxout_type (TREE_TYPE (type
), 0, 0);
1587 /* Print the value of integer constant C, in octal,
1588 handling double precision. */
1591 print_int_cst_octal (c
)
1594 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (c
);
1595 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (c
);
1596 int excess
= (3 - (HOST_BITS_PER_WIDE_INT
% 3));
1597 int width
= TYPE_PRECISION (TREE_TYPE (c
));
1599 /* GDB wants constants with no extra leading "1" bits, so
1600 we need to remove any sign-extension that might be
1602 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
1604 else if (width
> HOST_BITS_PER_WIDE_INT
)
1605 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
1606 else if (width
== HOST_BITS_PER_WIDE_INT
)
1609 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
1611 fprintf (asmfile
, "0");
1615 print_octal (high
, HOST_BITS_PER_WIDE_INT
/ 3);
1616 print_octal (low
, HOST_BITS_PER_WIDE_INT
/ 3);
1620 unsigned HOST_WIDE_INT beg
= high
>> excess
;
1621 unsigned HOST_WIDE_INT middle
1622 = ((high
& (((HOST_WIDE_INT
) 1 << excess
) - 1)) << (3 - excess
)
1623 | (low
>> (HOST_BITS_PER_WIDE_INT
/ 3 * 3)));
1624 unsigned HOST_WIDE_INT end
1625 = low
& (((unsigned HOST_WIDE_INT
) 1
1626 << (HOST_BITS_PER_WIDE_INT
/ 3 * 3))
1629 fprintf (asmfile
, "%o%01o", (int)beg
, (int)middle
);
1630 print_octal (end
, HOST_BITS_PER_WIDE_INT
/ 3);
1635 print_octal (value
, digits
)
1636 unsigned HOST_WIDE_INT value
;
1641 for (i
= digits
- 1; i
>= 0; i
--)
1642 fprintf (asmfile
, "%01o", (int)((value
>> (3 * i
)) & 7));
1645 /* Output the name of type TYPE, with no punctuation.
1646 Such names can be set up either by typedef declarations
1647 or by struct, enum and union tags. */
1650 dbxout_type_name (type
)
1654 if (TYPE_NAME (type
) == 0)
1656 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
1658 t
= TYPE_NAME (type
);
1660 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1662 t
= DECL_NAME (TYPE_NAME (type
));
1667 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
1668 CHARS (IDENTIFIER_LENGTH (t
));
1671 /* Output a .stabs for the symbol defined by DECL,
1672 which must be a ..._DECL node in the normal namespace.
1673 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1674 LOCAL is nonzero if the scope is less than the entire file. */
1677 dbxout_symbol (decl
, local
)
1681 tree type
= TREE_TYPE (decl
);
1682 tree context
= NULL_TREE
;
1684 /* Cast avoids warning in old compilers. */
1685 current_sym_code
= (STAB_CODE_TYPE
) 0;
1686 current_sym_value
= 0;
1687 current_sym_addr
= 0;
1689 /* Ignore nameless syms, but don't ignore type tags. */
1691 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
1692 || DECL_IGNORED_P (decl
))
1695 dbxout_prepare_symbol (decl
);
1697 /* The output will always start with the symbol name,
1698 so always count that in the length-output-so-far. */
1700 if (DECL_NAME (decl
) != 0)
1701 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
1703 switch (TREE_CODE (decl
))
1706 /* Enum values are defined by defining the enum type. */
1710 if (DECL_RTL (decl
) == 0)
1712 if (DECL_EXTERNAL (decl
))
1714 /* Don't mention a nested function under its parent. */
1715 context
= decl_function_context (decl
);
1716 if (context
== current_function_decl
)
1718 if (GET_CODE (DECL_RTL (decl
)) != MEM
1719 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
1723 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
1724 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1725 TREE_PUBLIC (decl
) ? 'F' : 'f');
1727 current_sym_code
= N_FUN
;
1728 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1730 if (TREE_TYPE (type
))
1731 dbxout_type (TREE_TYPE (type
), 0, 0);
1733 dbxout_type (void_type_node
, 0, 0);
1735 /* For a nested function, when that function is compiled,
1736 mention the containing function name
1737 as well as (since dbx wants it) our own assembler-name. */
1739 fprintf (asmfile
, ",%s,%s",
1740 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1741 IDENTIFIER_POINTER (DECL_NAME (context
)));
1743 dbxout_finish_symbol (decl
);
1748 /* This seems all wrong. Outputting most kinds of types gives no name
1749 at all. A true definition gives no name; a cross-ref for a
1750 structure can give the tag name, but not a type name.
1751 It seems that no typedef name is defined by outputting a type. */
1753 /* If this typedef name was defined by outputting the type,
1754 don't duplicate it. */
1755 if (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
== TYPE_DEFINED
1756 && TYPE_NAME (TREE_TYPE (decl
)) == decl
)
1759 /* Don't output the same typedef twice.
1760 And don't output what language-specific stuff doesn't want output. */
1761 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
1770 if (DECL_NAME (decl
))
1772 /* Nonzero means we must output a tag as well as a typedef. */
1775 /* Handle the case of a C++ structure or union
1776 where the TYPE_NAME is a TYPE_DECL
1777 which gives both a typedef name and a tag. */
1778 /* dbx requires the tag first and the typedef second. */
1779 if ((TREE_CODE (type
) == RECORD_TYPE
1780 || TREE_CODE (type
) == UNION_TYPE
1781 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1782 && TYPE_NAME (type
) == decl
1783 && !(use_gnu_debug_info_extensions
&& have_used_extensions
)
1784 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
1785 /* Distinguish the implicit typedefs of C++
1786 from explicit ones that might be found in C. */
1787 && DECL_ARTIFICIAL (decl
))
1789 tree name
= TYPE_NAME (type
);
1790 if (TREE_CODE (name
) == TYPE_DECL
)
1791 name
= DECL_NAME (name
);
1793 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1794 current_sym_value
= 0;
1795 current_sym_addr
= 0;
1796 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1798 fprintf (asmfile
, "%s \"%s:T", ASM_STABS_OP
,
1799 IDENTIFIER_POINTER (name
));
1800 dbxout_type (type
, 1, 0);
1801 dbxout_finish_symbol (NULL_TREE
);
1804 /* Output typedef name. */
1805 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
,
1806 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1808 /* Short cut way to output a tag also. */
1809 if ((TREE_CODE (type
) == RECORD_TYPE
1810 || TREE_CODE (type
) == UNION_TYPE
1811 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1812 && TYPE_NAME (type
) == decl
1813 /* Distinguish the implicit typedefs of C++
1814 from explicit ones that might be found in C. */
1815 && DECL_ARTIFICIAL (decl
))
1817 if (use_gnu_debug_info_extensions
&& have_used_extensions
)
1819 putc ('T', asmfile
);
1820 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
1822 #if 0 /* Now we generate the tag for this case up above. */
1828 putc ('t', asmfile
);
1829 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1831 dbxout_type (type
, 1, 0);
1832 dbxout_finish_symbol (decl
);
1836 /* Don't output a tag if this is an incomplete type (TYPE_SIZE is
1837 zero). This prevents the sun4 Sun OS 4.x dbx from crashing. */
1839 if (tag_needed
&& TYPE_NAME (type
) != 0
1840 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
1841 || (DECL_NAME (TYPE_NAME (type
)) != 0))
1842 && TYPE_SIZE (type
) != 0
1843 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1845 /* For a TYPE_DECL with no name, but the type has a name,
1847 This is what represents `struct foo' with no typedef. */
1848 /* In C++, the name of a type is the corresponding typedef.
1849 In C, it is an IDENTIFIER_NODE. */
1850 tree name
= TYPE_NAME (type
);
1851 if (TREE_CODE (name
) == TYPE_DECL
)
1852 name
= DECL_NAME (name
);
1854 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1855 current_sym_value
= 0;
1856 current_sym_addr
= 0;
1857 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1859 fprintf (asmfile
, "%s \"%s:T", ASM_STABS_OP
,
1860 IDENTIFIER_POINTER (name
));
1861 dbxout_type (type
, 1, 0);
1862 dbxout_finish_symbol (NULL_TREE
);
1866 /* If an enum type has no name, it cannot be referred to,
1867 but we must output it anyway, since the enumeration constants
1868 can be referred to. */
1869 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
1871 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1872 current_sym_value
= 0;
1873 current_sym_addr
= 0;
1874 current_sym_nchars
= 2;
1876 /* Some debuggers fail when given NULL names, so give this a
1877 harmless name of ` '. */
1878 fprintf (asmfile
, "%s \" :T", ASM_STABS_OP
);
1879 dbxout_type (type
, 1, 0);
1880 dbxout_finish_symbol (NULL_TREE
);
1883 /* Prevent duplicate output of a typedef. */
1884 TREE_ASM_WRITTEN (decl
) = 1;
1889 /* Parm decls go in their own separate chains
1890 and are output by dbxout_reg_parms and dbxout_parms. */
1894 /* Named return value, treat like a VAR_DECL. */
1896 if (DECL_RTL (decl
) == 0)
1898 /* Don't mention a variable that is external.
1899 Let the file that defines it describe it. */
1900 if (DECL_EXTERNAL (decl
))
1903 /* If the variable is really a constant
1904 and not written in memory, inform the debugger. */
1905 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
1906 && DECL_INITIAL (decl
) != 0
1907 && ! TREE_ASM_WRITTEN (decl
)
1908 && (DECL_FIELD_CONTEXT (decl
) == NULL_TREE
1909 || TREE_CODE (DECL_FIELD_CONTEXT (decl
)) == BLOCK
))
1911 if (TREE_PUBLIC (decl
) == 0)
1913 /* The sun4 assembler does not grok this. */
1914 char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1915 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
1916 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
1918 HOST_WIDE_INT ival
= TREE_INT_CST_LOW (DECL_INITIAL (decl
));
1919 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1920 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile
, name
, ival
);
1922 fprintf (asmfile
, "%s \"%s:c=i", ASM_STABS_OP
, name
);
1924 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, ival
);
1925 fprintf (asmfile
, "\",0x%x,0,0,0\n", N_LSYM
);
1929 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
1931 /* don't know how to do this yet. */
1935 /* else it is something we handle like a normal variable. */
1938 DECL_RTL (decl
) = eliminate_regs (DECL_RTL (decl
), 0, NULL_RTX
);
1939 #ifdef LEAF_REG_REMAP
1940 if (current_function_uses_only_leaf_regs
)
1941 leaf_renumber_regs_insn (DECL_RTL (decl
));
1944 dbxout_symbol_location (decl
, type
, 0, DECL_RTL (decl
));
1952 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1953 Add SUFFIX to its name, if SUFFIX is not 0.
1954 Describe the variable as residing in HOME
1955 (usually HOME is DECL_RTL (DECL), but not always). */
1958 dbxout_symbol_location (decl
, type
, suffix
, home
)
1966 /* Don't mention a variable at all
1967 if it was completely optimized into nothingness.
1969 If the decl was from an inline function, then its rtl
1970 is not identically the rtl that was used in this
1971 particular compilation. */
1972 if (GET_CODE (home
) == REG
)
1974 regno
= REGNO (home
);
1975 if (regno
>= FIRST_PSEUDO_REGISTER
)
1978 else if (GET_CODE (home
) == SUBREG
)
1982 while (GET_CODE (value
) == SUBREG
)
1984 offset
+= SUBREG_WORD (value
);
1985 value
= SUBREG_REG (value
);
1987 if (GET_CODE (value
) == REG
)
1989 regno
= REGNO (value
);
1990 if (regno
>= FIRST_PSEUDO_REGISTER
)
1994 alter_subreg (home
);
1997 /* The kind-of-variable letter depends on where
1998 the variable is and on the scope of its name:
1999 G and N_GSYM for static storage and global scope,
2000 S for static storage and file scope,
2001 V for static storage and local scope,
2002 for those two, use N_LCSYM if data is in bss segment,
2003 N_STSYM if in data segment, N_FUN otherwise.
2004 (We used N_FUN originally, then changed to N_STSYM
2005 to please GDB. However, it seems that confused ld.
2006 Now GDB has been fixed to like N_FUN, says Kingdon.)
2007 no letter at all, and N_LSYM, for auto variable,
2008 r and N_RSYM for register variable. */
2010 if (GET_CODE (home
) == MEM
2011 && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2013 if (TREE_PUBLIC (decl
))
2016 current_sym_code
= N_GSYM
;
2020 current_sym_addr
= XEXP (home
, 0);
2022 letter
= decl_function_context (decl
) ? 'V' : 'S';
2024 /* This should be the same condition as in assemble_variable, but
2025 we don't have access to dont_output_data here. So, instead,
2026 we rely on the fact that error_mark_node initializers always
2027 end up in bss for C++ and never end up in bss for C. */
2028 if (DECL_INITIAL (decl
) == 0
2029 || (!strcmp (lang_identify (), "cplusplus")
2030 && DECL_INITIAL (decl
) == error_mark_node
))
2031 current_sym_code
= N_LCSYM
;
2032 else if (DECL_IN_TEXT_SECTION (decl
))
2033 /* This is not quite right, but it's the closest
2034 of all the codes that Unix defines. */
2035 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
2038 /* Ultrix `as' seems to need this. */
2039 #ifdef DBX_STATIC_STAB_DATA_SECTION
2042 current_sym_code
= N_STSYM
;
2046 else if (regno
>= 0)
2049 current_sym_code
= N_RSYM
;
2050 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
2052 else if (GET_CODE (home
) == MEM
2053 && (GET_CODE (XEXP (home
, 0)) == MEM
2054 || (GET_CODE (XEXP (home
, 0)) == REG
2055 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
2056 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
2057 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2058 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
2061 /* If the value is indirect by memory or by a register
2062 that isn't the frame pointer
2063 then it means the object is variable-sized and address through
2064 that register or stack slot. DBX has no way to represent this
2065 so all we can do is output the variable as a pointer.
2066 If it's not a parameter, ignore it.
2067 (VAR_DECLs like this can be made by integrate.c.) */
2069 if (GET_CODE (XEXP (home
, 0)) == REG
)
2072 current_sym_code
= N_RSYM
;
2073 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
2077 current_sym_code
= N_LSYM
;
2078 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2079 We want the value of that CONST_INT. */
2081 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
2084 /* Effectively do build_pointer_type, but don't cache this type,
2085 since it might be temporary whereas the type it points to
2086 might have been saved for inlining. */
2087 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2088 type
= make_node (POINTER_TYPE
);
2089 TREE_TYPE (type
) = TREE_TYPE (decl
);
2091 else if (GET_CODE (home
) == MEM
2092 && GET_CODE (XEXP (home
, 0)) == REG
)
2094 current_sym_code
= N_LSYM
;
2095 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2097 else if (GET_CODE (home
) == MEM
2098 && GET_CODE (XEXP (home
, 0)) == PLUS
2099 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
2101 current_sym_code
= N_LSYM
;
2102 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2103 We want the value of that CONST_INT. */
2104 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2106 else if (GET_CODE (home
) == MEM
2107 && GET_CODE (XEXP (home
, 0)) == CONST
)
2109 /* Handle an obscure case which can arise when optimizing and
2110 when there are few available registers. (This is *always*
2111 the case for i386/i486 targets). The RTL looks like
2112 (MEM (CONST ...)) even though this variable is a local `auto'
2113 or a local `register' variable. In effect, what has happened
2114 is that the reload pass has seen that all assignments and
2115 references for one such a local variable can be replaced by
2116 equivalent assignments and references to some static storage
2117 variable, thereby avoiding the need for a register. In such
2118 cases we're forced to lie to debuggers and tell them that
2119 this variable was itself `static'. */
2120 current_sym_code
= N_LCSYM
;
2122 current_sym_addr
= XEXP (XEXP (home
, 0), 0);
2124 else if (GET_CODE (home
) == CONCAT
)
2126 tree subtype
= TREE_TYPE (type
);
2128 /* If the variable's storage is in two parts,
2129 output each as a separate stab with a modified name. */
2130 if (WORDS_BIG_ENDIAN
)
2131 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
2133 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
2135 /* Cast avoids warning in old compilers. */
2136 current_sym_code
= (STAB_CODE_TYPE
) 0;
2137 current_sym_value
= 0;
2138 current_sym_addr
= 0;
2139 dbxout_prepare_symbol (decl
);
2141 if (WORDS_BIG_ENDIAN
)
2142 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
2144 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
2148 /* Address might be a MEM, when DECL is a variable-sized object.
2149 Or it might be const0_rtx, meaning previous passes
2150 want us to ignore this variable. */
2153 /* Ok, start a symtab entry and output the variable name. */
2156 #ifdef DBX_STATIC_BLOCK_START
2157 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
2160 dbxout_symbol_name (decl
, suffix
, letter
);
2161 dbxout_type (type
, 0, 0);
2162 dbxout_finish_symbol (decl
);
2164 #ifdef DBX_STATIC_BLOCK_END
2165 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
2169 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2170 Then output LETTER to indicate the kind of location the symbol has. */
2173 dbxout_symbol_name (decl
, suffix
, letter
)
2178 /* One slight hitch: if this is a VAR_DECL which is a static
2179 class member, we must put out the mangled name instead of the
2180 DECL_NAME. Note also that static member (variable) names DO NOT begin
2181 with underscores in .stabs directives. */
2182 char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2185 fprintf (asmfile
, "%s \"%s%s:", ASM_STABS_OP
, name
,
2186 (suffix
? suffix
: ""));
2188 if (letter
) putc (letter
, asmfile
);
2192 dbxout_prepare_symbol (decl
)
2193 tree decl ATTRIBUTE_UNUSED
;
2196 char *filename
= DECL_SOURCE_FILE (decl
);
2198 dbxout_source_file (asmfile
, filename
);
2203 dbxout_finish_symbol (sym
)
2206 #ifdef DBX_FINISH_SYMBOL
2207 DBX_FINISH_SYMBOL (sym
);
2210 if (use_gnu_debug_info_extensions
&& sym
!= 0)
2211 line
= DECL_SOURCE_LINE (sym
);
2213 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
2214 if (current_sym_addr
)
2215 output_addr_const (asmfile
, current_sym_addr
);
2217 fprintf (asmfile
, "%d", current_sym_value
);
2218 putc ('\n', asmfile
);
2222 /* Output definitions of all the decls in a chain. */
2230 dbxout_symbol (syms
, 1);
2231 syms
= TREE_CHAIN (syms
);
2235 /* The following two functions output definitions of function parameters.
2236 Each parameter gets a definition locating it in the parameter list.
2237 Each parameter that is a register variable gets a second definition
2238 locating it in the register.
2240 Printing or argument lists in gdb uses the definitions that
2241 locate in the parameter list. But reference to the variable in
2242 expressions uses preferentially the definition as a register. */
2244 /* Output definitions, referring to storage in the parmlist,
2245 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2248 dbxout_parms (parms
)
2251 for (; parms
; parms
= TREE_CHAIN (parms
))
2252 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
2254 dbxout_prepare_symbol (parms
);
2256 /* Perform any necessary register eliminations on the parameter's rtl,
2257 so that the debugging output will be accurate. */
2258 DECL_INCOMING_RTL (parms
)
2259 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
2260 DECL_RTL (parms
) = eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
);
2261 #ifdef LEAF_REG_REMAP
2262 if (current_function_uses_only_leaf_regs
)
2264 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
2265 leaf_renumber_regs_insn (DECL_RTL (parms
));
2269 if (PARM_PASSED_IN_MEMORY (parms
))
2271 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
2273 /* ??? Here we assume that the parm address is indexed
2274 off the frame pointer or arg pointer.
2275 If that is not true, we produce meaningless results,
2276 but do not crash. */
2277 if (GET_CODE (addr
) == PLUS
2278 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
2279 current_sym_value
= INTVAL (XEXP (addr
, 1));
2281 current_sym_value
= 0;
2283 current_sym_code
= N_PSYM
;
2284 current_sym_addr
= 0;
2287 if (DECL_NAME (parms
))
2289 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2291 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2292 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2293 DBX_MEMPARM_STABS_LETTER
);
2297 current_sym_nchars
= 8;
2298 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2299 DBX_MEMPARM_STABS_LETTER
);
2302 /* It is quite tempting to use:
2304 dbxout_type (TREE_TYPE (parms), 0, 0);
2306 as the next statement, rather than using DECL_ARG_TYPE(), so
2307 that gcc reports the actual type of the parameter, rather
2308 than the promoted type. This certainly makes GDB's life
2309 easier, at least for some ports. The change is a bad idea
2310 however, since GDB expects to be able access the type without
2311 performing any conversions. So for example, if we were
2312 passing a float to an unprototyped function, gcc will store a
2313 double on the stack, but if we emit a stab saying the type is a
2314 float, then gdb will only read in a single value, and this will
2315 produce an erropneous value. */
2316 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
2317 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
2318 dbxout_finish_symbol (parms
);
2320 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
2323 char regparm_letter
;
2325 /* Parm passed in registers and lives in registers or nowhere. */
2327 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2328 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2329 current_sym_addr
= 0;
2331 /* If parm lives in a register, use that register;
2332 pretend the parm was passed there. It would be more consistent
2333 to describe the register where the parm was passed,
2334 but in practice that register usually holds something else.
2336 If we use DECL_RTL, then we must use the declared type of
2337 the variable, not the type that it arrived in. */
2338 if (REGNO (DECL_RTL (parms
)) >= 0
2339 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2341 best_rtl
= DECL_RTL (parms
);
2342 parm_type
= TREE_TYPE (parms
);
2344 /* If the parm lives nowhere, use the register where it was
2345 passed. It is also better to use the declared type here. */
2348 best_rtl
= DECL_INCOMING_RTL (parms
);
2349 parm_type
= TREE_TYPE (parms
);
2351 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
2354 if (DECL_NAME (parms
))
2356 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2357 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2358 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2363 current_sym_nchars
= 8;
2364 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2368 dbxout_type (parm_type
, 0, 0);
2369 dbxout_finish_symbol (parms
);
2371 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2372 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
2373 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
2374 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
2375 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2376 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
2380 /* Parm was passed via invisible reference.
2381 That is, its address was passed in a register.
2382 Output it as if it lived in that register.
2383 The debugger will know from the type
2384 that it was actually passed by invisible reference. */
2386 char regparm_letter
;
2387 /* Parm passed in registers and lives in registers or nowhere. */
2389 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2390 if (use_gnu_debug_info_extensions
)
2391 regparm_letter
= GDB_INV_REF_REGPARM_STABS_LETTER
;
2393 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2395 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2396 If it is an unallocated pseudo-reg, then use the register where
2397 it was passed instead. */
2398 if (REGNO (XEXP (DECL_RTL (parms
), 0)) >= 0
2399 && REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
2400 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
2402 current_sym_value
= REGNO (DECL_INCOMING_RTL (parms
));
2404 current_sym_addr
= 0;
2407 if (DECL_NAME (parms
))
2409 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2411 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2412 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2417 current_sym_nchars
= 8;
2418 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2422 dbxout_type (TREE_TYPE (parms
), 0, 0);
2423 dbxout_finish_symbol (parms
);
2425 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2426 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
2427 /* ??? A constant address for a parm can happen
2428 when the reg it lives in is equiv to a constant in memory.
2429 Should make this not happen, after 2.4. */
2430 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
2432 /* Parm was passed in registers but lives on the stack. */
2434 current_sym_code
= N_PSYM
;
2435 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2436 in which case we want the value of that CONST_INT,
2437 or (MEM (REG ...)) or (MEM (MEM ...)),
2438 in which case we use a value of zero. */
2439 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
2440 || GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
2441 current_sym_value
= 0;
2443 current_sym_value
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
2444 current_sym_addr
= 0;
2446 /* Make a big endian correction if the mode of the type of the
2447 parameter is not the same as the mode of the rtl. */
2448 if (BYTES_BIG_ENDIAN
2449 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
2450 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
2452 current_sym_value
+= UNITS_PER_WORD
- GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
)));
2456 if (DECL_NAME (parms
))
2458 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2460 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2461 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2462 DBX_MEMPARM_STABS_LETTER
);
2466 current_sym_nchars
= 8;
2467 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2468 DBX_MEMPARM_STABS_LETTER
);
2472 = DEBUGGER_ARG_OFFSET (current_sym_value
,
2473 XEXP (DECL_RTL (parms
), 0));
2474 dbxout_type (TREE_TYPE (parms
), 0, 0);
2475 dbxout_finish_symbol (parms
);
2480 /* Output definitions for the places where parms live during the function,
2481 when different from where they were passed, when the parms were passed
2484 It is not useful to do this for parms passed in registers
2485 that live during the function in different registers, because it is
2486 impossible to look in the passed register for the passed value,
2487 so we use the within-the-function register to begin with.
2489 PARMS is a chain of PARM_DECL nodes. */
2492 dbxout_reg_parms (parms
)
2495 for (; parms
; parms
= TREE_CHAIN (parms
))
2496 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
2498 dbxout_prepare_symbol (parms
);
2500 /* Report parms that live in registers during the function
2501 but were passed in memory. */
2502 if (GET_CODE (DECL_RTL (parms
)) == REG
2503 && REGNO (DECL_RTL (parms
)) >= 0
2504 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2505 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2506 0, DECL_RTL (parms
));
2507 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
2508 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2509 0, DECL_RTL (parms
));
2510 /* Report parms that live in memory but not where they were passed. */
2511 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2512 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
2513 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2514 0, DECL_RTL (parms
));
2518 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2519 output definitions of those names, in raw form */
2527 putc (',', asmfile
);
2528 dbxout_type (TREE_VALUE (args
), 0, 0);
2530 args
= TREE_CHAIN (args
);
2534 /* Given a chain of ..._TYPE nodes,
2535 find those which have typedef names and output those names.
2536 This is to ensure those types get output. */
2539 dbxout_types (types
)
2540 register tree types
;
2544 if (TYPE_NAME (types
)
2545 && TREE_CODE (TYPE_NAME (types
)) == TYPE_DECL
2546 && ! TREE_ASM_WRITTEN (TYPE_NAME (types
)))
2547 dbxout_symbol (TYPE_NAME (types
), 1);
2548 types
= TREE_CHAIN (types
);
2552 /* Output everything about a symbol block (a BLOCK node
2553 that represents a scope level),
2554 including recursive output of contained blocks.
2556 BLOCK is the BLOCK node.
2557 DEPTH is its depth within containing symbol blocks.
2558 ARGS is usually zero; but for the outermost block of the
2559 body of a function, it is a chain of PARM_DECLs for the function parameters.
2560 We output definitions of all the register parms
2561 as if they were local variables of that block.
2563 If -g1 was used, we count blocks just the same, but output nothing
2564 except for the outermost block.
2566 Actually, BLOCK may be several blocks chained together.
2567 We handle them all in sequence. */
2570 dbxout_block (block
, depth
, args
)
2571 register tree block
;
2579 /* Ignore blocks never expanded or otherwise marked as real. */
2580 if (TREE_USED (block
))
2582 #ifndef DBX_LBRAC_FIRST
2583 /* In dbx format, the syms of a block come before the N_LBRAC. */
2584 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2585 dbxout_syms (BLOCK_VARS (block
));
2587 dbxout_reg_parms (args
);
2590 /* Now output an N_LBRAC symbol to represent the beginning of
2591 the block. Use the block's tree-walk order to generate
2592 the assembler symbols LBBn and LBEn
2593 that final will define around the code in this block. */
2594 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2597 blocknum
= next_block_number
++;
2598 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
2600 if (BLOCK_HANDLER_BLOCK (block
))
2602 /* A catch block. Must precede N_LBRAC. */
2603 tree decl
= BLOCK_VARS (block
);
2606 #ifdef DBX_OUTPUT_CATCH
2607 DBX_OUTPUT_CATCH (asmfile
, decl
, buf
);
2609 fprintf (asmfile
, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP
,
2610 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
2611 assemble_name (asmfile
, buf
);
2612 fprintf (asmfile
, "\n");
2614 decl
= TREE_CHAIN (decl
);
2618 #ifdef DBX_OUTPUT_LBRAC
2619 DBX_OUTPUT_LBRAC (asmfile
, buf
);
2621 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_LBRAC
);
2622 assemble_name (asmfile
, buf
);
2623 #if DBX_BLOCKS_FUNCTION_RELATIVE
2624 fputc ('-', asmfile
);
2625 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
2627 fprintf (asmfile
, "\n");
2631 /* Count blocks the same way regardless of debug_info_level. */
2632 next_block_number
++;
2634 #ifdef DBX_LBRAC_FIRST
2635 /* On some weird machines, the syms of a block
2636 come after the N_LBRAC. */
2637 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2638 dbxout_syms (BLOCK_VARS (block
));
2640 dbxout_reg_parms (args
);
2643 /* Output the subblocks. */
2644 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
2646 /* Refer to the marker for the end of the block. */
2647 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2650 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
2651 #ifdef DBX_OUTPUT_RBRAC
2652 DBX_OUTPUT_RBRAC (asmfile
, buf
);
2654 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_RBRAC
);
2655 assemble_name (asmfile
, buf
);
2656 #if DBX_BLOCKS_FUNCTION_RELATIVE
2657 fputc ('-', asmfile
);
2658 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
2660 fprintf (asmfile
, "\n");
2664 block
= BLOCK_CHAIN (block
);
2668 /* Output the information about a function and its arguments and result.
2669 Usually this follows the function's code,
2670 but on some systems, it comes before. */
2673 dbxout_really_begin_function (decl
)
2676 dbxout_symbol (decl
, 0);
2677 dbxout_parms (DECL_ARGUMENTS (decl
));
2678 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
2679 dbxout_symbol (DECL_RESULT (decl
), 1);
2682 /* Called at beginning of output of function definition. */
2685 dbxout_begin_function (decl
)
2686 tree decl ATTRIBUTE_UNUSED
;
2688 #ifdef DBX_FUNCTION_FIRST
2689 dbxout_really_begin_function (decl
);
2693 /* Output dbx data for a function definition.
2694 This includes a definition of the function name itself (a symbol),
2695 definitions of the parameters (locating them in the parameter list)
2696 and then output the block that makes up the function's body
2697 (including all the auto variables of the function). */
2700 dbxout_function (decl
)
2703 #ifndef DBX_FUNCTION_FIRST
2704 dbxout_really_begin_function (decl
);
2706 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
2707 #ifdef DBX_OUTPUT_FUNCTION_END
2708 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
2710 #if defined(ASM_OUTPUT_SECTION_NAME)
2711 if (use_gnu_debug_info_extensions
2712 #if defined(NO_DBX_FUNCTION_END)
2713 && ! NO_DBX_FUNCTION_END
2716 dbxout_function_end ();
2719 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */