1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987, 88, 92, 93, 94, 95, 1996 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'. */
70 /* Include these first, because they may define MIN and MAX. */
79 #include "insn-config.h"
82 #include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions. */
88 #ifdef XCOFF_DEBUGGING_INFO
93 #define ASM_STABS_OP ".stabs"
97 #define ASM_STABN_OP ".stabn"
100 #ifndef DBX_TYPE_DECL_STABS_CODE
101 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
104 #ifndef DBX_STATIC_CONST_VAR_CODE
105 #define DBX_STATIC_CONST_VAR_CODE N_FUN
108 #ifndef DBX_REGPARM_STABS_CODE
109 #define DBX_REGPARM_STABS_CODE N_RSYM
112 #ifndef DBX_REGPARM_STABS_LETTER
113 #define DBX_REGPARM_STABS_LETTER 'P'
116 /* This is used for parameters passed by invisible reference in a register. */
117 #ifndef GDB_INV_REF_REGPARM_STABS_LETTER
118 #define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
121 #ifndef DBX_MEMPARM_STABS_LETTER
122 #define DBX_MEMPARM_STABS_LETTER 'p'
125 #ifndef FILE_NAME_JOINER
126 #define FILE_NAME_JOINER "/"
129 /* Nonzero means if the type has methods, only output debugging
130 information if methods are actually written to the asm file. This
131 optimization only works if the debugger can detect the special C++
134 #define MINIMAL_DEBUG 1
136 #ifdef NO_DOLLAR_IN_LABEL
137 #ifdef NO_DOT_IN_LABEL
139 #define MINIMAL_DEBUG 0
143 static int flag_minimal_debug
= MINIMAL_DEBUG
;
145 /* Nonzero if we have actually used any of the GDB extensions
146 to the debugging format. The idea is that we use them for the
147 first time only if there's a strong reason, but once we have done that,
148 we use them whenever convenient. */
150 static int have_used_extensions
= 0;
152 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
153 for the N_SO filename stabs label. */
155 static int source_label_number
= 1;
159 /* Typical USG systems don't have stab.h, and they also have
160 no use for DBX-format debugging info. */
162 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
164 #ifdef DEBUG_SYMS_TEXT
165 #define FORCE_TEXT text_section ();
170 #if defined (USG) || defined (NO_STAB_H) || defined (CROSS_COMPILE)
171 #include "gstab.h" /* If doing DBX on sysV, use our own stab.h. */
173 #include <stab.h> /* On BSD, use the system's 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 ();
325 static void dbxout_type_name ();
326 static void dbxout_type ();
327 static void dbxout_typedefs ();
328 static void dbxout_symbol_name ();
329 static void dbxout_symbol_location ();
330 static void dbxout_prepare_symbol ();
331 static void dbxout_finish_symbol ();
332 static void dbxout_type_index ();
333 static void dbxout_continue ();
334 static void print_int_cst_octal ();
335 static void print_octal ();
337 #if 0 /* Not clear we will actually need this. */
339 /* Return the absolutized filename for the given relative
340 filename. Note that if that filename is already absolute, it may
341 still be returned in a modified form because this routine also
342 eliminates redundant slashes and single dots and eliminates double
343 dots to get a shortest possible filename from the given input
344 filename. The absolutization of relative filenames is made by
345 assuming that the given filename is to be taken as relative to
346 the first argument (cwd) or to the current directory if cwd is
350 abspath (rel_filename
)
353 /* Setup the current working directory as needed. */
355 = (char *) alloca (strlen (cwd
) + strlen (rel_filename
) + 1);
356 char *endp
= abs_buffer
;
360 /* Copy the filename (possibly preceded by the current working
361 directory name) into the absolutization buffer. */
366 if (rel_filename
[0] != '/')
369 while (*endp
++ = *src_p
++)
371 *(endp
-1) = '/'; /* overwrite null */
373 src_p
= rel_filename
;
374 while (*endp
++ = *src_p
++)
379 /* Now make a copy of abs_buffer into abs_buffer, shortening the
380 filename (by taking out slashes and dots) as we go. */
382 outp
= inp
= abs_buffer
;
383 *outp
++ = *inp
++; /* copy first slash */
388 else if (inp
[0] == '/' && outp
[-1] == '/')
393 else if (inp
[0] == '.' && outp
[-1] == '/')
397 else if (inp
[1] == '/')
402 else if ((inp
[1] == '.') && (inp
[2] == 0 || inp
[2] == '/'))
404 inp
+= (inp
[2] == '/') ? 3 : 2;
406 while (outp
>= abs_buffer
&& *outp
!= '/')
408 if (outp
< abs_buffer
)
410 /* Catch cases like /.. where we try to backup to a
411 point above the absolute root of the logical file
414 fprintf (stderr
, "%s: invalid file name: %s\n",
415 pname
, rel_filename
);
425 /* On exit, make sure that there is a trailing null, and make sure that
426 the last character of the returned string is *not* a slash. */
432 /* Make a copy (in the heap) of the stuff left in the absolutization
433 buffer and return a pointer to the copy. */
435 value
= (char *) oballoc (strlen (abs_buffer
) + 1);
436 strcpy (value
, abs_buffer
);
441 /* At the beginning of compilation, start writing the symbol table.
442 Initialize `typevec' and output the standard data types of C. */
445 dbxout_init (asm_file
, input_file_name
, syms
)
447 char *input_file_name
;
450 char ltext_label_name
[100];
455 typevec
= (struct typeinfo
*) xmalloc (typevec_len
* sizeof typevec
[0]);
456 bzero ((char *) typevec
, typevec_len
* sizeof typevec
[0]);
458 /* Convert Ltext into the appropriate format for local labels in case
459 the system doesn't insert underscores in front of user generated
461 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
463 /* Put the current working directory in an N_SO symbol. */
464 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
465 but GDB always does. */
466 if (use_gnu_debug_info_extensions
)
469 if (!cwd
&& (cwd
= getpwd ()) && (!*cwd
|| cwd
[strlen (cwd
) - 1] != '/'))
471 char *wdslash
= xmalloc (strlen (cwd
) + sizeof (FILE_NAME_JOINER
));
472 sprintf (wdslash
, "%s%s", cwd
, FILE_NAME_JOINER
);
477 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
478 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile
, cwd
);
479 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
480 fprintf (asmfile
, "%s ", ASM_STABS_OP
);
481 output_quoted_string (asmfile
, cwd
);
482 fprintf (asmfile
, ",%d,0,0,%s\n", N_SO
, <ext_label_name
[1]);
483 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
487 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
488 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
489 would give us an N_SOL, and we want an N_SO. */
490 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile
, input_file_name
);
491 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
492 /* We include outputting `Ltext:' here,
493 because that gives you a way to override it. */
494 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
495 fprintf (asmfile
, "%s ", ASM_STABS_OP
);
496 output_quoted_string (asmfile
, input_file_name
);
497 fprintf (asmfile
, ",%d,0,0,%s\n",
498 N_SO
, <ext_label_name
[1]);
500 ASM_OUTPUT_INTERNAL_LABEL (asmfile
, "Ltext", 0);
501 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
503 /* Possibly output something to inform GDB that this compilation was by
504 GCC. It's easier for GDB to parse it when after the N_SO's. This
505 is used in Solaris 2. */
506 #ifdef ASM_IDENTIFY_GCC_AFTER_SOURCE
507 ASM_IDENTIFY_GCC_AFTER_SOURCE (asmfile
);
510 lastfile
= input_file_name
;
512 next_type_number
= 1;
513 next_block_number
= 2;
516 current_file
= (struct dbx_file
*) xmalloc (sizeof *current_file
);
517 current_file
->next
= NULL
;
518 current_file
->file_number
= 0;
519 current_file
->next_type_number
= 1;
520 next_file_number
= 1;
523 /* Make sure that types `int' and `char' have numbers 1 and 2.
524 Definitions of other integer types will refer to those numbers.
525 (Actually it should no longer matter what their numbers are.
526 Also, if any types with tags have been defined, dbxout_symbol
527 will output them first, so the numbers won't be 1 and 2. That
528 happens in C++. So it's a good thing it should no longer matter). */
530 #ifdef DBX_OUTPUT_STANDARD_TYPES
531 DBX_OUTPUT_STANDARD_TYPES (syms
);
533 dbxout_symbol (TYPE_NAME (integer_type_node
), 0);
534 dbxout_symbol (TYPE_NAME (char_type_node
), 0);
537 /* Get all permanent types that have typedef names,
538 and output them all, except for those already output. */
540 dbxout_typedefs (syms
);
543 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
544 in the reverse order from that which is found in SYMS. */
547 dbxout_typedefs (syms
)
552 dbxout_typedefs (TREE_CHAIN (syms
));
553 if (TREE_CODE (syms
) == TYPE_DECL
)
555 tree type
= TREE_TYPE (syms
);
557 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
558 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
559 dbxout_symbol (TYPE_NAME (type
), 0);
564 /* Change to reading from a new source file. Generate a N_BINCL stab. */
567 dbxout_start_new_source_file (filename
)
571 struct dbx_file
*n
= (struct dbx_file
*) xmalloc (sizeof *n
);
573 n
->next
= current_file
;
574 n
->file_number
= next_file_number
++;
575 n
->next_type_number
= 1;
577 fprintf (asmfile
, "%s \"%s\",%d,0,0,0\n", ASM_STABS_OP
, filename
, N_BINCL
);
581 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
584 dbxout_resume_previous_source_file ()
587 struct dbx_file
*next
;
589 fprintf (asmfile
, "%s %d,0,0,0\n", ASM_STABN_OP
, N_EINCL
);
590 next
= current_file
->next
;
596 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
599 dbxout_source_file (file
, filename
)
603 char ltext_label_name
[100];
605 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
607 #ifdef DBX_OUTPUT_SOURCE_FILENAME
608 DBX_OUTPUT_SOURCE_FILENAME (file
, filename
);
610 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext",
611 source_label_number
);
612 fprintf (file
, "%s ", ASM_STABS_OP
);
613 output_quoted_string (file
, filename
);
614 fprintf (file
, ",%d,0,0,%s\n", N_SOL
, <ext_label_name
[1]);
615 if (current_function_decl
!= NULL_TREE
616 && DECL_SECTION_NAME (current_function_decl
) != NULL_TREE
)
617 ; /* Don't change section amid function. */
620 ASM_OUTPUT_INTERNAL_LABEL (file
, "Ltext", source_label_number
);
621 source_label_number
++;
627 /* Output a line number symbol entry into output stream FILE,
628 for source file FILENAME and line number LINENO. */
631 dbxout_source_line (file
, filename
, lineno
)
636 dbxout_source_file (file
, filename
);
638 #ifdef ASM_OUTPUT_SOURCE_LINE
639 ASM_OUTPUT_SOURCE_LINE (file
, lineno
);
641 fprintf (file
, "\t%s %d,0,%d\n", ASM_STABD_OP
, N_SLINE
, lineno
);
645 /* At the end of compilation, finish writing the symbol table.
646 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
650 dbxout_finish (file
, filename
)
654 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
655 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file
, filename
);
656 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
659 /* Output the index of a type. */
662 dbxout_type_index (type
)
665 #ifndef DBX_USE_BINCL
666 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
669 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
670 fprintf (asmfile
, "(%d,%d)", t
->file_number
, t
->type_number
);
675 /* Continue a symbol-description that gets too big.
676 End one symbol table entry with a double-backslash
677 and start a new one, eventually producing something like
678 .stabs "start......\\",code,0,value
679 .stabs "...rest",code,0,value */
684 #ifdef DBX_CONTIN_CHAR
685 fprintf (asmfile
, "%c", DBX_CONTIN_CHAR
);
687 fprintf (asmfile
, "\\\\");
689 dbxout_finish_symbol (NULL_TREE
);
690 fprintf (asmfile
, "%s \"", ASM_STABS_OP
);
691 current_sym_nchars
= 0;
694 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
695 This must be a separate function because anonymous unions require
699 dbxout_type_fields (type
)
703 /* Output the name, type, position (in bits), size (in bits) of each
705 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
707 /* Omit here local type decls until we know how to support them. */
708 if (TREE_CODE (tem
) == TYPE_DECL
)
710 /* Omit fields whose position or size are variable. */
711 else if (TREE_CODE (tem
) == FIELD_DECL
712 && (TREE_CODE (DECL_FIELD_BITPOS (tem
)) != INTEGER_CST
713 || TREE_CODE (DECL_SIZE (tem
)) != INTEGER_CST
))
715 /* Omit here the nameless fields that are used to skip bits. */
716 else if (TREE_CODE (tem
) != CONST_DECL
)
718 /* Continue the line if necessary,
719 but not before the first field. */
720 if (tem
!= TYPE_FIELDS (type
))
723 if (use_gnu_debug_info_extensions
724 && flag_minimal_debug
725 && TREE_CODE (tem
) == FIELD_DECL
726 && DECL_VIRTUAL_P (tem
)
727 && DECL_ASSEMBLER_NAME (tem
))
729 have_used_extensions
= 1;
730 CHARS (3 + IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (tem
)));
731 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
)), asmfile
);
732 dbxout_type (DECL_FCONTEXT (tem
), 0, 0);
733 fprintf (asmfile
, ":");
734 dbxout_type (TREE_TYPE (tem
), 0, 0);
735 fprintf (asmfile
, ",%d;",
736 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem
)));
742 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem
)));
743 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem
)));
747 fprintf (asmfile
, ":");
751 if (use_gnu_debug_info_extensions
752 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
753 || TREE_CODE (tem
) != FIELD_DECL
))
755 have_used_extensions
= 1;
757 putc ((TREE_PRIVATE (tem
) ? '0'
758 : TREE_PROTECTED (tem
) ? '1' : '2'),
763 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
764 && DECL_BIT_FIELD_TYPE (tem
))
765 ? DECL_BIT_FIELD_TYPE (tem
)
766 : TREE_TYPE (tem
), 0, 0);
768 if (TREE_CODE (tem
) == VAR_DECL
)
770 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
772 char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem
));
773 have_used_extensions
= 1;
774 fprintf (asmfile
, ":%s;", name
);
775 CHARS (strlen (name
));
779 /* If TEM is non-static, GDB won't understand it. */
780 fprintf (asmfile
, ",0,0;");
783 else if (TREE_CODE (DECL_FIELD_BITPOS (tem
)) == INTEGER_CST
)
785 fprintf (asmfile
, ",%d,%d;",
786 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem
)),
787 TREE_INT_CST_LOW (DECL_SIZE (tem
)));
794 /* Subroutine of `dbxout_type_methods'. Output debug info about the
795 method described DECL. DEBUG_NAME is an encoding of the method's
796 type signature. ??? We may be able to do without DEBUG_NAME altogether
800 dbxout_type_method_1 (decl
, debug_name
)
806 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
808 else /* it's a METHOD_TYPE. */
810 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
811 /* A for normal functions.
812 B for `const' member functions.
813 C for `volatile' member functions.
814 D for `const volatile' member functions. */
815 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
817 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
820 if (DECL_VINDEX (decl
))
826 fprintf (asmfile
, ":%s;%c%c%c", debug_name
,
827 TREE_PRIVATE (decl
) ? '0' : TREE_PROTECTED (decl
) ? '1' : '2', c1
, c2
);
828 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
)) + 6
829 - (debug_name
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
830 if (DECL_VINDEX (decl
))
832 fprintf (asmfile
, "%d;",
833 TREE_INT_CST_LOW (DECL_VINDEX (decl
)));
834 dbxout_type (DECL_CONTEXT (decl
), 0, 0);
835 fprintf (asmfile
, ";");
840 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
844 dbxout_type_methods (type
)
847 /* C++: put out the method names and their parameter lists */
848 tree methods
= TYPE_METHODS (type
);
850 register tree fndecl
;
852 char formatted_type_identifier_length
[16];
853 register int type_identifier_length
;
855 if (methods
== NULL_TREE
)
858 type_encoding
= DECL_NAME (TYPE_NAME (type
));
861 /* C++: Template classes break some assumptions made by this code about
862 the class names, constructor names, and encodings for assembler
863 label names. For now, disable output of dbx info for them. */
865 char *ptr
= IDENTIFIER_POINTER (type_encoding
);
866 /* This should use index. (mrs) */
867 while (*ptr
&& *ptr
!= '<') ptr
++;
874 #ifdef HAVE_TEMPLATES
875 if (warn_template_debugging
)
876 warning ("dbx info for template class methods not yet supported");
884 type_identifier_length
= IDENTIFIER_LENGTH (type_encoding
);
886 sprintf(formatted_type_identifier_length
, "%d", type_identifier_length
);
888 if (TREE_CODE (methods
) == FUNCTION_DECL
)
890 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
891 fndecl
= TREE_VEC_ELT (methods
, 0);
893 fndecl
= TREE_VEC_ELT (methods
, 1);
897 tree name
= DECL_NAME (fndecl
);
900 /* Group together all the methods for the same operation.
901 These differ in the types of the arguments. */
902 for (last
= NULL_TREE
;
903 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
904 fndecl
= TREE_CHAIN (fndecl
))
905 /* Output the name of the field (after overloading), as
906 well as the name of the field before overloading, along
907 with its parameter list */
909 /* This is the "mangled" name of the method.
910 It encodes the argument types. */
911 char *debug_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
));
912 int show_arg_types
= 0;
918 if (DECL_IGNORED_P (fndecl
))
921 if (flag_minimal_debug
)
925 /* We can't optimize a method which uses an anonymous
926 class, because the debugger will not be able to
927 associate the arbitrary class name with the actual
929 #ifndef NO_DOLLAR_IN_LABEL
934 if (strchr (debug_name
, marker
))
936 /* Detect ordinary methods because their mangled names
937 start with the operation name. */
938 else if (!strncmp (IDENTIFIER_POINTER (name
), debug_name
,
939 IDENTIFIER_LENGTH (name
)))
941 debug_name
+= IDENTIFIER_LENGTH (name
);
942 if (debug_name
[0] == '_' && debug_name
[1] == '_')
944 char *method_name
= debug_name
+ 2;
945 char *length_ptr
= formatted_type_identifier_length
;
946 /* Get past const and volatile qualifiers. */
947 while (*method_name
== 'C' || *method_name
== 'V')
949 /* Skip digits for length of type_encoding. */
950 while (*method_name
== *length_ptr
&& *length_ptr
)
951 length_ptr
++, method_name
++;
952 if (! strncmp (method_name
,
953 IDENTIFIER_POINTER (type_encoding
),
954 type_identifier_length
))
955 method_name
+= type_identifier_length
;
956 debug_name
= method_name
;
959 /* Detect constructors by their style of name mangling. */
960 else if (debug_name
[0] == '_' && debug_name
[1] == '_')
962 char *ctor_name
= debug_name
+ 2;
963 char *length_ptr
= formatted_type_identifier_length
;
964 while (*ctor_name
== 'C' || *ctor_name
== 'V')
966 /* Skip digits for length of type_encoding. */
967 while (*ctor_name
== *length_ptr
&& *length_ptr
)
968 length_ptr
++, ctor_name
++;
969 if (!strncmp (IDENTIFIER_POINTER (type_encoding
), ctor_name
,
970 type_identifier_length
))
971 debug_name
= ctor_name
+ type_identifier_length
;
973 /* The other alternative is a destructor. */
977 /* Output the operation name just once, for the first method
981 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (name
));
982 CHARS (IDENTIFIER_LENGTH (name
) + 2);
987 dbxout_type (TREE_TYPE (fndecl
), 0, show_arg_types
);
989 dbxout_type_method_1 (fndecl
, debug_name
);
999 /* Emit a "range" type specification, which has the form:
1000 "r<index type>;<lower bound>;<upper bound>;".
1001 TYPE is an INTEGER_TYPE. */
1004 dbxout_range_type (type
)
1007 fprintf (asmfile
, "r");
1008 if (TREE_TYPE (type
))
1009 dbxout_type (TREE_TYPE (type
), 0, 0);
1010 else if (TREE_CODE (type
) != INTEGER_TYPE
)
1011 dbxout_type (type
, 0, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1014 /* Traditionally, we made sure 'int' was type 1, and builtin types
1015 were defined to be sub-ranges of int. Unfortunately, this
1016 does not allow us to distinguish true sub-ranges from integer
1017 types. So, instead we define integer (non-sub-range) types as
1018 sub-ranges of themselves. */
1019 dbxout_type_index (type
);
1021 if (TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
)
1022 fprintf (asmfile
, ";%d",
1023 TREE_INT_CST_LOW (TYPE_MIN_VALUE (type
)));
1025 fprintf (asmfile
, ";0");
1026 if (TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
)
1027 fprintf (asmfile
, ";%d;",
1028 TREE_INT_CST_LOW (TYPE_MAX_VALUE (type
)));
1030 fprintf (asmfile
, ";-1;");
1033 /* Output a reference to a type. If the type has not yet been
1034 described in the dbx output, output its definition now.
1035 For a type already defined, just refer to its definition
1036 using the type number.
1038 If FULL is nonzero, and the type has been described only with
1039 a forward-reference, output the definition now.
1040 If FULL is zero in this case, just refer to the forward-reference
1041 using the number previously allocated.
1043 If SHOW_ARG_TYPES is nonzero, we output a description of the argument
1044 types for a METHOD_TYPE. */
1047 dbxout_type (type
, full
, show_arg_types
)
1053 static int anonymous_type_number
= 0;
1055 /* If there was an input error and we don't really have a type,
1056 avoid crashing and write something that is at least valid
1057 by assuming `int'. */
1058 if (type
== error_mark_node
)
1059 type
= integer_type_node
;
1060 else if (!(TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1061 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
))))
1063 type
= TYPE_MAIN_VARIANT (type
);
1064 if (TYPE_NAME (type
)
1065 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1066 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1070 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1072 /* Type has no dbx number assigned. Assign next available number. */
1073 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1075 /* Make sure type vector is long enough to record about this type. */
1077 if (next_type_number
== typevec_len
)
1080 (struct typeinfo
*) xrealloc (typevec
,
1081 typevec_len
* 2 * sizeof typevec
[0]);
1082 bzero ((char *) (typevec
+ typevec_len
),
1083 typevec_len
* sizeof typevec
[0]);
1087 #ifdef DBX_USE_BINCL
1088 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
=
1089 current_file
->file_number
;
1090 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
=
1091 current_file
->next_type_number
++;
1095 /* Output the number of this type, to refer to it. */
1096 dbxout_type_index (type
);
1098 #ifdef DBX_TYPE_DEFINED
1099 if (DBX_TYPE_DEFINED (type
))
1103 /* If this type's definition has been output or is now being output,
1106 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1111 /* If we have already had a cross reference,
1112 and either that's all we want or that's the best we could do,
1113 don't repeat the cross reference.
1114 Sun dbx crashes if we do. */
1115 if (! full
|| TYPE_SIZE (type
) == 0
1116 /* No way in DBX fmt to describe a variable size. */
1117 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1125 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1126 leave the type-number completely undefined rather than output
1127 a cross-reference. If we have already used GNU debug info extensions,
1128 then it is OK to output a cross reference. This is necessary to get
1129 proper C++ debug output. */
1130 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1131 || TREE_CODE (type
) == QUAL_UNION_TYPE
1132 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1133 && ! use_gnu_debug_info_extensions
)
1134 /* We must use the same test here as we use twice below when deciding
1135 whether to emit a cross-reference. */
1136 if ((TYPE_NAME (type
) != 0
1137 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1138 && DECL_IGNORED_P (TYPE_NAME (type
)))
1140 || TYPE_SIZE (type
) == 0
1141 /* No way in DBX fmt to describe a variable size. */
1142 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1144 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1149 /* Output a definition now. */
1151 fprintf (asmfile
, "=");
1154 /* Mark it as defined, so that if it is self-referent
1155 we will not get into an infinite recursion of definitions. */
1157 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1159 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1160 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1162 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0, 0);
1166 switch (TREE_CODE (type
))
1170 /* For a void type, just define it as itself; ie, "5=5".
1171 This makes us consider it defined
1172 without saying what it is. The debugger will make it
1173 a void type when the reference is seen, and nothing will
1174 ever override that default. */
1175 dbxout_type_index (type
);
1179 if (type
== char_type_node
&& ! TREE_UNSIGNED (type
))
1181 /* Output the type `char' as a subrange of itself!
1182 I don't understand this definition, just copied it
1183 from the output of pcc.
1184 This used to use `r2' explicitly and we used to
1185 take care to make sure that `char' was type number 2. */
1186 fprintf (asmfile
, "r");
1187 dbxout_type_index (type
);
1188 fprintf (asmfile
, ";0;127;");
1190 else if (use_gnu_debug_info_extensions
1191 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
1192 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
))
1194 /* This used to say `r1' and we used to take care
1195 to make sure that `int' was type number 1. */
1196 fprintf (asmfile
, "r");
1197 dbxout_type_index (integer_type_node
);
1198 fprintf (asmfile
, ";");
1199 print_int_cst_octal (TYPE_MIN_VALUE (type
));
1200 fprintf (asmfile
, ";");
1201 print_int_cst_octal (TYPE_MAX_VALUE (type
));
1202 fprintf (asmfile
, ";");
1204 else /* Output other integer types as subranges of `int'. */
1205 dbxout_range_type (type
);
1210 /* This used to say `r1' and we used to take care
1211 to make sure that `int' was type number 1. */
1212 fprintf (asmfile
, "r");
1213 dbxout_type_index (integer_type_node
);
1214 fprintf (asmfile
, ";%d;0;", int_size_in_bytes (type
));
1219 if (use_gnu_debug_info_extensions
)
1220 fprintf (asmfile
, "@s%d;-20;",
1221 BITS_PER_UNIT
* int_size_in_bytes (type
));
1224 /* Output the type `char' as a subrange of itself.
1225 That is what pcc seems to do. */
1226 fprintf (asmfile
, "r");
1227 dbxout_type_index (char_type_node
);
1228 fprintf (asmfile
, ";0;%d;", TREE_UNSIGNED (type
) ? 255 : 127);
1234 if (use_gnu_debug_info_extensions
)
1235 fprintf (asmfile
, "@s%d;-16;",
1236 BITS_PER_UNIT
* int_size_in_bytes (type
));
1237 else /* Define as enumeral type (False, True) */
1238 fprintf (asmfile
, "eFalse:0,True:1,;");
1243 putc ('d', asmfile
);
1245 dbxout_type (TREE_TYPE (type
), 0, 0);
1249 /* Differs from the REAL_TYPE by its new data type number */
1251 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1253 fprintf (asmfile
, "r");
1254 dbxout_type_index (type
);
1255 fprintf (asmfile
, ";%d;0;",
1256 int_size_in_bytes (TREE_TYPE (type
)));
1257 CHARS (12); /* The number is probably incorrect here. */
1261 /* Output a complex integer type as a structure,
1262 pending some other way to do it. */
1263 fprintf (asmfile
, "s%d", int_size_in_bytes (type
));
1265 fprintf (asmfile
, "real:");
1267 dbxout_type (TREE_TYPE (type
), 0, 0);
1268 fprintf (asmfile
, ",%d,%d;",
1269 0, TYPE_PRECISION (TREE_TYPE (type
)));
1271 fprintf (asmfile
, "imag:");
1273 dbxout_type (TREE_TYPE (type
), 0, 0);
1274 fprintf (asmfile
, ",%d,%d;;",
1275 TYPE_PRECISION (TREE_TYPE (type
)),
1276 TYPE_PRECISION (TREE_TYPE (type
)));
1282 if (use_gnu_debug_info_extensions
)
1284 have_used_extensions
= 1;
1285 fprintf (asmfile
, "@s%d;",
1286 BITS_PER_UNIT
* int_size_in_bytes (type
));
1287 /* Check if a bitstring type, which in Chill is
1288 different from a [power]set. */
1289 if (TYPE_STRING_FLAG (type
))
1290 fprintf (asmfile
, "@S;");
1292 putc ('S', asmfile
);
1294 dbxout_type (TYPE_DOMAIN (type
), 0, 0);
1298 /* Output "a" followed by a range type definition
1299 for the index type of the array
1300 followed by a reference to the target-type.
1301 ar1;0;N;M for a C array of type M and size N+1. */
1302 /* Check if a character string type, which in Chill is
1303 different from an array of characters. */
1304 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
1306 have_used_extensions
= 1;
1307 fprintf (asmfile
, "@S;");
1309 tem
= TYPE_DOMAIN (type
);
1312 fprintf (asmfile
, "ar");
1313 dbxout_type_index (integer_type_node
);
1314 fprintf (asmfile
, ";0;-1;");
1318 fprintf (asmfile
, "a");
1319 dbxout_range_type (tem
);
1322 dbxout_type (TREE_TYPE (type
), 0, 0);
1327 case QUAL_UNION_TYPE
:
1329 int i
, n_baseclasses
= 0;
1331 if (TYPE_BINFO (type
) != 0 && TYPE_BINFO_BASETYPES (type
) != 0)
1332 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
1334 /* Output a structure type. We must use the same test here as we
1335 use in the DBX_NO_XREFS case above. */
1336 if ((TYPE_NAME (type
) != 0
1337 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1338 && DECL_IGNORED_P (TYPE_NAME (type
)))
1340 || TYPE_SIZE (type
) == 0
1341 /* No way in DBX fmt to describe a variable size. */
1342 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
1344 /* If the type is just a cross reference, output one
1345 and mark the type as partially described.
1346 If it later becomes defined, we will output
1347 its real definition.
1348 If the type has a name, don't nest its definition within
1349 another type's definition; instead, output an xref
1350 and let the definition come when the name is defined. */
1351 fprintf (asmfile
, (TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu");
1353 #if 0 /* This assertion is legitimately false in C++. */
1354 /* We shouldn't be outputting a reference to a type before its
1355 definition unless the type has a tag name.
1356 A typedef name without a tag name should be impossible. */
1357 if (TREE_CODE (TYPE_NAME (type
)) != IDENTIFIER_NODE
)
1360 if (TYPE_NAME (type
) != 0)
1361 dbxout_type_name (type
);
1363 fprintf (asmfile
, "$$%d", anonymous_type_number
++);
1364 fprintf (asmfile
, ":");
1365 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1369 /* Identify record or union, and print its size. */
1370 fprintf (asmfile
, (TREE_CODE (type
) == RECORD_TYPE
) ? "s%d" : "u%d",
1371 int_size_in_bytes (type
));
1373 if (use_gnu_debug_info_extensions
)
1377 have_used_extensions
= 1;
1378 fprintf (asmfile
, "!%d,", n_baseclasses
);
1382 for (i
= 0; i
< n_baseclasses
; i
++)
1384 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)), i
);
1385 if (use_gnu_debug_info_extensions
)
1387 have_used_extensions
= 1;
1388 putc (TREE_VIA_VIRTUAL (child
) ? '1'
1391 putc (TREE_VIA_PUBLIC (child
) ? '2'
1394 fprintf (asmfile
, "%d,",
1395 TREE_INT_CST_LOW (BINFO_OFFSET (child
)) * BITS_PER_UNIT
);
1397 dbxout_type (BINFO_TYPE (child
), 0, 0);
1398 putc (';', asmfile
);
1402 /* Print out the base class information with fields
1403 which have the same names at the types they hold. */
1404 dbxout_type_name (BINFO_TYPE (child
));
1405 putc (':', asmfile
);
1406 dbxout_type (BINFO_TYPE (child
), full
, 0);
1407 fprintf (asmfile
, ",%d,%d;",
1408 TREE_INT_CST_LOW (BINFO_OFFSET (child
)) * BITS_PER_UNIT
,
1409 TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child
)))) * BITS_PER_UNIT
);
1417 /* Write out the field declarations. */
1418 dbxout_type_fields (type
);
1419 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1421 have_used_extensions
= 1;
1422 dbxout_type_methods (type
);
1424 putc (';', asmfile
);
1426 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1427 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1428 && TYPE_VFIELD (type
))
1430 have_used_extensions
= 1;
1432 /* Tell GDB+ that it may keep reading. */
1433 putc ('~', asmfile
);
1435 /* We need to write out info about what field this class
1436 uses as its "main" vtable pointer field, because if this
1437 field is inherited from a base class, GDB cannot necessarily
1438 figure out which field it's using in time. */
1439 if (TYPE_VFIELD (type
))
1441 putc ('%', asmfile
);
1442 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0, 0);
1444 putc (';', asmfile
);
1450 /* We must use the same test here as we use in the DBX_NO_XREFS case
1451 above. We simplify it a bit since an enum will never have a variable
1453 if ((TYPE_NAME (type
) != 0
1454 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1455 && DECL_IGNORED_P (TYPE_NAME (type
)))
1457 || TYPE_SIZE (type
) == 0)
1459 fprintf (asmfile
, "xe");
1461 dbxout_type_name (type
);
1462 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1463 fprintf (asmfile
, ":");
1466 #ifdef DBX_OUTPUT_ENUM
1467 DBX_OUTPUT_ENUM (asmfile
, type
);
1469 if (use_gnu_debug_info_extensions
1470 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1471 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1472 putc ('e', asmfile
);
1474 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1476 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)));
1477 if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == 0)
1478 fprintf (asmfile
, "%lu",
1479 (unsigned long) TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1480 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == -1
1481 && TREE_INT_CST_LOW (TREE_VALUE (tem
)) < 0)
1482 fprintf (asmfile
, "%ld",
1483 (long) TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1485 print_int_cst_octal (TREE_VALUE (tem
));
1486 fprintf (asmfile
, ",");
1487 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)));
1488 if (TREE_CHAIN (tem
) != 0)
1491 putc (';', asmfile
);
1497 putc ('*', asmfile
);
1499 dbxout_type (TREE_TYPE (type
), 0, 0);
1503 if (use_gnu_debug_info_extensions
)
1505 have_used_extensions
= 1;
1506 putc ('#', asmfile
);
1508 if (flag_minimal_debug
&& !show_arg_types
)
1510 /* Normally, just output the return type.
1511 The argument types are encoded in the method name. */
1512 putc ('#', asmfile
);
1513 dbxout_type (TREE_TYPE (type
), 0, 0);
1514 putc (';', asmfile
);
1519 /* When outputting destructors, we need to write
1520 the argument types out longhand. */
1521 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0, 0);
1522 putc (',', asmfile
);
1524 dbxout_type (TREE_TYPE (type
), 0, 0);
1525 dbxout_args (TYPE_ARG_TYPES (type
));
1526 putc (';', asmfile
);
1532 /* Treat it as a function type. */
1533 dbxout_type (TREE_TYPE (type
), 0, 0);
1538 if (use_gnu_debug_info_extensions
)
1540 have_used_extensions
= 1;
1541 putc ('@', asmfile
);
1543 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0, 0);
1544 putc (',', asmfile
);
1546 dbxout_type (TREE_TYPE (type
), 0, 0);
1550 /* Should print as an int, because it is really
1552 dbxout_type (integer_type_node
, 0, 0);
1556 case REFERENCE_TYPE
:
1557 if (use_gnu_debug_info_extensions
)
1558 have_used_extensions
= 1;
1559 putc (use_gnu_debug_info_extensions
? '&' : '*', asmfile
);
1561 dbxout_type (TREE_TYPE (type
), 0, 0);
1565 putc ('f', asmfile
);
1567 dbxout_type (TREE_TYPE (type
), 0, 0);
1575 /* Print the value of integer constant C, in octal,
1576 handling double precision. */
1579 print_int_cst_octal (c
)
1582 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (c
);
1583 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (c
);
1584 int excess
= (3 - (HOST_BITS_PER_WIDE_INT
% 3));
1585 int width
= TYPE_PRECISION (TREE_TYPE (c
));
1587 /* GDB wants constants with no extra leading "1" bits, so
1588 we need to remove any sign-extension that might be
1590 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
1592 else if (width
> HOST_BITS_PER_WIDE_INT
)
1593 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
1594 else if (width
== HOST_BITS_PER_WIDE_INT
)
1597 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
1599 fprintf (asmfile
, "0");
1603 print_octal (high
, HOST_BITS_PER_WIDE_INT
/ 3);
1604 print_octal (low
, HOST_BITS_PER_WIDE_INT
/ 3);
1608 unsigned HOST_WIDE_INT beg
= high
>> excess
;
1609 unsigned HOST_WIDE_INT middle
1610 = ((high
& (((HOST_WIDE_INT
) 1 << excess
) - 1)) << (3 - excess
)
1611 | (low
>> (HOST_BITS_PER_WIDE_INT
/ 3 * 3)));
1612 unsigned HOST_WIDE_INT end
1613 = low
& (((unsigned HOST_WIDE_INT
) 1
1614 << (HOST_BITS_PER_WIDE_INT
/ 3 * 3))
1617 fprintf (asmfile
, "%o%01o", beg
, middle
);
1618 print_octal (end
, HOST_BITS_PER_WIDE_INT
/ 3);
1623 print_octal (value
, digits
)
1624 unsigned HOST_WIDE_INT value
;
1629 for (i
= digits
- 1; i
>= 0; i
--)
1630 fprintf (asmfile
, "%01o", ((value
>> (3 * i
)) & 7));
1633 /* Output the name of type TYPE, with no punctuation.
1634 Such names can be set up either by typedef declarations
1635 or by struct, enum and union tags. */
1638 dbxout_type_name (type
)
1642 if (TYPE_NAME (type
) == 0)
1644 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
1646 t
= TYPE_NAME (type
);
1648 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1650 t
= DECL_NAME (TYPE_NAME (type
));
1655 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
1656 CHARS (IDENTIFIER_LENGTH (t
));
1659 /* Output a .stabs for the symbol defined by DECL,
1660 which must be a ..._DECL node in the normal namespace.
1661 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1662 LOCAL is nonzero if the scope is less than the entire file. */
1665 dbxout_symbol (decl
, local
)
1669 tree type
= TREE_TYPE (decl
);
1670 tree context
= NULL_TREE
;
1672 /* Cast avoids warning in old compilers. */
1673 current_sym_code
= (STAB_CODE_TYPE
) 0;
1674 current_sym_value
= 0;
1675 current_sym_addr
= 0;
1677 /* Ignore nameless syms, but don't ignore type tags. */
1679 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
1680 || DECL_IGNORED_P (decl
))
1683 dbxout_prepare_symbol (decl
);
1685 /* The output will always start with the symbol name,
1686 so always count that in the length-output-so-far. */
1688 if (DECL_NAME (decl
) != 0)
1689 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
1691 switch (TREE_CODE (decl
))
1694 /* Enum values are defined by defining the enum type. */
1698 if (DECL_RTL (decl
) == 0)
1700 if (DECL_EXTERNAL (decl
))
1702 /* Don't mention a nested function under its parent. */
1703 context
= decl_function_context (decl
);
1704 if (context
== current_function_decl
)
1706 if (GET_CODE (DECL_RTL (decl
)) != MEM
1707 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
1711 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
1712 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1713 TREE_PUBLIC (decl
) ? 'F' : 'f');
1715 current_sym_code
= N_FUN
;
1716 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
1718 if (TREE_TYPE (type
))
1719 dbxout_type (TREE_TYPE (type
), 0, 0);
1721 dbxout_type (void_type_node
, 0, 0);
1723 /* For a nested function, when that function is compiled,
1724 mention the containing function name
1725 as well as (since dbx wants it) our own assembler-name. */
1727 fprintf (asmfile
, ",%s,%s",
1728 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
1729 IDENTIFIER_POINTER (DECL_NAME (context
)));
1731 dbxout_finish_symbol (decl
);
1736 /* This seems all wrong. Outputting most kinds of types gives no name
1737 at all. A true definition gives no name; a cross-ref for a
1738 structure can give the tag name, but not a type name.
1739 It seems that no typedef name is defined by outputting a type. */
1741 /* If this typedef name was defined by outputting the type,
1742 don't duplicate it. */
1743 if (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
== TYPE_DEFINED
1744 && TYPE_NAME (TREE_TYPE (decl
)) == decl
)
1747 /* Don't output the same typedef twice.
1748 And don't output what language-specific stuff doesn't want output. */
1749 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
1758 if (DECL_NAME (decl
))
1760 /* Nonzero means we must output a tag as well as a typedef. */
1763 /* Handle the case of a C++ structure or union
1764 where the TYPE_NAME is a TYPE_DECL
1765 which gives both a typedef name and a tag. */
1766 /* dbx requires the tag first and the typedef second. */
1767 if ((TREE_CODE (type
) == RECORD_TYPE
1768 || TREE_CODE (type
) == UNION_TYPE
1769 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1770 && TYPE_NAME (type
) == decl
1771 && !(use_gnu_debug_info_extensions
&& have_used_extensions
)
1772 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
1773 /* Distinguish the implicit typedefs of C++
1774 from explicit ones that might be found in C. */
1775 && (!strcmp (lang_identify (), "cplusplus")
1776 /* The following line maybe unnecessary;
1777 in 2.6, try removing it. */
1778 || DECL_SOURCE_LINE (decl
) == 0))
1780 tree name
= TYPE_NAME (type
);
1781 if (TREE_CODE (name
) == TYPE_DECL
)
1782 name
= DECL_NAME (name
);
1784 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1785 current_sym_value
= 0;
1786 current_sym_addr
= 0;
1787 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1789 fprintf (asmfile
, "%s \"%s:T", ASM_STABS_OP
,
1790 IDENTIFIER_POINTER (name
));
1791 dbxout_type (type
, 1, 0);
1792 dbxout_finish_symbol (NULL_TREE
);
1795 /* Output typedef name. */
1796 fprintf (asmfile
, "%s \"%s:", ASM_STABS_OP
,
1797 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1799 /* Short cut way to output a tag also. */
1800 if ((TREE_CODE (type
) == RECORD_TYPE
1801 || TREE_CODE (type
) == UNION_TYPE
1802 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
1803 && TYPE_NAME (type
) == decl
)
1805 if (use_gnu_debug_info_extensions
&& have_used_extensions
)
1807 putc ('T', asmfile
);
1808 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
1810 #if 0 /* Now we generate the tag for this case up above. */
1816 putc ('t', asmfile
);
1817 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1819 dbxout_type (type
, 1, 0);
1820 dbxout_finish_symbol (decl
);
1824 /* Don't output a tag if this is an incomplete type (TYPE_SIZE is
1825 zero). This prevents the sun4 Sun OS 4.x dbx from crashing. */
1827 if (tag_needed
&& TYPE_NAME (type
) != 0
1828 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
1829 || (DECL_NAME (TYPE_NAME (type
)) != 0))
1830 && TYPE_SIZE (type
) != 0
1831 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1833 /* For a TYPE_DECL with no name, but the type has a name,
1835 This is what represents `struct foo' with no typedef. */
1836 /* In C++, the name of a type is the corresponding typedef.
1837 In C, it is an IDENTIFIER_NODE. */
1838 tree name
= TYPE_NAME (type
);
1839 if (TREE_CODE (name
) == TYPE_DECL
)
1840 name
= DECL_NAME (name
);
1842 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1843 current_sym_value
= 0;
1844 current_sym_addr
= 0;
1845 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
1847 fprintf (asmfile
, "%s \"%s:T", ASM_STABS_OP
,
1848 IDENTIFIER_POINTER (name
));
1849 dbxout_type (type
, 1, 0);
1850 dbxout_finish_symbol (NULL_TREE
);
1854 /* If an enum type has no name, it cannot be referred to,
1855 but we must output it anyway, since the enumeration constants
1856 can be referred to. */
1857 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
1859 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
1860 current_sym_value
= 0;
1861 current_sym_addr
= 0;
1862 current_sym_nchars
= 2;
1864 /* Some debuggers fail when given NULL names, so give this a
1865 harmless name of ` '. */
1866 fprintf (asmfile
, "%s \" :T", ASM_STABS_OP
);
1867 dbxout_type (type
, 1, 0);
1868 dbxout_finish_symbol (NULL_TREE
);
1871 /* Prevent duplicate output of a typedef. */
1872 TREE_ASM_WRITTEN (decl
) = 1;
1877 /* Parm decls go in their own separate chains
1878 and are output by dbxout_reg_parms and dbxout_parms. */
1882 /* Named return value, treat like a VAR_DECL. */
1884 if (DECL_RTL (decl
) == 0)
1886 /* Don't mention a variable that is external.
1887 Let the file that defines it describe it. */
1888 if (DECL_EXTERNAL (decl
))
1891 /* If the variable is really a constant
1892 and not written in memory, inform the debugger. */
1893 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
1894 && DECL_INITIAL (decl
) != 0
1895 && ! TREE_ASM_WRITTEN (decl
)
1896 && (DECL_FIELD_CONTEXT (decl
) == NULL_TREE
1897 || TREE_CODE (DECL_FIELD_CONTEXT (decl
)) == BLOCK
))
1899 if (TREE_PUBLIC (decl
) == 0)
1901 /* The sun4 assembler does not grok this. */
1902 char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
1903 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
1904 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
1906 HOST_WIDE_INT ival
= TREE_INT_CST_LOW (DECL_INITIAL (decl
));
1907 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1908 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile
, name
, ival
);
1910 fprintf (asmfile
, "%s \"%s:c=i%d\",0x%x,0,0,0\n",
1911 ASM_STABS_OP
, name
, ival
, N_LSYM
);
1915 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
1917 /* don't know how to do this yet. */
1921 /* else it is something we handle like a normal variable. */
1924 DECL_RTL (decl
) = eliminate_regs (DECL_RTL (decl
), 0, NULL_RTX
);
1925 #ifdef LEAF_REG_REMAP
1927 leaf_renumber_regs_insn (DECL_RTL (decl
));
1930 dbxout_symbol_location (decl
, type
, 0, DECL_RTL (decl
));
1934 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1935 Add SUFFIX to its name, if SUFFIX is not 0.
1936 Describe the variable as residing in HOME
1937 (usually HOME is DECL_RTL (DECL), but not always). */
1940 dbxout_symbol_location (decl
, type
, suffix
, home
)
1948 /* Don't mention a variable at all
1949 if it was completely optimized into nothingness.
1951 If the decl was from an inline function, then it's rtl
1952 is not identically the rtl that was used in this
1953 particular compilation. */
1954 if (GET_CODE (home
) == REG
)
1956 regno
= REGNO (home
);
1957 if (regno
>= FIRST_PSEUDO_REGISTER
)
1960 else if (GET_CODE (home
) == SUBREG
)
1964 while (GET_CODE (value
) == SUBREG
)
1966 offset
+= SUBREG_WORD (value
);
1967 value
= SUBREG_REG (value
);
1969 if (GET_CODE (value
) == REG
)
1971 regno
= REGNO (value
);
1972 if (regno
>= FIRST_PSEUDO_REGISTER
)
1976 alter_subreg (home
);
1979 /* The kind-of-variable letter depends on where
1980 the variable is and on the scope of its name:
1981 G and N_GSYM for static storage and global scope,
1982 S for static storage and file scope,
1983 V for static storage and local scope,
1984 for those two, use N_LCSYM if data is in bss segment,
1985 N_STSYM if in data segment, N_FUN otherwise.
1986 (We used N_FUN originally, then changed to N_STSYM
1987 to please GDB. However, it seems that confused ld.
1988 Now GDB has been fixed to like N_FUN, says Kingdon.)
1989 no letter at all, and N_LSYM, for auto variable,
1990 r and N_RSYM for register variable. */
1992 if (GET_CODE (home
) == MEM
1993 && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
1995 if (TREE_PUBLIC (decl
))
1998 current_sym_code
= N_GSYM
;
2002 current_sym_addr
= XEXP (home
, 0);
2004 letter
= decl_function_context (decl
) ? 'V' : 'S';
2006 /* This should be the same condition as in assemble_variable, but
2007 we don't have access to dont_output_data here. So, instead,
2008 we rely on the fact that error_mark_node initializers always
2009 end up in bss for C++ and never end up in bss for C. */
2010 if (DECL_INITIAL (decl
) == 0
2011 || (!strcmp (lang_identify (), "cplusplus")
2012 && DECL_INITIAL (decl
) == error_mark_node
))
2013 current_sym_code
= N_LCSYM
;
2014 else if (DECL_IN_TEXT_SECTION (decl
))
2015 /* This is not quite right, but it's the closest
2016 of all the codes that Unix defines. */
2017 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
2020 /* Ultrix `as' seems to need this. */
2021 #ifdef DBX_STATIC_STAB_DATA_SECTION
2024 current_sym_code
= N_STSYM
;
2028 else if (regno
>= 0)
2031 current_sym_code
= N_RSYM
;
2032 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
2034 else if (GET_CODE (home
) == MEM
2035 && (GET_CODE (XEXP (home
, 0)) == MEM
2036 || (GET_CODE (XEXP (home
, 0)) == REG
2037 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
)))
2038 /* If the value is indirect by memory or by a register
2039 that isn't the frame pointer
2040 then it means the object is variable-sized and address through
2041 that register or stack slot. DBX has no way to represent this
2042 so all we can do is output the variable as a pointer.
2043 If it's not a parameter, ignore it.
2044 (VAR_DECLs like this can be made by integrate.c.) */
2046 if (GET_CODE (XEXP (home
, 0)) == REG
)
2049 current_sym_code
= N_RSYM
;
2050 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
2054 current_sym_code
= N_LSYM
;
2055 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2056 We want the value of that CONST_INT. */
2058 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
2061 /* Effectively do build_pointer_type, but don't cache this type,
2062 since it might be temporary whereas the type it points to
2063 might have been saved for inlining. */
2064 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2065 type
= make_node (POINTER_TYPE
);
2066 TREE_TYPE (type
) = TREE_TYPE (decl
);
2068 else if (GET_CODE (home
) == MEM
2069 && GET_CODE (XEXP (home
, 0)) == REG
)
2071 current_sym_code
= N_LSYM
;
2072 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2074 else if (GET_CODE (home
) == MEM
2075 && GET_CODE (XEXP (home
, 0)) == PLUS
2076 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
2078 current_sym_code
= N_LSYM
;
2079 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2080 We want the value of that CONST_INT. */
2081 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2083 else if (GET_CODE (home
) == MEM
2084 && GET_CODE (XEXP (home
, 0)) == CONST
)
2086 /* Handle an obscure case which can arise when optimizing and
2087 when there are few available registers. (This is *always*
2088 the case for i386/i486 targets). The RTL looks like
2089 (MEM (CONST ...)) even though this variable is a local `auto'
2090 or a local `register' variable. In effect, what has happened
2091 is that the reload pass has seen that all assignments and
2092 references for one such a local variable can be replaced by
2093 equivalent assignments and references to some static storage
2094 variable, thereby avoiding the need for a register. In such
2095 cases we're forced to lie to debuggers and tell them that
2096 this variable was itself `static'. */
2097 current_sym_code
= N_LCSYM
;
2099 current_sym_addr
= XEXP (XEXP (home
, 0), 0);
2101 else if (GET_CODE (home
) == CONCAT
)
2103 tree subtype
= TREE_TYPE (type
);
2105 /* If the variable's storage is in two parts,
2106 output each as a separate stab with a modified name. */
2107 if (WORDS_BIG_ENDIAN
)
2108 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
2110 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
2112 /* Cast avoids warning in old compilers. */
2113 current_sym_code
= (STAB_CODE_TYPE
) 0;
2114 current_sym_value
= 0;
2115 current_sym_addr
= 0;
2116 dbxout_prepare_symbol (decl
);
2118 if (WORDS_BIG_ENDIAN
)
2119 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
2121 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
2125 /* Address might be a MEM, when DECL is a variable-sized object.
2126 Or it might be const0_rtx, meaning previous passes
2127 want us to ignore this variable. */
2130 /* Ok, start a symtab entry and output the variable name. */
2133 #ifdef DBX_STATIC_BLOCK_START
2134 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
2137 dbxout_symbol_name (decl
, suffix
, letter
);
2138 dbxout_type (type
, 0, 0);
2139 dbxout_finish_symbol (decl
);
2141 #ifdef DBX_STATIC_BLOCK_END
2142 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
2146 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2147 Then output LETTER to indicate the kind of location the symbol has. */
2150 dbxout_symbol_name (decl
, suffix
, letter
)
2155 /* One slight hitch: if this is a VAR_DECL which is a static
2156 class member, we must put out the mangled name instead of the
2157 DECL_NAME. Note also that static member (variable) names DO NOT begin
2158 with underscores in .stabs directives. */
2159 char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2162 fprintf (asmfile
, "%s \"%s%s:", ASM_STABS_OP
, name
,
2163 (suffix
? suffix
: ""));
2165 if (letter
) putc (letter
, asmfile
);
2169 dbxout_prepare_symbol (decl
)
2173 char *filename
= DECL_SOURCE_FILE (decl
);
2175 dbxout_source_file (asmfile
, filename
);
2180 dbxout_finish_symbol (sym
)
2183 #ifdef DBX_FINISH_SYMBOL
2184 DBX_FINISH_SYMBOL (sym
);
2187 if (use_gnu_debug_info_extensions
&& sym
!= 0)
2188 line
= DECL_SOURCE_LINE (sym
);
2190 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
2191 if (current_sym_addr
)
2192 output_addr_const (asmfile
, current_sym_addr
);
2194 fprintf (asmfile
, "%d", current_sym_value
);
2195 putc ('\n', asmfile
);
2199 /* Output definitions of all the decls in a chain. */
2207 dbxout_symbol (syms
, 1);
2208 syms
= TREE_CHAIN (syms
);
2212 /* The following two functions output definitions of function parameters.
2213 Each parameter gets a definition locating it in the parameter list.
2214 Each parameter that is a register variable gets a second definition
2215 locating it in the register.
2217 Printing or argument lists in gdb uses the definitions that
2218 locate in the parameter list. But reference to the variable in
2219 expressions uses preferentially the definition as a register. */
2221 /* Output definitions, referring to storage in the parmlist,
2222 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2225 dbxout_parms (parms
)
2228 for (; parms
; parms
= TREE_CHAIN (parms
))
2229 if (DECL_NAME (parms
) && TREE_TYPE (parms
) != error_mark_node
)
2231 dbxout_prepare_symbol (parms
);
2233 /* Perform any necessary register eliminations on the parameter's rtl,
2234 so that the debugging output will be accurate. */
2235 DECL_INCOMING_RTL (parms
)
2236 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
2237 DECL_RTL (parms
) = eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
);
2238 #ifdef LEAF_REG_REMAP
2241 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
2242 leaf_renumber_regs_insn (DECL_RTL (parms
));
2246 if (PARM_PASSED_IN_MEMORY (parms
))
2248 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
2250 /* ??? Here we assume that the parm address is indexed
2251 off the frame pointer or arg pointer.
2252 If that is not true, we produce meaningless results,
2253 but do not crash. */
2254 if (GET_CODE (addr
) == PLUS
2255 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
2256 current_sym_value
= INTVAL (XEXP (addr
, 1));
2258 current_sym_value
= 0;
2260 current_sym_code
= N_PSYM
;
2261 current_sym_addr
= 0;
2264 if (DECL_NAME (parms
))
2266 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2268 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2269 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2270 DBX_MEMPARM_STABS_LETTER
);
2274 current_sym_nchars
= 8;
2275 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2276 DBX_MEMPARM_STABS_LETTER
);
2279 dbxout_type (DECL_ARG_TYPE (parms
), 0, 0);
2280 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
2281 dbxout_finish_symbol (parms
);
2283 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
2286 char regparm_letter
;
2288 /* Parm passed in registers and lives in registers or nowhere. */
2290 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2291 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2292 current_sym_addr
= 0;
2294 /* If parm lives in a register, use that register;
2295 pretend the parm was passed there. It would be more consistent
2296 to describe the register where the parm was passed,
2297 but in practice that register usually holds something else.
2299 If we use DECL_RTL, then we must use the declared type of
2300 the variable, not the type that it arrived in. */
2301 if (REGNO (DECL_RTL (parms
)) >= 0
2302 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2304 best_rtl
= DECL_RTL (parms
);
2305 parm_type
= TREE_TYPE (parms
);
2307 /* If the parm lives nowhere, use the register where it was
2308 passed. It is also better to use the declared type here. */
2311 best_rtl
= DECL_INCOMING_RTL (parms
);
2312 parm_type
= TREE_TYPE (parms
);
2314 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
2317 if (DECL_NAME (parms
))
2319 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2320 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2321 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2326 current_sym_nchars
= 8;
2327 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2331 dbxout_type (parm_type
, 0, 0);
2332 dbxout_finish_symbol (parms
);
2334 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2335 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
2336 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
2337 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
2338 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2339 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
2343 /* Parm was passed via invisible reference.
2344 That is, its address was passed in a register.
2345 Output it as if it lived in that register.
2346 The debugger will know from the type
2347 that it was actually passed by invisible reference. */
2349 char regparm_letter
;
2350 /* Parm passed in registers and lives in registers or nowhere. */
2352 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2353 if (use_gnu_debug_info_extensions
)
2354 regparm_letter
= GDB_INV_REF_REGPARM_STABS_LETTER
;
2356 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2358 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2359 If it is an unallocated pseudo-reg, then use the register where
2360 it was passed instead. */
2361 if (REGNO (XEXP (DECL_RTL (parms
), 0)) >= 0
2362 && REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
2363 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
2365 current_sym_value
= REGNO (DECL_INCOMING_RTL (parms
));
2367 current_sym_addr
= 0;
2370 if (DECL_NAME (parms
))
2372 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2374 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2375 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2380 current_sym_nchars
= 8;
2381 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2385 dbxout_type (TREE_TYPE (parms
), 0, 0);
2386 dbxout_finish_symbol (parms
);
2388 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2389 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
2390 /* ??? A constant address for a parm can happen
2391 when the reg it lives in is equiv to a constant in memory.
2392 Should make this not happen, after 2.4. */
2393 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
2395 /* Parm was passed in registers but lives on the stack. */
2397 current_sym_code
= N_PSYM
;
2398 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2399 in which case we want the value of that CONST_INT,
2400 or (MEM (REG ...)) or (MEM (MEM ...)),
2401 in which case we use a value of zero. */
2402 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
2403 || GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
2404 current_sym_value
= 0;
2406 current_sym_value
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
2407 current_sym_addr
= 0;
2410 if (DECL_NAME (parms
))
2412 current_sym_nchars
= 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2414 fprintf (asmfile
, "%s \"%s:%c", ASM_STABS_OP
,
2415 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2416 DBX_MEMPARM_STABS_LETTER
);
2420 current_sym_nchars
= 8;
2421 fprintf (asmfile
, "%s \"(anon):%c", ASM_STABS_OP
,
2422 DBX_MEMPARM_STABS_LETTER
);
2426 = DEBUGGER_ARG_OFFSET (current_sym_value
,
2427 XEXP (DECL_RTL (parms
), 0));
2428 dbxout_type (TREE_TYPE (parms
), 0, 0);
2429 dbxout_finish_symbol (parms
);
2434 /* Output definitions for the places where parms live during the function,
2435 when different from where they were passed, when the parms were passed
2438 It is not useful to do this for parms passed in registers
2439 that live during the function in different registers, because it is
2440 impossible to look in the passed register for the passed value,
2441 so we use the within-the-function register to begin with.
2443 PARMS is a chain of PARM_DECL nodes. */
2446 dbxout_reg_parms (parms
)
2449 for (; parms
; parms
= TREE_CHAIN (parms
))
2450 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
2452 dbxout_prepare_symbol (parms
);
2454 /* Report parms that live in registers during the function
2455 but were passed in memory. */
2456 if (GET_CODE (DECL_RTL (parms
)) == REG
2457 && REGNO (DECL_RTL (parms
)) >= 0
2458 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2459 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2460 0, DECL_RTL (parms
));
2461 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
2462 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2463 0, DECL_RTL (parms
));
2464 /* Report parms that live in memory but not where they were passed. */
2465 else if (GET_CODE (DECL_RTL (parms
)) == MEM
2466 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
2467 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
2468 0, DECL_RTL (parms
));
2472 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2473 output definitions of those names, in raw form */
2481 putc (',', asmfile
);
2482 dbxout_type (TREE_VALUE (args
), 0, 0);
2484 args
= TREE_CHAIN (args
);
2488 /* Given a chain of ..._TYPE nodes,
2489 find those which have typedef names and output those names.
2490 This is to ensure those types get output. */
2493 dbxout_types (types
)
2494 register tree types
;
2498 if (TYPE_NAME (types
)
2499 && TREE_CODE (TYPE_NAME (types
)) == TYPE_DECL
2500 && ! TREE_ASM_WRITTEN (TYPE_NAME (types
)))
2501 dbxout_symbol (TYPE_NAME (types
), 1);
2502 types
= TREE_CHAIN (types
);
2506 /* Output everything about a symbol block (a BLOCK node
2507 that represents a scope level),
2508 including recursive output of contained blocks.
2510 BLOCK is the BLOCK node.
2511 DEPTH is its depth within containing symbol blocks.
2512 ARGS is usually zero; but for the outermost block of the
2513 body of a function, it is a chain of PARM_DECLs for the function parameters.
2514 We output definitions of all the register parms
2515 as if they were local variables of that block.
2517 If -g1 was used, we count blocks just the same, but output nothing
2518 except for the outermost block.
2520 Actually, BLOCK may be several blocks chained together.
2521 We handle them all in sequence. */
2524 dbxout_block (block
, depth
, args
)
2525 register tree block
;
2533 /* Ignore blocks never expanded or otherwise marked as real. */
2534 if (TREE_USED (block
))
2536 #ifndef DBX_LBRAC_FIRST
2537 /* In dbx format, the syms of a block come before the N_LBRAC. */
2538 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2539 dbxout_syms (BLOCK_VARS (block
));
2541 dbxout_reg_parms (args
);
2544 /* Now output an N_LBRAC symbol to represent the beginning of
2545 the block. Use the block's tree-walk order to generate
2546 the assembler symbols LBBn and LBEn
2547 that final will define around the code in this block. */
2548 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2551 blocknum
= next_block_number
++;
2552 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
2554 if (BLOCK_HANDLER_BLOCK (block
))
2556 /* A catch block. Must precede N_LBRAC. */
2557 tree decl
= BLOCK_VARS (block
);
2560 #ifdef DBX_OUTPUT_CATCH
2561 DBX_OUTPUT_CATCH (asmfile
, decl
, buf
);
2563 fprintf (asmfile
, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP
,
2564 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
2565 assemble_name (asmfile
, buf
);
2566 fprintf (asmfile
, "\n");
2568 decl
= TREE_CHAIN (decl
);
2572 #ifdef DBX_OUTPUT_LBRAC
2573 DBX_OUTPUT_LBRAC (asmfile
, buf
);
2575 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_LBRAC
);
2576 assemble_name (asmfile
, buf
);
2577 #if DBX_BLOCKS_FUNCTION_RELATIVE
2578 fputc ('-', asmfile
);
2579 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
2581 fprintf (asmfile
, "\n");
2585 /* Count blocks the same way regardless of debug_info_level. */
2586 next_block_number
++;
2588 #ifdef DBX_LBRAC_FIRST
2589 /* On some weird machines, the syms of a block
2590 come after the N_LBRAC. */
2591 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
2592 dbxout_syms (BLOCK_VARS (block
));
2594 dbxout_reg_parms (args
);
2597 /* Output the subblocks. */
2598 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
2600 /* Refer to the marker for the end of the block. */
2601 if (depth
> 0 && debug_info_level
!= DINFO_LEVEL_TERSE
)
2604 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
2605 #ifdef DBX_OUTPUT_RBRAC
2606 DBX_OUTPUT_RBRAC (asmfile
, buf
);
2608 fprintf (asmfile
, "%s %d,0,0,", ASM_STABN_OP
, N_RBRAC
);
2609 assemble_name (asmfile
, buf
);
2610 #if DBX_BLOCKS_FUNCTION_RELATIVE
2611 fputc ('-', asmfile
);
2612 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
2614 fprintf (asmfile
, "\n");
2618 block
= BLOCK_CHAIN (block
);
2622 /* Output the information about a function and its arguments and result.
2623 Usually this follows the function's code,
2624 but on some systems, it comes before. */
2627 dbxout_really_begin_function (decl
)
2630 dbxout_symbol (decl
, 0);
2631 dbxout_parms (DECL_ARGUMENTS (decl
));
2632 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
2633 dbxout_symbol (DECL_RESULT (decl
), 1);
2636 /* Called at beginning of output of function definition. */
2639 dbxout_begin_function (decl
)
2642 #ifdef DBX_FUNCTION_FIRST
2643 dbxout_really_begin_function (decl
);
2647 /* Output dbx data for a function definition.
2648 This includes a definition of the function name itself (a symbol),
2649 definitions of the parameters (locating them in the parameter list)
2650 and then output the block that makes up the function's body
2651 (including all the auto variables of the function). */
2654 dbxout_function (decl
)
2657 #ifndef DBX_FUNCTION_FIRST
2658 dbxout_really_begin_function (decl
);
2660 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
2661 #ifdef DBX_OUTPUT_FUNCTION_END
2662 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
2665 #endif /* DBX_DEBUGGING_INFO */