1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987, 88, 92-99, 2000 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
PARAMS ((void));
325 static void dbxout_typedefs
PARAMS ((tree
));
326 static void dbxout_type_index
PARAMS ((tree
));
327 #if DBX_CONTIN_LENGTH > 0
328 static void dbxout_continue
PARAMS ((void));
330 static void dbxout_type_fields
PARAMS ((tree
));
331 static void dbxout_type_method_1
PARAMS ((tree
, const char *));
332 static void dbxout_type_methods
PARAMS ((tree
));
333 static void dbxout_range_type
PARAMS ((tree
));
334 static void dbxout_type
PARAMS ((tree
, int, int));
335 static void print_int_cst_octal
PARAMS ((tree
));
336 static void print_octal
PARAMS ((unsigned HOST_WIDE_INT
, int));
337 static void dbxout_type_name
PARAMS ((tree
));
338 static void dbxout_symbol_location
PARAMS ((tree
, tree
, const char *, rtx
));
339 static void dbxout_symbol_name
PARAMS ((tree
, const char *, int));
340 static void dbxout_prepare_symbol
PARAMS ((tree
));
341 static void dbxout_finish_symbol
PARAMS ((tree
));
342 static void dbxout_block
PARAMS ((tree
, int, tree
));
343 static void dbxout_really_begin_function
PARAMS ((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 /* For unsigned types, we use octal if they are the same size or
1184 larger. This is because we print the bounds as signed decimal,
1185 and hence they can't span same size unsigned types. */
1187 if (use_gnu_debug_info_extensions
1188 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
1189 || (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
)
1190 && TREE_UNSIGNED (type
))
1191 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
1192 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
1193 && TREE_UNSIGNED (type
))))
1195 fprintf (asmfile
, "r");
1196 dbxout_type_index (type
);
1197 fprintf (asmfile
, ";");
1198 print_int_cst_octal (TYPE_MIN_VALUE (type
));
1199 fprintf (asmfile
, ";");
1200 print_int_cst_octal (TYPE_MAX_VALUE (type
));
1201 fprintf (asmfile
, ";");
1205 /* Output other integer types as subranges of `int'. */
1206 dbxout_range_type (type
);
1213 /* This used to say `r1' and we used to take care
1214 to make sure that `int' was type number 1. */
1215 fprintf (asmfile
, "r");
1216 dbxout_type_index (integer_type_node
);
1217 fputc (';', asmfile
);
1218 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1219 fputs (";0;", asmfile
);
1224 if (use_gnu_debug_info_extensions
)
1226 fputs ("@s", asmfile
);
1227 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1228 BITS_PER_UNIT
* int_size_in_bytes (type
));
1229 fputs (";-20;", asmfile
);
1233 /* Output the type `char' as a subrange of itself.
1234 That is what pcc seems to do. */
1235 fprintf (asmfile
, "r");
1236 dbxout_type_index (char_type_node
);
1237 fprintf (asmfile
, ";0;%d;", TREE_UNSIGNED (type
) ? 255 : 127);
1243 if (use_gnu_debug_info_extensions
)
1245 fputs ("@s", asmfile
);
1246 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1247 BITS_PER_UNIT
* int_size_in_bytes (type
));
1248 fputs (";-16;", asmfile
);
1250 else /* Define as enumeral type (False, True) */
1251 fprintf (asmfile
, "eFalse:0,True:1,;");
1256 putc ('d', asmfile
);
1258 dbxout_type (TREE_TYPE (type
), 0, 0);
1262 /* Differs from the REAL_TYPE by its new data type number */
1264 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1266 fprintf (asmfile
, "r");
1267 dbxout_type_index (type
);
1268 fputc (';', asmfile
);
1269 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1270 int_size_in_bytes (TREE_TYPE (type
)));
1271 fputs (";0;", asmfile
);
1272 CHARS (12); /* The number is probably incorrect here. */
1276 /* Output a complex integer type as a structure,
1277 pending some other way to do it. */
1278 fputc ('s', asmfile
);
1279 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, int_size_in_bytes (type
));
1281 fprintf (asmfile
, "real:");
1283 dbxout_type (TREE_TYPE (type
), 0, 0);
1284 fprintf (asmfile
, ",%d,%d;",
1285 0, TYPE_PRECISION (TREE_TYPE (type
)));
1287 fprintf (asmfile
, "imag:");
1289 dbxout_type (TREE_TYPE (type
), 0, 0);
1290 fprintf (asmfile
, ",%d,%d;;",
1291 TYPE_PRECISION (TREE_TYPE (type
)),
1292 TYPE_PRECISION (TREE_TYPE (type
)));
1298 if (use_gnu_debug_info_extensions
)
1300 have_used_extensions
= 1;
1301 fputs ("@s", asmfile
);
1302 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1303 BITS_PER_UNIT
* int_size_in_bytes (type
));
1304 fputc (';', asmfile
);
1305 /* Check if a bitstring type, which in Chill is
1306 different from a [power]set. */
1307 if (TYPE_STRING_FLAG (type
))
1308 fprintf (asmfile
, "@S;");
1310 putc ('S', asmfile
);
1312 dbxout_type (TYPE_DOMAIN (type
), 0, 0);
1316 /* Make arrays of packed bits look like bitstrings for chill. */
1317 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
1319 have_used_extensions
= 1;
1320 fputs ("@s", asmfile
);
1321 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1322 BITS_PER_UNIT
* int_size_in_bytes (type
));
1323 fputc (';', asmfile
);
1324 fprintf (asmfile
, "@S;");
1325 putc ('S', asmfile
);
1327 dbxout_type (TYPE_DOMAIN (type
), 0, 0);
1330 /* Output "a" followed by a range type definition
1331 for the index type of the array
1332 followed by a reference to the target-type.
1333 ar1;0;N;M for a C array of type M and size N+1. */
1334 /* Check if a character string type, which in Chill is
1335 different from an array of characters. */
1336 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
1338 have_used_extensions
= 1;
1339 fprintf (asmfile
, "@S;");
1341 tem
= TYPE_DOMAIN (type
);
1344 fprintf (asmfile
, "ar");
1345 dbxout_type_index (integer_type_node
);
1346 fprintf (asmfile
, ";0;-1;");
1350 fprintf (asmfile
, "a");
1351 dbxout_range_type (tem
);
1354 dbxout_type (TREE_TYPE (type
), 0, 0);
1359 case QUAL_UNION_TYPE
:
1361 int i
, n_baseclasses
= 0;
1363 if (TYPE_BINFO (type
) != 0
1364 && TREE_CODE (TYPE_BINFO (type
)) == TREE_VEC
1365 && TYPE_BINFO_BASETYPES (type
) != 0)
1366 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
1368 /* Output a structure type. We must use the same test here as we
1369 use in the DBX_NO_XREFS case above. */
1370 if ((TYPE_NAME (type
) != 0
1371 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1372 && DECL_IGNORED_P (TYPE_NAME (type
)))
1374 || TYPE_SIZE (type
) == 0
1375 /* No way in DBX fmt to describe a variable size. */
1376 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1378 /* If the type is just a cross reference, output one
1379 and mark the type as partially described.
1380 If it later becomes defined, we will output
1381 its real definition.
1382 If the type has a name, don't nest its definition within
1383 another type's definition; instead, output an xref
1384 and let the definition come when the name is defined. */
1385 fputs ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu", asmfile
);
1387 #if 0 /* This assertion is legitimately false in C++. */
1388 /* We shouldn't be outputting a reference to a type before its
1389 definition unless the type has a tag name.
1390 A typedef name without a tag name should be impossible. */
1391 if (TREE_CODE (TYPE_NAME (type
)) != IDENTIFIER_NODE
)
1394 if (TYPE_NAME (type
) != 0)
1395 dbxout_type_name (type
);
1397 fprintf (asmfile
, "$$%d", anonymous_type_number
++);
1398 fprintf (asmfile
, ":");
1399 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1403 /* Identify record or union, and print its size. */
1404 fputc (((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u'), asmfile
);
1405 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1406 int_size_in_bytes (type
));
1408 if (use_gnu_debug_info_extensions
)
1412 have_used_extensions
= 1;
1413 fprintf (asmfile
, "!%d,", n_baseclasses
);
1417 for (i
= 0; i
< n_baseclasses
; i
++)
1419 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)), i
);
1420 if (use_gnu_debug_info_extensions
)
1422 have_used_extensions
= 1;
1423 putc (TREE_VIA_VIRTUAL (child
) ? '1'
1426 putc (TREE_VIA_PUBLIC (child
) ? '2'
1429 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1430 TREE_INT_CST_LOW (BINFO_OFFSET (child
)) * BITS_PER_UNIT
);
1431 fputc (',', asmfile
);
1433 dbxout_type (BINFO_TYPE (child
), 0, 0);
1434 putc (';', asmfile
);
1438 /* Print out the base class information with fields
1439 which have the same names at the types they hold. */
1440 dbxout_type_name (BINFO_TYPE (child
));
1441 putc (':', asmfile
);
1442 dbxout_type (BINFO_TYPE (child
), full
, 0);
1443 fputc (',', asmfile
);
1444 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1445 TREE_INT_CST_LOW (BINFO_OFFSET (child
)) * BITS_PER_UNIT
);
1446 fputc (',', asmfile
);
1447 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1448 TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child
)))) * BITS_PER_UNIT
);
1449 fputc (';', asmfile
);
1457 /* Write out the field declarations. */
1458 dbxout_type_fields (type
);
1459 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1461 have_used_extensions
= 1;
1462 dbxout_type_methods (type
);
1464 putc (';', asmfile
);
1466 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1467 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1468 && TYPE_VFIELD (type
))
1470 have_used_extensions
= 1;
1472 /* Tell GDB+ that it may keep reading. */
1473 putc ('~', asmfile
);
1475 /* We need to write out info about what field this class
1476 uses as its "main" vtable pointer field, because if this
1477 field is inherited from a base class, GDB cannot necessarily
1478 figure out which field it's using in time. */
1479 if (TYPE_VFIELD (type
))
1481 putc ('%', asmfile
);
1482 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0, 0);
1484 putc (';', asmfile
);
1490 /* We must use the same test here as we use in the DBX_NO_XREFS case
1491 above. We simplify it a bit since an enum will never have a variable
1493 if ((TYPE_NAME (type
) != 0
1494 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1495 && DECL_IGNORED_P (TYPE_NAME (type
)))
1497 || TYPE_SIZE (type
) == 0)
1499 fprintf (asmfile
, "xe");
1501 dbxout_type_name (type
);
1502 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1503 fprintf (asmfile
, ":");
1506 #ifdef DBX_OUTPUT_ENUM
1507 DBX_OUTPUT_ENUM (asmfile
, type
);
1509 if (use_gnu_debug_info_extensions
1510 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1511 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1512 putc ('e', asmfile
);
1514 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1516 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)));
1517 if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == 0)
1518 fprintf (asmfile
, HOST_WIDE_INT_PRINT_UNSIGNED
,
1519 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1520 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == -1
1521 && TREE_INT_CST_LOW (TREE_VALUE (tem
)) < 0)
1522 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
,
1523 TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1525 print_int_cst_octal (TREE_VALUE (tem
));
1526 fprintf (asmfile
, ",");
1527 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)));
1528 if (TREE_CHAIN (tem
) != 0)
1533 putc (';', asmfile
);
1539 putc ('*', asmfile
);
1541 dbxout_type (TREE_TYPE (type
), 0, 0);
1545 if (use_gnu_debug_info_extensions
)
1547 have_used_extensions
= 1;
1548 putc ('#', asmfile
);
1550 if (flag_minimal_debug
&& !show_arg_types
)
1552 /* Normally, just output the return type.
1553 The argument types are encoded in the method name. */
1554 putc ('#', asmfile
);
1556 dbxout_type (TREE_TYPE (type
), 0, 0);
1557 putc (';', asmfile
);
1562 /* When outputting destructors, we need to write
1563 the argument types out longhand. */
1564 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0, 0);
1565 putc (',', asmfile
);
1567 dbxout_type (TREE_TYPE (type
), 0, 0);
1568 dbxout_args (TYPE_ARG_TYPES (type
));
1569 putc (';', asmfile
);
1575 /* Treat it as a function type. */
1576 dbxout_type (TREE_TYPE (type
), 0, 0);
1581 if (use_gnu_debug_info_extensions
)
1583 have_used_extensions
= 1;
1584 putc ('@', asmfile
);
1586 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0, 0);
1587 putc (',', asmfile
);
1589 dbxout_type (TREE_TYPE (type
), 0, 0);
1593 /* Should print as an int, because it is really
1595 dbxout_type (integer_type_node
, 0, 0);
1599 case REFERENCE_TYPE
:
1600 if (use_gnu_debug_info_extensions
)
1601 have_used_extensions
= 1;
1602 putc (use_gnu_debug_info_extensions
? '&' : '*', asmfile
);
1604 dbxout_type (TREE_TYPE (type
), 0, 0);
1608 putc ('f', asmfile
);
1610 dbxout_type (TREE_TYPE (type
), 0, 0);
1618 /* Print the value of integer constant C, in octal,
1619 handling double precision. */
1622 print_int_cst_octal (c
)
1625 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (c
);
1626 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (c
);
1627 int excess
= (3 - (HOST_BITS_PER_WIDE_INT
% 3));
1628 int width
= TYPE_PRECISION (TREE_TYPE (c
));
1630 /* GDB wants constants with no extra leading "1" bits, so
1631 we need to remove any sign-extension that might be
1633 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
1635 else if (width
> HOST_BITS_PER_WIDE_INT
)
1636 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
1637 else if (width
== HOST_BITS_PER_WIDE_INT
)
1640 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
1642 fprintf (asmfile
, "0");
1646 print_octal (high
, HOST_BITS_PER_WIDE_INT
/ 3);
1647 print_octal (low
, HOST_BITS_PER_WIDE_INT
/ 3);
1651 unsigned HOST_WIDE_INT beg
= high
>> excess
;
1652 unsigned HOST_WIDE_INT middle
1653 = ((high
& (((HOST_WIDE_INT
) 1 << excess
) - 1)) << (3 - excess
)
1654 | (low
>> (HOST_BITS_PER_WIDE_INT
/ 3 * 3)));
1655 unsigned HOST_WIDE_INT end
1656 = low
& (((unsigned HOST_WIDE_INT
) 1
1657 << (HOST_BITS_PER_WIDE_INT
/ 3 * 3))
1660 fprintf (asmfile
, "%o%01o", (int)beg
, (int)middle
);
1661 print_octal (end
, HOST_BITS_PER_WIDE_INT
/ 3);
1666 print_octal (value
, digits
)
1667 unsigned HOST_WIDE_INT value
;
1672 for (i
= digits
- 1; i
>= 0; i
--)
1673 fprintf (asmfile
, "%01o", (int)((value
>> (3 * i
)) & 7));
1676 /* Output the name of type TYPE, with no punctuation.
1677 Such names can be set up either by typedef declarations
1678 or by struct, enum and union tags. */
1681 dbxout_type_name (type
)
1685 if (TYPE_NAME (type
) == 0)
1687 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
1689 t
= TYPE_NAME (type
);
1691 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1693 t
= DECL_NAME (TYPE_NAME (type
));
1698 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
1699 CHARS (IDENTIFIER_LENGTH (t
));
1702 /* Output a .stabs for the symbol defined by DECL,
1703 which must be a ..._DECL node in the normal namespace.
1704 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1705 LOCAL is nonzero if the scope is less than the entire file. */
1708 dbxout_symbol (decl
, local
)
1710 int local ATTRIBUTE_UNUSED
;
1712 tree type
= TREE_TYPE (decl
);
1713 tree context
= NULL_TREE
;
1715 /* Cast avoids warning in old compilers. */
1716 current_sym_code
= (STAB_CODE_TYPE
) 0;
1717 current_sym_value
= 0;
1718 current_sym_addr
= 0;
1720 /* Ignore nameless syms, but don't ignore type tags. */
1722 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
1723 || DECL_IGNORED_P (decl
))
1726 dbxout_prepare_symbol (decl
);
1728 /* The output will always start with the symbol name,
1729 so always count that in the length-output-so-far. */
1731 if (DECL_NAME (decl
) != 0)
1732 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
1734 switch (TREE_CODE (decl
))
1737 /* Enum values are defined by defining the enum type. */
1741 if (DECL_RTL (decl
) == 0)
1743 if (DECL_EXTERNAL (decl
))
1745 /* Don't mention a nested function under its parent. */
1746 context
= decl_function_context (decl
);
1747 if (context
== current_function_decl
)
1749 if (GET_CODE (DECL_RTL (decl
)) != MEM
1750 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
1754 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
1755 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1756 TREE_PUBLIC (decl
) ? 'F' : 'f');
1758 current_sym_code
= N_FUN
;
1759 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1761 if (TREE_TYPE (type
))
1762 dbxout_type (TREE_TYPE (type
), 0, 0);
1764 dbxout_type (void_type_node
, 0, 0);
1766 /* For a nested function, when that function is compiled,
1767 mention the containing function name
1768 as well as (since dbx wants it) our own assembler-name. */
1770 fprintf (asmfile
, ",%s,%s",
1771 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1772 IDENTIFIER_POINTER (DECL_NAME (context
)));
1774 dbxout_finish_symbol (decl
);
1779 /* This seems all wrong. Outputting most kinds of types gives no name
1780 at all. A true definition gives no name; a cross-ref for a
1781 structure can give the tag name, but not a type name.
1782 It seems that no typedef name is defined by outputting a type. */
1784 /* If this typedef name was defined by outputting the type,
1785 don't duplicate it. */
1786 if (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
== TYPE_DEFINED
1787 && TYPE_NAME (TREE_TYPE (decl
)) == decl
)
1790 /* Don't output the same typedef twice.
1791 And don't output what language-specific stuff doesn't want output. */
1792 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
1801 if (DECL_NAME (decl
))
1803 /* Nonzero means we must output a tag as well as a typedef. */
1806 /* Handle the case of a C++ structure or union
1807 where the TYPE_NAME is a TYPE_DECL
1808 which gives both a typedef name and a tag. */
1809 /* dbx requires the tag first and the typedef second. */
1810 if ((TREE_CODE (type
) == RECORD_TYPE
1811 || TREE_CODE (type
) == UNION_TYPE
1812 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1813 && TYPE_NAME (type
) == decl
1814 && !(use_gnu_debug_info_extensions
&& have_used_extensions
)
1815 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
1816 /* Distinguish the implicit typedefs of C++
1817 from explicit ones that might be found in C. */
1818 && DECL_ARTIFICIAL (decl
))
1820 tree name
= TYPE_NAME (type
);
1821 if (TREE_CODE (name
) == TYPE_DECL
)
1822 name
= DECL_NAME (name
);
1824 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1825 current_sym_value
= 0;
1826 current_sym_addr
= 0;
1827 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1829 fprintf (asmfile
, "%s \"%s:T", ASM_STABS_OP
,
1830 IDENTIFIER_POINTER (name
));
1831 dbxout_type (type
, 1, 0);
1832 dbxout_finish_symbol (NULL_TREE
);
1835 /* Output typedef name. */
1836 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
,
1837 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1839 /* Short cut way to output a tag also. */
1840 if ((TREE_CODE (type
) == RECORD_TYPE
1841 || TREE_CODE (type
) == UNION_TYPE
1842 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1843 && TYPE_NAME (type
) == decl
1844 /* Distinguish the implicit typedefs of C++
1845 from explicit ones that might be found in C. */
1846 && DECL_ARTIFICIAL (decl
))
1848 if (use_gnu_debug_info_extensions
&& have_used_extensions
)
1850 putc ('T', asmfile
);
1851 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
1853 #if 0 /* Now we generate the tag for this case up above. */
1859 putc ('t', asmfile
);
1860 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1862 dbxout_type (type
, 1, 0);
1863 dbxout_finish_symbol (decl
);
1867 /* Don't output a tag if this is an incomplete type (TYPE_SIZE is
1868 zero). This prevents the sun4 Sun OS 4.x dbx from crashing. */
1870 if (tag_needed
&& TYPE_NAME (type
) != 0
1871 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
1872 || (DECL_NAME (TYPE_NAME (type
)) != 0))
1873 && TYPE_SIZE (type
) != 0
1874 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1876 /* For a TYPE_DECL with no name, but the type has a name,
1878 This is what represents `struct foo' with no typedef. */
1879 /* In C++, the name of a type is the corresponding typedef.
1880 In C, it is an IDENTIFIER_NODE. */
1881 tree name
= TYPE_NAME (type
);
1882 if (TREE_CODE (name
) == TYPE_DECL
)
1883 name
= DECL_NAME (name
);
1885 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1886 current_sym_value
= 0;
1887 current_sym_addr
= 0;
1888 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1890 fprintf (asmfile
, "%s \"%s:T", ASM_STABS_OP
,
1891 IDENTIFIER_POINTER (name
));
1892 dbxout_type (type
, 1, 0);
1893 dbxout_finish_symbol (NULL_TREE
);
1897 /* If an enum type has no name, it cannot be referred to,
1898 but we must output it anyway, since the enumeration constants
1899 can be referred to. */
1900 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
1902 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1903 current_sym_value
= 0;
1904 current_sym_addr
= 0;
1905 current_sym_nchars
= 2;
1907 /* Some debuggers fail when given NULL names, so give this a
1908 harmless name of ` '. */
1909 fprintf (asmfile
, "%s \" :T", ASM_STABS_OP
);
1910 dbxout_type (type
, 1, 0);
1911 dbxout_finish_symbol (NULL_TREE
);
1914 /* Prevent duplicate output of a typedef. */
1915 TREE_ASM_WRITTEN (decl
) = 1;
1920 /* Parm decls go in their own separate chains
1921 and are output by dbxout_reg_parms and dbxout_parms. */
1925 /* Named return value, treat like a VAR_DECL. */
1927 if (DECL_RTL (decl
) == 0)
1929 /* Don't mention a variable that is external.
1930 Let the file that defines it describe it. */
1931 if (DECL_EXTERNAL (decl
))
1934 /* If the variable is really a constant
1935 and not written in memory, inform the debugger. */
1936 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
1937 && DECL_INITIAL (decl
) != 0
1938 && ! TREE_ASM_WRITTEN (decl
)
1939 && (DECL_FIELD_CONTEXT (decl
) == NULL_TREE
1940 || TREE_CODE (DECL_FIELD_CONTEXT (decl
)) == BLOCK
))
1942 if (TREE_PUBLIC (decl
) == 0)
1944 /* The sun4 assembler does not grok this. */
1945 const char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1946 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
1947 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
1949 HOST_WIDE_INT ival
= TREE_INT_CST_LOW (DECL_INITIAL (decl
));
1950 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1951 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile
, name
, ival
);
1953 fprintf (asmfile
, "%s \"%s:c=i", ASM_STABS_OP
, name
);
1955 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, ival
);
1956 fprintf (asmfile
, "\",0x%x,0,0,0\n", N_LSYM
);
1960 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
1962 /* don't know how to do this yet. */
1966 /* else it is something we handle like a normal variable. */
1969 DECL_RTL (decl
) = eliminate_regs (DECL_RTL (decl
), 0, NULL_RTX
);
1970 #ifdef LEAF_REG_REMAP
1971 if (current_function_uses_only_leaf_regs
)
1972 leaf_renumber_regs_insn (DECL_RTL (decl
));
1975 dbxout_symbol_location (decl
, type
, 0, DECL_RTL (decl
));
1983 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1984 Add SUFFIX to its name, if SUFFIX is not 0.
1985 Describe the variable as residing in HOME
1986 (usually HOME is DECL_RTL (DECL), but not always). */
1989 dbxout_symbol_location (decl
, type
, suffix
, home
)
1997 /* Don't mention a variable at all
1998 if it was completely optimized into nothingness.
2000 If the decl was from an inline function, then its rtl
2001 is not identically the rtl that was used in this
2002 particular compilation. */
2003 if (GET_CODE (home
) == REG
)
2005 regno
= REGNO (home
);
2006 if (regno
>= FIRST_PSEUDO_REGISTER
)
2009 else if (GET_CODE (home
) == SUBREG
)
2013 while (GET_CODE (value
) == SUBREG
)
2015 offset
+= SUBREG_WORD (value
);
2016 value
= SUBREG_REG (value
);
2018 if (GET_CODE (value
) == REG
)
2020 regno
= REGNO (value
);
2021 if (regno
>= FIRST_PSEUDO_REGISTER
)
2025 alter_subreg (home
);
2028 /* The kind-of-variable letter depends on where
2029 the variable is and on the scope of its name:
2030 G and N_GSYM for static storage and global scope,
2031 S for static storage and file scope,
2032 V for static storage and local scope,
2033 for those two, use N_LCSYM if data is in bss segment,
2034 N_STSYM if in data segment, N_FUN otherwise.
2035 (We used N_FUN originally, then changed to N_STSYM
2036 to please GDB. However, it seems that confused ld.
2037 Now GDB has been fixed to like N_FUN, says Kingdon.)
2038 no letter at all, and N_LSYM, for auto variable,
2039 r and N_RSYM for register variable. */
2041 if (GET_CODE (home
) == MEM
2042 && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2044 if (TREE_PUBLIC (decl
))
2047 current_sym_code
= N_GSYM
;
2051 current_sym_addr
= XEXP (home
, 0);
2053 letter
= decl_function_context (decl
) ? 'V' : 'S';
2055 /* This should be the same condition as in assemble_variable, but
2056 we don't have access to dont_output_data here. So, instead,
2057 we rely on the fact that error_mark_node initializers always
2058 end up in bss for C++ and never end up in bss for C. */
2059 if (DECL_INITIAL (decl
) == 0
2060 || (!strcmp (lang_identify (), "cplusplus")
2061 && DECL_INITIAL (decl
) == error_mark_node
))
2062 current_sym_code
= N_LCSYM
;
2063 else if (DECL_IN_TEXT_SECTION (decl
))
2064 /* This is not quite right, but it's the closest
2065 of all the codes that Unix defines. */
2066 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
2069 /* Ultrix `as' seems to need this. */
2070 #ifdef DBX_STATIC_STAB_DATA_SECTION
2073 current_sym_code
= N_STSYM
;
2077 else if (regno
>= 0)
2080 current_sym_code
= N_RSYM
;
2081 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
2083 else if (GET_CODE (home
) == MEM
2084 && (GET_CODE (XEXP (home
, 0)) == MEM
2085 || (GET_CODE (XEXP (home
, 0)) == REG
2086 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
2087 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
2088 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2089 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
2092 /* If the value is indirect by memory or by a register
2093 that isn't the frame pointer
2094 then it means the object is variable-sized and address through
2095 that register or stack slot. DBX has no way to represent this
2096 so all we can do is output the variable as a pointer.
2097 If it's not a parameter, ignore it.
2098 (VAR_DECLs like this can be made by integrate.c.) */
2100 if (GET_CODE (XEXP (home
, 0)) == REG
)
2103 current_sym_code
= N_RSYM
;
2104 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
2108 current_sym_code
= N_LSYM
;
2109 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2110 We want the value of that CONST_INT. */
2112 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
2115 /* Effectively do build_pointer_type, but don't cache this type,
2116 since it might be temporary whereas the type it points to
2117 might have been saved for inlining. */
2118 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2119 type
= make_node (POINTER_TYPE
);
2120 TREE_TYPE (type
) = TREE_TYPE (decl
);
2122 else if (GET_CODE (home
) == MEM
2123 && GET_CODE (XEXP (home
, 0)) == REG
)
2125 current_sym_code
= N_LSYM
;
2126 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2128 else if (GET_CODE (home
) == MEM
2129 && GET_CODE (XEXP (home
, 0)) == PLUS
2130 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
2132 current_sym_code
= N_LSYM
;
2133 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2134 We want the value of that CONST_INT. */
2135 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2137 else if (GET_CODE (home
) == MEM
2138 && GET_CODE (XEXP (home
, 0)) == CONST
)
2140 /* Handle an obscure case which can arise when optimizing and
2141 when there are few available registers. (This is *always*
2142 the case for i386/i486 targets). The RTL looks like
2143 (MEM (CONST ...)) even though this variable is a local `auto'
2144 or a local `register' variable. In effect, what has happened
2145 is that the reload pass has seen that all assignments and
2146 references for one such a local variable can be replaced by
2147 equivalent assignments and references to some static storage
2148 variable, thereby avoiding the need for a register. In such
2149 cases we're forced to lie to debuggers and tell them that
2150 this variable was itself `static'. */
2151 current_sym_code
= N_LCSYM
;
2153 current_sym_addr
= XEXP (XEXP (home
, 0), 0);
2155 else if (GET_CODE (home
) == CONCAT
)
2157 tree subtype
= TREE_TYPE (type
);
2159 /* If the variable's storage is in two parts,
2160 output each as a separate stab with a modified name. */
2161 if (WORDS_BIG_ENDIAN
)
2162 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
2164 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
2166 /* Cast avoids warning in old compilers. */
2167 current_sym_code
= (STAB_CODE_TYPE
) 0;
2168 current_sym_value
= 0;
2169 current_sym_addr
= 0;
2170 dbxout_prepare_symbol (decl
);
2172 if (WORDS_BIG_ENDIAN
)
2173 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
2175 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
2179 /* Address might be a MEM, when DECL is a variable-sized object.
2180 Or it might be const0_rtx, meaning previous passes
2181 want us to ignore this variable. */
2184 /* Ok, start a symtab entry and output the variable name. */
2187 #ifdef DBX_STATIC_BLOCK_START
2188 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
2191 dbxout_symbol_name (decl
, suffix
, letter
);
2192 dbxout_type (type
, 0, 0);
2193 dbxout_finish_symbol (decl
);
2195 #ifdef DBX_STATIC_BLOCK_END
2196 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
2200 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2201 Then output LETTER to indicate the kind of location the symbol has. */
2204 dbxout_symbol_name (decl
, suffix
, letter
)
2209 /* One slight hitch: if this is a VAR_DECL which is a static
2210 class member, we must put out the mangled name instead of the
2211 DECL_NAME. Note also that static member (variable) names DO NOT begin
2212 with underscores in .stabs directives. */
2213 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2216 fprintf (asmfile
, "%s \"%s%s:", ASM_STABS_OP
, name
,
2217 (suffix
? suffix
: ""));
2219 if (letter
) putc (letter
, asmfile
);
2223 dbxout_prepare_symbol (decl
)
2224 tree decl ATTRIBUTE_UNUSED
;
2227 const char *filename
= DECL_SOURCE_FILE (decl
);
2229 dbxout_source_file (asmfile
, filename
);
2234 dbxout_finish_symbol (sym
)
2237 #ifdef DBX_FINISH_SYMBOL
2238 DBX_FINISH_SYMBOL (sym
);
2241 if (use_gnu_debug_info_extensions
&& sym
!= 0)
2242 line
= DECL_SOURCE_LINE (sym
);
2244 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
2245 if (current_sym_addr
)
2246 output_addr_const (asmfile
, current_sym_addr
);
2248 fprintf (asmfile
, "%d", current_sym_value
);
2249 putc ('\n', asmfile
);
2253 /* Output definitions of all the decls in a chain. */
2261 dbxout_symbol (syms
, 1);
2262 syms
= TREE_CHAIN (syms
);
2266 /* The following two functions output definitions of function parameters.
2267 Each parameter gets a definition locating it in the parameter list.
2268 Each parameter that is a register variable gets a second definition
2269 locating it in the register.
2271 Printing or argument lists in gdb uses the definitions that
2272 locate in the parameter list. But reference to the variable in
2273 expressions uses preferentially the definition as a register. */
2275 /* Output definitions, referring to storage in the parmlist,
2276 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2279 dbxout_parms (parms
)
2282 for (; parms
; parms
= TREE_CHAIN (parms
))
2283 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
2285 dbxout_prepare_symbol (parms
);
2287 /* Perform any necessary register eliminations on the parameter's rtl,
2288 so that the debugging output will be accurate. */
2289 DECL_INCOMING_RTL (parms
)
2290 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
2291 DECL_RTL (parms
) = eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
);
2292 #ifdef LEAF_REG_REMAP
2293 if (current_function_uses_only_leaf_regs
)
2295 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
2296 leaf_renumber_regs_insn (DECL_RTL (parms
));
2300 if (PARM_PASSED_IN_MEMORY (parms
))
2302 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
2304 /* ??? Here we assume that the parm address is indexed
2305 off the frame pointer or arg pointer.
2306 If that is not true, we produce meaningless results,
2307 but do not crash. */
2308 if (GET_CODE (addr
) == PLUS
2309 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
2310 current_sym_value
= INTVAL (XEXP (addr
, 1));
2312 current_sym_value
= 0;
2314 current_sym_code
= N_PSYM
;
2315 current_sym_addr
= 0;
2318 if (DECL_NAME (parms
))
2320 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2322 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2323 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2324 DBX_MEMPARM_STABS_LETTER
);
2328 current_sym_nchars
= 8;
2329 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2330 DBX_MEMPARM_STABS_LETTER
);
2333 /* It is quite tempting to use:
2335 dbxout_type (TREE_TYPE (parms), 0, 0);
2337 as the next statement, rather than using DECL_ARG_TYPE(), so
2338 that gcc reports the actual type of the parameter, rather
2339 than the promoted type. This certainly makes GDB's life
2340 easier, at least for some ports. The change is a bad idea
2341 however, since GDB expects to be able access the type without
2342 performing any conversions. So for example, if we were
2343 passing a float to an unprototyped function, gcc will store a
2344 double on the stack, but if we emit a stab saying the type is a
2345 float, then gdb will only read in a single value, and this will
2346 produce an erropneous value. */
2347 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
2348 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
2349 dbxout_finish_symbol (parms
);
2351 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
2354 char regparm_letter
;
2356 /* Parm passed in registers and lives in registers or nowhere. */
2358 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2359 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2360 current_sym_addr
= 0;
2362 /* If parm lives in a register, use that register;
2363 pretend the parm was passed there. It would be more consistent
2364 to describe the register where the parm was passed,
2365 but in practice that register usually holds something else.
2367 If we use DECL_RTL, then we must use the declared type of
2368 the variable, not the type that it arrived in. */
2369 if (REGNO (DECL_RTL (parms
)) >= 0
2370 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2372 best_rtl
= DECL_RTL (parms
);
2373 parm_type
= TREE_TYPE (parms
);
2375 /* If the parm lives nowhere, use the register where it was
2376 passed. It is also better to use the declared type here. */
2379 best_rtl
= DECL_INCOMING_RTL (parms
);
2380 parm_type
= TREE_TYPE (parms
);
2382 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
2385 if (DECL_NAME (parms
))
2387 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2388 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2389 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2394 current_sym_nchars
= 8;
2395 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2399 dbxout_type (parm_type
, 0, 0);
2400 dbxout_finish_symbol (parms
);
2402 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2403 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
2404 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
2405 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
2406 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2407 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
2411 /* Parm was passed via invisible reference.
2412 That is, its address was passed in a register.
2413 Output it as if it lived in that register.
2414 The debugger will know from the type
2415 that it was actually passed by invisible reference. */
2417 char regparm_letter
;
2418 /* Parm passed in registers and lives in registers or nowhere. */
2420 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2421 if (use_gnu_debug_info_extensions
)
2422 regparm_letter
= GDB_INV_REF_REGPARM_STABS_LETTER
;
2424 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2426 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2427 If it is an unallocated pseudo-reg, then use the register where
2428 it was passed instead. */
2429 if (REGNO (XEXP (DECL_RTL (parms
), 0)) >= 0
2430 && REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
2431 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
2433 current_sym_value
= REGNO (DECL_INCOMING_RTL (parms
));
2435 current_sym_addr
= 0;
2438 if (DECL_NAME (parms
))
2440 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2442 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2443 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2448 current_sym_nchars
= 8;
2449 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2453 dbxout_type (TREE_TYPE (parms
), 0, 0);
2454 dbxout_finish_symbol (parms
);
2456 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2457 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
2458 /* ??? A constant address for a parm can happen
2459 when the reg it lives in is equiv to a constant in memory.
2460 Should make this not happen, after 2.4. */
2461 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
2463 /* Parm was passed in registers but lives on the stack. */
2464 int aux_sym_value
= 0;
2466 current_sym_code
= N_PSYM
;
2467 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2468 in which case we want the value of that CONST_INT,
2469 or (MEM (REG ...)) or (MEM (MEM ...)),
2470 in which case we use a value of zero. */
2471 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
)
2472 current_sym_value
= 0;
2473 else if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
2475 /* Remember the location on the stack the parm is moved to */
2477 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
2478 current_sym_value
= 0;
2482 = INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
2484 current_sym_addr
= 0;
2486 /* Make a big endian correction if the mode of the type of the
2487 parameter is not the same as the mode of the rtl. */
2488 if (BYTES_BIG_ENDIAN
2489 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
2490 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
2492 current_sym_value
+= UNITS_PER_WORD
- GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
)));
2496 if (DECL_NAME (parms
))
2499 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2501 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2502 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2503 DBX_MEMPARM_STABS_LETTER
);
2507 current_sym_nchars
= 8;
2508 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2509 DBX_MEMPARM_STABS_LETTER
);
2513 = DEBUGGER_ARG_OFFSET (current_sym_value
,
2514 XEXP (DECL_RTL (parms
), 0));
2515 dbxout_type (TREE_TYPE (parms
), 0, 0);
2516 dbxout_finish_symbol (parms
);
2517 if (aux_sym_value
!= 0)
2519 /* Generate an entry for the stack location */
2521 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
,
2522 IDENTIFIER_POINTER (DECL_NAME (parms
)));
2523 current_sym_value
= aux_sym_value
;
2524 current_sym_code
= N_LSYM
;
2525 dbxout_type (build_reference_type (TREE_TYPE (parms
)), 0, 0);
2526 dbxout_finish_symbol (parms
);
2532 /* Output definitions for the places where parms live during the function,
2533 when different from where they were passed, when the parms were passed
2536 It is not useful to do this for parms passed in registers
2537 that live during the function in different registers, because it is
2538 impossible to look in the passed register for the passed value,
2539 so we use the within-the-function register to begin with.
2541 PARMS is a chain of PARM_DECL nodes. */
2544 dbxout_reg_parms (parms
)
2547 for (; parms
; parms
= TREE_CHAIN (parms
))
2548 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
2550 dbxout_prepare_symbol (parms
);
2552 /* Report parms that live in registers during the function
2553 but were passed in memory. */
2554 if (GET_CODE (DECL_RTL (parms
)) == REG
2555 && REGNO (DECL_RTL (parms
)) >= 0
2556 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2557 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2558 0, DECL_RTL (parms
));
2559 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
2560 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2561 0, DECL_RTL (parms
));
2562 /* Report parms that live in memory but not where they were passed. */
2563 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2564 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
2565 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2566 0, DECL_RTL (parms
));
2570 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2571 output definitions of those names, in raw form */
2579 putc (',', asmfile
);
2580 dbxout_type (TREE_VALUE (args
), 0, 0);
2582 args
= TREE_CHAIN (args
);
2586 /* Given a chain of ..._TYPE nodes,
2587 find those which have typedef names and output those names.
2588 This is to ensure those types get output. */
2591 dbxout_types (types
)
2592 register tree types
;
2596 if (TYPE_NAME (types
)
2597 && TREE_CODE (TYPE_NAME (types
)) == TYPE_DECL
2598 && ! TREE_ASM_WRITTEN (TYPE_NAME (types
)))
2599 dbxout_symbol (TYPE_NAME (types
), 1);
2600 types
= TREE_CHAIN (types
);
2604 /* Output everything about a symbol block (a BLOCK node
2605 that represents a scope level),
2606 including recursive output of contained blocks.
2608 BLOCK is the BLOCK node.
2609 DEPTH is its depth within containing symbol blocks.
2610 ARGS is usually zero; but for the outermost block of the
2611 body of a function, it is a chain of PARM_DECLs for the function parameters.
2612 We output definitions of all the register parms
2613 as if they were local variables of that block.
2615 If -g1 was used, we count blocks just the same, but output nothing
2616 except for the outermost block.
2618 Actually, BLOCK may be several blocks chained together.
2619 We handle them all in sequence. */
2622 dbxout_block (block
, depth
, args
)
2623 register tree block
;
2631 /* Ignore blocks never expanded or otherwise marked as real. */
2632 if (TREE_USED (block
))
2634 #ifndef DBX_LBRAC_FIRST
2635 /* In dbx format, the syms of a block come before the N_LBRAC. */
2636 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2637 dbxout_syms (BLOCK_VARS (block
));
2639 dbxout_reg_parms (args
);
2642 /* Now output an N_LBRAC symbol to represent the beginning of
2643 the block. Use the block's tree-walk order to generate
2644 the assembler symbols LBBn and LBEn
2645 that final will define around the code in this block. */
2646 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2649 blocknum
= next_block_number
++;
2650 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
2652 if (BLOCK_HANDLER_BLOCK (block
))
2654 /* A catch block. Must precede N_LBRAC. */
2655 tree decl
= BLOCK_VARS (block
);
2658 #ifdef DBX_OUTPUT_CATCH
2659 DBX_OUTPUT_CATCH (asmfile
, decl
, buf
);
2661 fprintf (asmfile
, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP
,
2662 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
2663 assemble_name (asmfile
, buf
);
2664 fprintf (asmfile
, "\n");
2666 decl
= TREE_CHAIN (decl
);
2670 #ifdef DBX_OUTPUT_LBRAC
2671 DBX_OUTPUT_LBRAC (asmfile
, buf
);
2673 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_LBRAC
);
2674 assemble_name (asmfile
, buf
);
2675 #if DBX_BLOCKS_FUNCTION_RELATIVE
2676 fputc ('-', asmfile
);
2677 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
2679 fprintf (asmfile
, "\n");
2683 /* Count blocks the same way regardless of debug_info_level. */
2684 next_block_number
++;
2686 #ifdef DBX_LBRAC_FIRST
2687 /* On some weird machines, the syms of a block
2688 come after the N_LBRAC. */
2689 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2690 dbxout_syms (BLOCK_VARS (block
));
2692 dbxout_reg_parms (args
);
2695 /* Output the subblocks. */
2696 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
2698 /* Refer to the marker for the end of the block. */
2699 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2702 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
2703 #ifdef DBX_OUTPUT_RBRAC
2704 DBX_OUTPUT_RBRAC (asmfile
, buf
);
2706 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_RBRAC
);
2707 assemble_name (asmfile
, buf
);
2708 #if DBX_BLOCKS_FUNCTION_RELATIVE
2709 fputc ('-', asmfile
);
2710 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
2712 fprintf (asmfile
, "\n");
2716 block
= BLOCK_CHAIN (block
);
2720 /* Output the information about a function and its arguments and result.
2721 Usually this follows the function's code,
2722 but on some systems, it comes before. */
2725 dbxout_really_begin_function (decl
)
2728 dbxout_symbol (decl
, 0);
2729 dbxout_parms (DECL_ARGUMENTS (decl
));
2730 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
2731 dbxout_symbol (DECL_RESULT (decl
), 1);
2734 /* Called at beginning of output of function definition. */
2737 dbxout_begin_function (decl
)
2738 tree decl ATTRIBUTE_UNUSED
;
2740 #ifdef DBX_FUNCTION_FIRST
2741 dbxout_really_begin_function (decl
);
2745 /* Output dbx data for a function definition.
2746 This includes a definition of the function name itself (a symbol),
2747 definitions of the parameters (locating them in the parameter list)
2748 and then output the block that makes up the function's body
2749 (including all the auto variables of the function). */
2752 dbxout_function (decl
)
2755 #ifndef DBX_FUNCTION_FIRST
2756 dbxout_really_begin_function (decl
);
2758 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
2759 #ifdef DBX_OUTPUT_FUNCTION_END
2760 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
2762 #if defined(ASM_OUTPUT_SECTION_NAME)
2763 if (use_gnu_debug_info_extensions
2764 #if defined(NO_DBX_FUNCTION_END)
2765 && ! NO_DBX_FUNCTION_END
2768 dbxout_function_end ();
2771 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */