1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* Output dbx-format symbol table data.
24 This consists of many symbol table entries, each of them
25 a .stabs assembler pseudo-op with four operands:
26 a "name" which is really a description of one symbol and its type,
27 a "code", which is a symbol defined in stab.h whose name starts with N_,
28 an unused operand always 0,
29 and a "value" which is an address or an offset.
30 The name is enclosed in doublequote characters.
32 Each function, variable, typedef, and structure tag
33 has a symbol table entry to define it.
34 The beginning and end of each level of name scoping within
35 a function are also marked by special symbol table entries.
37 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
38 and a data type number. The data type number may be followed by
39 "=" and a type definition; normally this will happen the first time
40 the type number is mentioned. The type definition may refer to
41 other types by number, and those type numbers may be followed
42 by "=" and nested definitions.
44 This can make the "name" quite long.
45 When a name is more than 80 characters, we split the .stabs pseudo-op
46 into two .stabs pseudo-ops, both sharing the same "code" and "value".
47 The first one is marked as continued with a double-backslash at the
50 The kind-of-symbol letter distinguished function names from global
51 variables from file-scope variables from parameters from auto
52 variables in memory from typedef names from register variables.
55 The "code" is mostly redundant with the kind-of-symbol letter
56 that goes in the "name", but not entirely: for symbols located
57 in static storage, the "code" says which segment the address is in,
58 which controls how it is relocated.
60 The "value" for a symbol in static storage
61 is the core address of the symbol (actually, the assembler
62 label for the symbol). For a symbol located in a stack slot
63 it is the stack offset; for one in a register, the register number.
64 For a typedef symbol, it is zero.
66 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
67 output while in the text section.
69 For more on data type definitions, see `dbxout_type'. */
78 #include "insn-config.h"
81 #include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions. */
87 #ifdef XCOFF_DEBUGGING_INFO
92 #define ASM_STABS_OP ".stabs"
96 #define ASM_STABN_OP ".stabn"
99 #ifndef DBX_TYPE_DECL_STABS_CODE
100 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
103 #ifndef DBX_STATIC_CONST_VAR_CODE
104 #define DBX_STATIC_CONST_VAR_CODE N_FUN
107 #ifndef DBX_REGPARM_STABS_CODE
108 #define DBX_REGPARM_STABS_CODE N_RSYM
111 #ifndef DBX_REGPARM_STABS_LETTER
112 #define DBX_REGPARM_STABS_LETTER 'P'
115 /* This is used for parameters passed by invisible reference in a register. */
116 #ifndef GDB_INV_REF_REGPARM_STABS_LETTER
117 #define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
120 #ifndef DBX_MEMPARM_STABS_LETTER
121 #define DBX_MEMPARM_STABS_LETTER 'p'
124 #ifndef FILE_NAME_JOINER
125 #define FILE_NAME_JOINER "/"
128 /* Nonzero means if the type has methods, only output debugging
129 information if methods are actually written to the asm file. This
130 optimization only works if the debugger can detect the special C++
133 #define MINIMAL_DEBUG 1
135 #ifdef NO_DOLLAR_IN_LABEL
136 #ifdef NO_DOT_IN_LABEL
138 #define MINIMAL_DEBUG 0
142 /* Typical USG systems don't have stab.h, and they also have
143 no use for DBX-format debugging info. */
145 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
147 static int flag_minimal_debug = MINIMAL_DEBUG;
149 /* Nonzero if we have actually used any of the GDB extensions
150 to the debugging format. The idea is that we use them for the
151 first time only if there's a strong reason, but once we have done that,
152 we use them whenever convenient. */
154 static int have_used_extensions = 0;
156 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
157 for the N_SO filename stabs label. */
159 static int source_label_number = 1;
161 #ifdef DEBUG_SYMS_TEXT
162 #define FORCE_TEXT text_section ();
167 /* If there is a system stab.h, use it. Otherwise, use our own. */
168 /* ??? This is supposed to describe the target's stab format, so using
169 the host HAVE_STAB_H appears to be wrong. For now, we use our own file
170 when cross compiling. */
171 #if defined (USG) || !defined (HAVE_STAB_H) || defined (CROSS_COMPILE)
172 #include "gstab.h" /* If doing DBX on sysV, use our own stab.h. */
176 /* This is a GNU extension we need to reference in this file. */
183 #define STAB_CODE_TYPE enum __stab_debug_code
185 #define STAB_CODE_TYPE int
188 /* 1 if PARM is passed to this function in memory. */
190 #define PARM_PASSED_IN_MEMORY(PARM) \
191 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
193 /* A C expression for the integer offset value of an automatic variable
194 (N_LSYM) having address X (an RTX). */
195 #ifndef DEBUGGER_AUTO_OFFSET
196 #define DEBUGGER_AUTO_OFFSET(X) \
197 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
200 /* A C expression for the integer offset value of an argument (N_PSYM)
201 having address X (an RTX). The nominal offset is OFFSET. */
202 #ifndef DEBUGGER_ARG_OFFSET
203 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
206 /* Stream for writing to assembler file. */
208 static FILE *asmfile;
210 /* Last source file name mentioned in a NOTE insn. */
212 static const char *lastfile;
214 /* Current working directory. */
216 static const char *cwd;
218 enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
220 /* Structure recording information about a C data type.
221 The status element says whether we have yet output
222 the definition of the type. TYPE_XREF says we have
223 output it as a cross-reference only.
224 The file_number and type_number elements are used if DBX_USE_BINCL
229 enum typestatus status;
236 /* Vector recording information about C data types.
237 When we first notice a data type (a tree node),
238 we assign it a number using next_type_number.
239 That is its index in this vector. */
241 struct typeinfo *typevec;
243 /* Number of elements of space allocated in `typevec'. */
245 static int typevec_len;
247 /* In dbx output, each type gets a unique number.
248 This is the number for the next type output.
249 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
251 static int next_type_number;
255 /* When using N_BINCL in dbx output, each type number is actually a
256 pair of the file number and the type number within the file.
257 This is a stack of input files. */
261 struct dbx_file *next;
263 int next_type_number;
266 /* This is the top of the stack. */
268 static struct dbx_file *current_file;
270 /* This is the next file number to use. */
272 static int next_file_number;
274 #endif /* DBX_USE_BINCL */
276 /* These variables are for dbxout_symbol to communicate to
277 dbxout_finish_symbol.
278 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
279 current_sym_value and current_sym_addr are two ways to address the
280 value to store in the symtab entry.
281 current_sym_addr if nonzero represents the value as an rtx.
282 If that is zero, current_sym_value is used. This is used
283 when the value is an offset (such as for auto variables,
284 register variables and parms). */
286 static STAB_CODE_TYPE current_sym_code;
287 static int current_sym_value;
288 static rtx current_sym_addr;
290 /* Number of chars of symbol-description generated so far for the
291 current symbol. Used by CHARS and CONTIN. */
293 static int current_sym_nchars;
295 /* Report having output N chars of the current symbol-description. */
297 #define CHARS(N) (current_sym_nchars += (N))
299 /* Break the current symbol-description, generating a continuation,
300 if it has become long. */
302 #ifndef DBX_CONTIN_LENGTH
303 #define DBX_CONTIN_LENGTH 80
306 #if DBX_CONTIN_LENGTH > 0
308 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
313 #if defined(ASM_OUTPUT_SECTION_NAME)
314 static void dbxout_function_end PARAMS ((void));
316 static void dbxout_typedefs PARAMS ((tree));
317 static void dbxout_type_index PARAMS ((tree));
318 #if DBX_CONTIN_LENGTH > 0
319 static void dbxout_continue PARAMS ((void));
321 static void dbxout_type_fields PARAMS ((tree));
322 static void dbxout_type_method_1 PARAMS ((tree, const char *));
323 static void dbxout_type_methods PARAMS ((tree));
324 static void dbxout_range_type PARAMS ((tree));
325 static void dbxout_type PARAMS ((tree, int, int));
326 static void print_int_cst_octal PARAMS ((tree));
327 static void print_octal PARAMS ((unsigned HOST_WIDE_INT, int));
328 static void dbxout_type_name PARAMS ((tree));
329 static void dbxout_symbol_location PARAMS ((tree, tree, const char *, rtx));
330 static void dbxout_symbol_name PARAMS ((tree, const char *, int));
331 static void dbxout_prepare_symbol PARAMS ((tree));
332 static void dbxout_finish_symbol PARAMS ((tree));
333 static void dbxout_block PARAMS ((tree, int, tree));
334 static void dbxout_really_begin_function PARAMS ((tree));
336 #if defined(ASM_OUTPUT_SECTION_NAME)
338 dbxout_function_end ()
340 static int scope_labelno = 0;
341 char lscope_label_name[100];
342 /* Convert Ltext into the appropriate format for local labels in case
343 the system doesn't insert underscores in front of user generated
345 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
346 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Lscope", scope_labelno);
349 /* By convention, GCC will mark the end of a function with an N_FUN
350 symbol and an empty string. */
351 fprintf (asmfile, "%s \"\",%d,0,0,", ASM_STABS_OP, N_FUN);
352 assemble_name (asmfile, lscope_label_name);
353 fputc ('-', asmfile);
354 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
355 fprintf (asmfile, "\n");
357 #endif /* ! NO_DBX_FUNCTION_END */
359 /* At the beginning of compilation, start writing the symbol table.
360 Initialize `typevec' and output the standard data types of C. */
363 dbxout_init (asm_file, input_file_name, syms)
365 const char *input_file_name;
368 char ltext_label_name[100];
373 typevec = (struct typeinfo *) xcalloc (typevec_len, sizeof typevec[0]);
375 /* Convert Ltext into the appropriate format for local labels in case
376 the system doesn't insert underscores in front of user generated
378 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
380 /* Put the current working directory in an N_SO symbol. */
381 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
382 but GDB always does. */
383 if (use_gnu_debug_info_extensions)
386 if (!cwd && (cwd = getpwd ()) && (!*cwd || cwd[strlen (cwd) - 1] != '/'))
388 char *wdslash = xmalloc (strlen (cwd) + sizeof (FILE_NAME_JOINER));
389 sprintf (wdslash, "%s%s", cwd, FILE_NAME_JOINER);
394 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
395 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd);
396 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
397 fprintf (asmfile, "%s ", ASM_STABS_OP);
398 output_quoted_string (asmfile, cwd);
399 fprintf (asmfile, ",%d,0,0,%s\n", N_SO, <ext_label_name[1]);
400 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
404 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
405 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
406 would give us an N_SOL, and we want an N_SO. */
407 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile, input_file_name);
408 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
409 /* We include outputting `Ltext:' here,
410 because that gives you a way to override it. */
411 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
412 fprintf (asmfile, "%s ", ASM_STABS_OP);
413 output_quoted_string (asmfile, input_file_name);
414 fprintf (asmfile, ",%d,0,0,%s\n",
415 N_SO, <ext_label_name[1]);
417 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Ltext", 0);
418 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
420 /* Possibly output something to inform GDB that this compilation was by
421 GCC. It's easier for GDB to parse it when after the N_SO's. This
422 is used in Solaris 2. */
423 #ifdef ASM_IDENTIFY_GCC_AFTER_SOURCE
424 ASM_IDENTIFY_GCC_AFTER_SOURCE (asmfile);
427 lastfile = input_file_name;
429 next_type_number = 1;
432 current_file = (struct dbx_file *) xmalloc (sizeof *current_file);
433 current_file->next = NULL;
434 current_file->file_number = 0;
435 current_file->next_type_number = 1;
436 next_file_number = 1;
439 /* Make sure that types `int' and `char' have numbers 1 and 2.
440 Definitions of other integer types will refer to those numbers.
441 (Actually it should no longer matter what their numbers are.
442 Also, if any types with tags have been defined, dbxout_symbol
443 will output them first, so the numbers won't be 1 and 2. That
444 happens in C++. So it's a good thing it should no longer matter). */
446 #ifdef DBX_OUTPUT_STANDARD_TYPES
447 DBX_OUTPUT_STANDARD_TYPES (syms);
449 dbxout_symbol (TYPE_NAME (integer_type_node), 0);
450 dbxout_symbol (TYPE_NAME (char_type_node), 0);
453 /* Get all permanent types that have typedef names,
454 and output them all, except for those already output. */
456 dbxout_typedefs (syms);
458 ggc_add_string_root ((char **) &lastfile, 1);
461 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
462 in the reverse order from that which is found in SYMS. */
465 dbxout_typedefs (syms)
470 dbxout_typedefs (TREE_CHAIN (syms));
471 if (TREE_CODE (syms) == TYPE_DECL)
473 tree type = TREE_TYPE (syms);
475 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
476 && TYPE_SIZE (type) != NULL_TREE
477 && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
478 dbxout_symbol (TYPE_NAME (type), 0);
483 /* Change to reading from a new source file. Generate a N_BINCL stab. */
486 dbxout_start_new_source_file (filename)
487 const char *filename ATTRIBUTE_UNUSED;
490 struct dbx_file *n = (struct dbx_file *) xmalloc (sizeof *n);
492 n->next = current_file;
493 n->file_number = next_file_number++;
494 n->next_type_number = 1;
496 fprintf (asmfile, "%s ", ASM_STABS_OP);
497 output_quoted_string (asmfile, filename);
498 fprintf (asmfile, ",%d,0,0,0\n", N_BINCL);
502 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
505 dbxout_resume_previous_source_file ()
508 struct dbx_file *next;
510 fprintf (asmfile, "%s %d,0,0,0\n", ASM_STABN_OP, N_EINCL);
511 next = current_file->next;
517 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
520 dbxout_source_file (file, filename)
522 const char *filename;
524 char ltext_label_name[100];
526 if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
528 #ifdef DBX_OUTPUT_SOURCE_FILENAME
529 DBX_OUTPUT_SOURCE_FILENAME (file, filename);
531 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext",
532 source_label_number);
533 fprintf (file, "%s ", ASM_STABS_OP);
534 output_quoted_string (file, filename);
535 fprintf (file, ",%d,0,0,%s\n", N_SOL, <ext_label_name[1]);
536 if (current_function_decl != NULL_TREE
537 && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
538 ; /* Don't change section amid function. */
541 ASM_OUTPUT_INTERNAL_LABEL (file, "Ltext", source_label_number);
542 source_label_number++;
548 /* Output a line number symbol entry into output stream FILE,
549 for source file FILENAME and line number LINENO. */
552 dbxout_source_line (file, filename, lineno)
554 const char *filename;
557 dbxout_source_file (file, filename);
559 #ifdef ASM_OUTPUT_SOURCE_LINE
560 ASM_OUTPUT_SOURCE_LINE (file, lineno);
562 fprintf (file, "\t%s %d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno);
566 /* At the end of compilation, finish writing the symbol table.
567 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
571 dbxout_finish (file, filename)
572 FILE *file ATTRIBUTE_UNUSED;
573 const char *filename ATTRIBUTE_UNUSED;
575 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
576 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file, filename);
577 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
580 /* Output the index of a type. */
583 dbxout_type_index (type)
586 #ifndef DBX_USE_BINCL
587 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
590 struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
591 fprintf (asmfile, "(%d,%d)", t->file_number, t->type_number);
596 #if DBX_CONTIN_LENGTH > 0
597 /* Continue a symbol-description that gets too big.
598 End one symbol table entry with a double-backslash
599 and start a new one, eventually producing something like
600 .stabs "start......\\",code,0,value
601 .stabs "...rest",code,0,value */
606 #ifdef DBX_CONTIN_CHAR
607 fprintf (asmfile, "%c", DBX_CONTIN_CHAR);
609 fprintf (asmfile, "\\\\");
611 dbxout_finish_symbol (NULL_TREE);
612 fprintf (asmfile, "%s \"", ASM_STABS_OP);
613 current_sym_nchars = 0;
615 #endif /* DBX_CONTIN_LENGTH > 0 */
617 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
618 This must be a separate function because anonymous unions require
622 dbxout_type_fields (type)
626 /* Output the name, type, position (in bits), size (in bits) of each
628 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
630 /* Omit here local type decls until we know how to support them. */
631 if (TREE_CODE (tem) == TYPE_DECL)
633 /* Omit fields whose position or size are variable. */
634 else if (TREE_CODE (tem) == FIELD_DECL
635 && (TREE_CODE (DECL_FIELD_BITPOS (tem)) != INTEGER_CST
636 || TREE_CODE (DECL_SIZE (tem)) != INTEGER_CST))
638 /* Omit here the nameless fields that are used to skip bits. */
639 else if (DECL_IGNORED_P (tem))
641 else if (TREE_CODE (tem) != CONST_DECL)
643 /* Continue the line if necessary,
644 but not before the first field. */
645 if (tem != TYPE_FIELDS (type))
650 if (use_gnu_debug_info_extensions
651 && flag_minimal_debug
652 && TREE_CODE (tem) == FIELD_DECL
653 && DECL_VIRTUAL_P (tem)
654 && DECL_ASSEMBLER_NAME (tem))
656 have_used_extensions = 1;
657 CHARS (3 + IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (tem)));
658 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem)), asmfile);
659 dbxout_type (DECL_FCONTEXT (tem), 0, 0);
660 fprintf (asmfile, ":");
661 dbxout_type (TREE_TYPE (tem), 0, 0);
662 fputc (',', asmfile);
663 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
664 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)));
665 fputc (';', asmfile);
671 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
672 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem)));
676 fprintf (asmfile, ":");
680 if (use_gnu_debug_info_extensions
681 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
682 || TREE_CODE (tem) != FIELD_DECL))
684 have_used_extensions = 1;
686 putc ((TREE_PRIVATE (tem) ? '0'
687 : TREE_PROTECTED (tem) ? '1' : '2'),
692 dbxout_type ((TREE_CODE (tem) == FIELD_DECL
693 && DECL_BIT_FIELD_TYPE (tem))
694 ? DECL_BIT_FIELD_TYPE (tem)
695 : TREE_TYPE (tem), 0, 0);
697 if (TREE_CODE (tem) == VAR_DECL)
699 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
702 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem));
703 have_used_extensions = 1;
704 fprintf (asmfile, ":%s;", name);
705 CHARS (strlen (name));
709 /* If TEM is non-static, GDB won't understand it. */
710 fprintf (asmfile, ",0,0;");
713 else if (TREE_CODE (DECL_FIELD_BITPOS (tem)) == INTEGER_CST)
715 fputc (',', asmfile);
716 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
717 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)));
718 fputc (',', asmfile);
719 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
720 TREE_INT_CST_LOW (DECL_SIZE (tem)));
721 fputc (';', asmfile);
728 /* Subroutine of `dbxout_type_methods'. Output debug info about the
729 method described DECL. DEBUG_NAME is an encoding of the method's
730 type signature. ??? We may be able to do without DEBUG_NAME altogether
734 dbxout_type_method_1 (decl, debug_name)
736 const char *debug_name;
740 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
742 else /* it's a METHOD_TYPE. */
744 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
745 /* A for normal functions.
746 B for `const' member functions.
747 C for `volatile' member functions.
748 D for `const volatile' member functions. */
749 if (TYPE_READONLY (TREE_TYPE (firstarg)))
751 if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
754 if (DECL_VINDEX (decl))
760 fprintf (asmfile, ":%s;%c%c%c", debug_name,
761 TREE_PRIVATE (decl) ? '0' : TREE_PROTECTED (decl) ? '1' : '2', c1, c2);
762 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)) + 6
763 - (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
764 if (DECL_VINDEX (decl))
766 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
767 TREE_INT_CST_LOW (DECL_VINDEX (decl)));
768 fputc (';', asmfile);
769 dbxout_type (DECL_CONTEXT (decl), 0, 0);
770 fprintf (asmfile, ";");
775 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
779 dbxout_type_methods (type)
782 /* C++: put out the method names and their parameter lists */
783 tree methods = TYPE_METHODS (type);
785 register tree fndecl;
787 char formatted_type_identifier_length[16];
788 register int type_identifier_length;
790 if (methods == NULL_TREE)
793 type_encoding = DECL_NAME (TYPE_NAME (type));
796 /* C++: Template classes break some assumptions made by this code about
797 the class names, constructor names, and encodings for assembler
798 label names. For now, disable output of dbx info for them. */
800 const char *ptr = IDENTIFIER_POINTER (type_encoding);
801 /* This should use index. (mrs) */
802 while (*ptr && *ptr != '<') ptr++;
813 type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
815 sprintf(formatted_type_identifier_length, "%d", type_identifier_length);
817 if (TREE_CODE (methods) != TREE_VEC)
819 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
820 fndecl = TREE_VEC_ELT (methods, 0);
822 fndecl = TREE_VEC_ELT (methods, 1);
826 tree name = DECL_NAME (fndecl);
829 /* Group together all the methods for the same operation.
830 These differ in the types of the arguments. */
831 for (last = NULL_TREE;
832 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
833 fndecl = TREE_CHAIN (fndecl))
834 /* Output the name of the field (after overloading), as
835 well as the name of the field before overloading, along
836 with its parameter list */
838 /* This is the "mangled" name of the method.
839 It encodes the argument types. */
840 const char *debug_name =
841 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
842 int show_arg_types = 0;
848 if (DECL_IGNORED_P (fndecl))
851 if (flag_minimal_debug)
855 /* We can't optimize a method which uses an anonymous
856 class, because the debugger will not be able to
857 associate the arbitrary class name with the actual
859 #ifndef NO_DOLLAR_IN_LABEL
864 if (strchr (debug_name, marker))
866 /* Detect ordinary methods because their mangled names
867 start with the operation name. */
868 else if (!strncmp (IDENTIFIER_POINTER (name), debug_name,
869 IDENTIFIER_LENGTH (name)))
871 debug_name += IDENTIFIER_LENGTH (name);
872 if (debug_name[0] == '_' && debug_name[1] == '_')
874 const char *method_name = debug_name + 2;
875 const char *length_ptr =
876 formatted_type_identifier_length;
877 /* Get past const and volatile qualifiers. */
878 while (*method_name == 'C' || *method_name == 'V')
880 /* Skip digits for length of type_encoding. */
881 while (*method_name == *length_ptr && *length_ptr)
882 length_ptr++, method_name++;
883 if (! strncmp (method_name,
884 IDENTIFIER_POINTER (type_encoding),
885 type_identifier_length))
886 method_name += type_identifier_length;
887 debug_name = method_name;
890 /* Detect constructors by their style of name mangling. */
891 else if (debug_name[0] == '_' && debug_name[1] == '_')
893 const char *ctor_name = debug_name + 2;
894 const char *length_ptr = formatted_type_identifier_length;
895 while (*ctor_name == 'C' || *ctor_name == 'V')
897 /* Skip digits for length of type_encoding. */
898 while (*ctor_name == *length_ptr && *length_ptr)
899 length_ptr++, ctor_name++;
900 if (!strncmp (IDENTIFIER_POINTER (type_encoding), ctor_name,
901 type_identifier_length))
902 debug_name = ctor_name + type_identifier_length;
904 /* The other alternative is a destructor. */
908 /* Output the operation name just once, for the first method
912 fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
913 CHARS (IDENTIFIER_LENGTH (name) + 2);
918 dbxout_type (TREE_TYPE (fndecl), 0, show_arg_types);
920 dbxout_type_method_1 (fndecl, debug_name);
930 /* Emit a "range" type specification, which has the form:
931 "r<index type>;<lower bound>;<upper bound>;".
932 TYPE is an INTEGER_TYPE. */
935 dbxout_range_type (type)
938 fprintf (asmfile, "r");
939 if (TREE_TYPE (type))
940 dbxout_type (TREE_TYPE (type), 0, 0);
941 else if (TREE_CODE (type) != INTEGER_TYPE)
942 dbxout_type (type, 0, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
945 /* Traditionally, we made sure 'int' was type 1, and builtin types
946 were defined to be sub-ranges of int. Unfortunately, this
947 does not allow us to distinguish true sub-ranges from integer
948 types. So, instead we define integer (non-sub-range) types as
949 sub-ranges of themselves. This matters for Chill. If this isn't
950 a subrange type, then we want to define it in terms of itself.
951 However, in C, this may be an anonymous integer type, and we don't
952 want to emit debug info referring to it. Just calling
953 dbxout_type_index won't work anyways, because the type hasn't been
954 defined yet. We make this work for both cases by checked to see
955 whether this is a defined type, referring to it if it is, and using
957 if (TYPE_SYMTAB_ADDRESS (type) != 0)
958 dbxout_type_index (type);
960 dbxout_type_index (integer_type_node);
962 if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
964 fputc (';', asmfile);
965 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
966 TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)));
969 fprintf (asmfile, ";0");
970 if (TYPE_MAX_VALUE (type)
971 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
973 fputc (';', asmfile);
974 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
975 TREE_INT_CST_LOW (TYPE_MAX_VALUE (type)));
976 fputc (';', asmfile);
979 fprintf (asmfile, ";-1;");
982 /* Output a reference to a type. If the type has not yet been
983 described in the dbx output, output its definition now.
984 For a type already defined, just refer to its definition
985 using the type number.
987 If FULL is nonzero, and the type has been described only with
988 a forward-reference, output the definition now.
989 If FULL is zero in this case, just refer to the forward-reference
990 using the number previously allocated.
992 If SHOW_ARG_TYPES is nonzero, we output a description of the argument
993 types for a METHOD_TYPE. */
996 dbxout_type (type, full, show_arg_types)
1002 static int anonymous_type_number = 0;
1004 /* If there was an input error and we don't really have a type,
1005 avoid crashing and write something that is at least valid
1006 by assuming `int'. */
1007 if (type == error_mark_node)
1008 type = integer_type_node;
1011 /* Try to find the "main variant" with the same name but not const
1012 or volatile. (Since stabs does not distinguish const and volatile,
1013 there is no need to make them separate types. But types with
1014 different names are usefully distinguished.) */
1016 for (tem = TYPE_MAIN_VARIANT (type); tem; tem = TYPE_NEXT_VARIANT (tem))
1017 if (!TYPE_READONLY (tem) && !TYPE_VOLATILE (tem)
1018 && TYPE_NAME (tem) == TYPE_NAME (type))
1023 if (TYPE_NAME (type)
1024 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1025 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
1029 if (TYPE_SYMTAB_ADDRESS (type) == 0)
1031 /* Type has no dbx number assigned. Assign next available number. */
1032 TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
1034 /* Make sure type vector is long enough to record about this type. */
1036 if (next_type_number == typevec_len)
1039 = (struct typeinfo *) xrealloc (typevec,
1040 typevec_len * 2 * sizeof typevec[0]);
1041 bzero ((char *) (typevec + typevec_len),
1042 typevec_len * sizeof typevec[0]);
1046 #ifdef DBX_USE_BINCL
1047 typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
1048 = current_file->file_number;
1049 typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
1050 = current_file->next_type_number++;
1054 /* Output the number of this type, to refer to it. */
1055 dbxout_type_index (type);
1057 #ifdef DBX_TYPE_DEFINED
1058 if (DBX_TYPE_DEFINED (type))
1062 /* If this type's definition has been output or is now being output,
1065 switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
1070 /* If we have already had a cross reference,
1071 and either that's all we want or that's the best we could do,
1072 don't repeat the cross reference.
1073 Sun dbx crashes if we do. */
1074 if (! full || TYPE_SIZE (type) == 0
1075 /* No way in DBX fmt to describe a variable size. */
1076 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1084 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1085 leave the type-number completely undefined rather than output
1086 a cross-reference. If we have already used GNU debug info extensions,
1087 then it is OK to output a cross reference. This is necessary to get
1088 proper C++ debug output. */
1089 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
1090 || TREE_CODE (type) == QUAL_UNION_TYPE
1091 || TREE_CODE (type) == ENUMERAL_TYPE)
1092 && ! use_gnu_debug_info_extensions)
1093 /* We must use the same test here as we use twice below when deciding
1094 whether to emit a cross-reference. */
1095 if ((TYPE_NAME (type) != 0
1096 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1097 && DECL_IGNORED_P (TYPE_NAME (type)))
1099 || TYPE_SIZE (type) == 0
1100 /* No way in DBX fmt to describe a variable size. */
1101 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1103 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1108 /* Output a definition now. */
1110 fprintf (asmfile, "=");
1113 /* Mark it as defined, so that if it is self-referent
1114 we will not get into an infinite recursion of definitions. */
1116 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
1118 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1119 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1121 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0, 0);
1125 switch (TREE_CODE (type))
1129 /* For a void type, just define it as itself; ie, "5=5".
1130 This makes us consider it defined
1131 without saying what it is. The debugger will make it
1132 a void type when the reference is seen, and nothing will
1133 ever override that default. */
1134 dbxout_type_index (type);
1138 if (type == char_type_node && ! TREE_UNSIGNED (type))
1140 /* Output the type `char' as a subrange of itself!
1141 I don't understand this definition, just copied it
1142 from the output of pcc.
1143 This used to use `r2' explicitly and we used to
1144 take care to make sure that `char' was type number 2. */
1145 fprintf (asmfile, "r");
1146 dbxout_type_index (type);
1147 fprintf (asmfile, ";0;127;");
1150 /* If this is a subtype of another integer type, always prefer to
1151 write it as a subtype. */
1152 else if (TREE_TYPE (type) != 0
1153 && TREE_CODE (TREE_TYPE (type)) == INTEGER_CST)
1154 dbxout_range_type (type);
1158 /* If the size is non-standard, say what it is if we can use
1161 if (use_gnu_debug_info_extensions
1162 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1163 fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1165 /* If we can use GDB extensions and the size is wider than a
1166 long (the size used by GDB to read them) or we may have
1167 trouble writing the bounds the usual way, write them in
1168 octal. Note the test is for the *target's* size of "long",
1169 not that of the host. The host test is just to make sure we
1170 can write it out in case the host wide int is narrower than the
1173 /* For unsigned types, we use octal if they are the same size or
1174 larger. This is because we print the bounds as signed decimal,
1175 and hence they can't span same size unsigned types. */
1177 if (use_gnu_debug_info_extensions
1178 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
1179 || (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)
1180 && TREE_UNSIGNED (type))
1181 || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
1182 || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
1183 && TREE_UNSIGNED (type))))
1185 fprintf (asmfile, "r");
1186 dbxout_type_index (type);
1187 fprintf (asmfile, ";");
1188 print_int_cst_octal (TYPE_MIN_VALUE (type));
1189 fprintf (asmfile, ";");
1190 print_int_cst_octal (TYPE_MAX_VALUE (type));
1191 fprintf (asmfile, ";");
1195 /* Output other integer types as subranges of `int'. */
1196 dbxout_range_type (type);
1203 /* This used to say `r1' and we used to take care
1204 to make sure that `int' was type number 1. */
1205 fprintf (asmfile, "r");
1206 dbxout_type_index (integer_type_node);
1207 fputc (';', asmfile);
1208 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, int_size_in_bytes (type));
1209 fputs (";0;", asmfile);
1214 if (use_gnu_debug_info_extensions)
1216 fputs ("@s", asmfile);
1217 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1218 BITS_PER_UNIT * int_size_in_bytes (type));
1219 fputs (";-20;", asmfile);
1223 /* Output the type `char' as a subrange of itself.
1224 That is what pcc seems to do. */
1225 fprintf (asmfile, "r");
1226 dbxout_type_index (char_type_node);
1227 fprintf (asmfile, ";0;%d;", TREE_UNSIGNED (type) ? 255 : 127);
1233 if (use_gnu_debug_info_extensions)
1235 fputs ("@s", asmfile);
1236 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1237 BITS_PER_UNIT * int_size_in_bytes (type));
1238 fputs (";-16;", asmfile);
1240 else /* Define as enumeral type (False, True) */
1241 fprintf (asmfile, "eFalse:0,True:1,;");
1246 putc ('d', asmfile);
1248 dbxout_type (TREE_TYPE (type), 0, 0);
1252 /* Differs from the REAL_TYPE by its new data type number */
1254 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1256 fprintf (asmfile, "r");
1257 dbxout_type_index (type);
1258 fputc (';', asmfile);
1259 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1260 int_size_in_bytes (TREE_TYPE (type)));
1261 fputs (";0;", asmfile);
1262 CHARS (12); /* The number is probably incorrect here. */
1266 /* Output a complex integer type as a structure,
1267 pending some other way to do it. */
1268 fputc ('s', asmfile);
1269 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, int_size_in_bytes (type));
1271 fprintf (asmfile, "real:");
1273 dbxout_type (TREE_TYPE (type), 0, 0);
1274 fprintf (asmfile, ",%d,%d;",
1275 0, TYPE_PRECISION (TREE_TYPE (type)));
1277 fprintf (asmfile, "imag:");
1279 dbxout_type (TREE_TYPE (type), 0, 0);
1280 fprintf (asmfile, ",%d,%d;;",
1281 TYPE_PRECISION (TREE_TYPE (type)),
1282 TYPE_PRECISION (TREE_TYPE (type)));
1288 if (use_gnu_debug_info_extensions)
1290 have_used_extensions = 1;
1291 fputs ("@s", asmfile);
1292 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1293 BITS_PER_UNIT * int_size_in_bytes (type));
1294 fputc (';', asmfile);
1295 /* Check if a bitstring type, which in Chill is
1296 different from a [power]set. */
1297 if (TYPE_STRING_FLAG (type))
1298 fprintf (asmfile, "@S;");
1300 putc ('S', asmfile);
1302 dbxout_type (TYPE_DOMAIN (type), 0, 0);
1306 /* Make arrays of packed bits look like bitstrings for chill. */
1307 if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
1309 have_used_extensions = 1;
1310 fputs ("@s", asmfile);
1311 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1312 BITS_PER_UNIT * int_size_in_bytes (type));
1313 fputc (';', asmfile);
1314 fprintf (asmfile, "@S;");
1315 putc ('S', asmfile);
1317 dbxout_type (TYPE_DOMAIN (type), 0, 0);
1320 /* Output "a" followed by a range type definition
1321 for the index type of the array
1322 followed by a reference to the target-type.
1323 ar1;0;N;M for a C array of type M and size N+1. */
1324 /* Check if a character string type, which in Chill is
1325 different from an array of characters. */
1326 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
1328 have_used_extensions = 1;
1329 fprintf (asmfile, "@S;");
1331 tem = TYPE_DOMAIN (type);
1334 fprintf (asmfile, "ar");
1335 dbxout_type_index (integer_type_node);
1336 fprintf (asmfile, ";0;-1;");
1340 fprintf (asmfile, "a");
1341 dbxout_range_type (tem);
1344 dbxout_type (TREE_TYPE (type), 0, 0);
1349 case QUAL_UNION_TYPE:
1351 int i, n_baseclasses = 0;
1353 if (TYPE_BINFO (type) != 0
1354 && TREE_CODE (TYPE_BINFO (type)) == TREE_VEC
1355 && TYPE_BINFO_BASETYPES (type) != 0)
1356 n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
1358 /* Output a structure type. We must use the same test here as we
1359 use in the DBX_NO_XREFS case above. */
1360 if ((TYPE_NAME (type) != 0
1361 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1362 && DECL_IGNORED_P (TYPE_NAME (type)))
1364 || TYPE_SIZE (type) == 0
1365 /* No way in DBX fmt to describe a variable size. */
1366 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1368 /* If the type is just a cross reference, output one
1369 and mark the type as partially described.
1370 If it later becomes defined, we will output
1371 its real definition.
1372 If the type has a name, don't nest its definition within
1373 another type's definition; instead, output an xref
1374 and let the definition come when the name is defined. */
1375 fputs ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu", asmfile);
1377 #if 0 /* This assertion is legitimately false in C++. */
1378 /* We shouldn't be outputting a reference to a type before its
1379 definition unless the type has a tag name.
1380 A typedef name without a tag name should be impossible. */
1381 if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
1384 if (TYPE_NAME (type) != 0)
1385 dbxout_type_name (type);
1387 fprintf (asmfile, "$$%d", anonymous_type_number++);
1388 fprintf (asmfile, ":");
1389 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1393 /* Identify record or union, and print its size. */
1394 fputc (((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'), asmfile);
1395 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1396 int_size_in_bytes (type));
1398 if (use_gnu_debug_info_extensions)
1402 have_used_extensions = 1;
1403 fprintf (asmfile, "!%d,", n_baseclasses);
1407 for (i = 0; i < n_baseclasses; i++)
1409 tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i);
1410 if (use_gnu_debug_info_extensions)
1412 have_used_extensions = 1;
1413 putc (TREE_VIA_VIRTUAL (child) ? '1'
1416 putc (TREE_VIA_PUBLIC (child) ? '2'
1419 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1420 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT);
1421 fputc (',', asmfile);
1423 dbxout_type (BINFO_TYPE (child), 0, 0);
1424 putc (';', asmfile);
1428 /* Print out the base class information with fields
1429 which have the same names at the types they hold. */
1430 dbxout_type_name (BINFO_TYPE (child));
1431 putc (':', asmfile);
1432 dbxout_type (BINFO_TYPE (child), full, 0);
1433 fputc (',', asmfile);
1434 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1435 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT);
1436 fputc (',', asmfile);
1437 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1438 TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child)))) * BITS_PER_UNIT);
1439 fputc (';', asmfile);
1447 /* Write out the field declarations. */
1448 dbxout_type_fields (type);
1449 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
1451 have_used_extensions = 1;
1452 dbxout_type_methods (type);
1454 putc (';', asmfile);
1456 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
1457 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1458 && TYPE_VFIELD (type))
1460 have_used_extensions = 1;
1462 /* Tell GDB+ that it may keep reading. */
1463 putc ('~', asmfile);
1465 /* We need to write out info about what field this class
1466 uses as its "main" vtable pointer field, because if this
1467 field is inherited from a base class, GDB cannot necessarily
1468 figure out which field it's using in time. */
1469 if (TYPE_VFIELD (type))
1471 putc ('%', asmfile);
1472 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0, 0);
1474 putc (';', asmfile);
1480 /* We must use the same test here as we use in the DBX_NO_XREFS case
1481 above. We simplify it a bit since an enum will never have a variable
1483 if ((TYPE_NAME (type) != 0
1484 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1485 && DECL_IGNORED_P (TYPE_NAME (type)))
1487 || TYPE_SIZE (type) == 0)
1489 fprintf (asmfile, "xe");
1491 dbxout_type_name (type);
1492 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1493 fprintf (asmfile, ":");
1496 #ifdef DBX_OUTPUT_ENUM
1497 DBX_OUTPUT_ENUM (asmfile, type);
1499 if (use_gnu_debug_info_extensions
1500 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1501 fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1502 putc ('e', asmfile);
1504 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
1506 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1507 if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
1508 fprintf (asmfile, HOST_WIDE_INT_PRINT_UNSIGNED,
1509 TREE_INT_CST_LOW (TREE_VALUE (tem)));
1510 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
1511 && TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
1512 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1513 TREE_INT_CST_LOW (TREE_VALUE (tem)));
1515 print_int_cst_octal (TREE_VALUE (tem));
1516 fprintf (asmfile, ",");
1517 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem)));
1518 if (TREE_CHAIN (tem) != 0)
1523 putc (';', asmfile);
1529 putc ('*', asmfile);
1531 dbxout_type (TREE_TYPE (type), 0, 0);
1535 if (use_gnu_debug_info_extensions)
1537 have_used_extensions = 1;
1538 putc ('#', asmfile);
1540 if (flag_minimal_debug && !show_arg_types)
1542 /* Normally, just output the return type.
1543 The argument types are encoded in the method name. */
1544 putc ('#', asmfile);
1546 dbxout_type (TREE_TYPE (type), 0, 0);
1547 putc (';', asmfile);
1552 /* When outputting destructors, we need to write
1553 the argument types out longhand. */
1554 dbxout_type (TYPE_METHOD_BASETYPE (type), 0, 0);
1555 putc (',', asmfile);
1557 dbxout_type (TREE_TYPE (type), 0, 0);
1558 dbxout_args (TYPE_ARG_TYPES (type));
1559 putc (';', asmfile);
1565 /* Treat it as a function type. */
1566 dbxout_type (TREE_TYPE (type), 0, 0);
1571 if (use_gnu_debug_info_extensions)
1573 have_used_extensions = 1;
1574 putc ('@', asmfile);
1576 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0, 0);
1577 putc (',', asmfile);
1579 dbxout_type (TREE_TYPE (type), 0, 0);
1583 /* Should print as an int, because it is really
1585 dbxout_type (integer_type_node, 0, 0);
1589 case REFERENCE_TYPE:
1590 if (use_gnu_debug_info_extensions)
1591 have_used_extensions = 1;
1592 putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
1594 dbxout_type (TREE_TYPE (type), 0, 0);
1598 putc ('f', asmfile);
1600 dbxout_type (TREE_TYPE (type), 0, 0);
1608 /* Print the value of integer constant C, in octal,
1609 handling double precision. */
1612 print_int_cst_octal (c)
1615 unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
1616 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
1617 int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
1618 int width = TYPE_PRECISION (TREE_TYPE (c));
1620 /* GDB wants constants with no extra leading "1" bits, so
1621 we need to remove any sign-extension that might be
1623 if (width == HOST_BITS_PER_WIDE_INT * 2)
1625 else if (width > HOST_BITS_PER_WIDE_INT)
1626 high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
1627 else if (width == HOST_BITS_PER_WIDE_INT)
1630 high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
1632 fprintf (asmfile, "0");
1636 print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
1637 print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
1641 unsigned HOST_WIDE_INT beg = high >> excess;
1642 unsigned HOST_WIDE_INT middle
1643 = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
1644 | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
1645 unsigned HOST_WIDE_INT end
1646 = low & (((unsigned HOST_WIDE_INT) 1
1647 << (HOST_BITS_PER_WIDE_INT / 3 * 3))
1650 fprintf (asmfile, "%o%01o", (int)beg, (int)middle);
1651 print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
1656 print_octal (value, digits)
1657 unsigned HOST_WIDE_INT value;
1662 for (i = digits - 1; i >= 0; i--)
1663 fprintf (asmfile, "%01o", (int)((value >> (3 * i)) & 7));
1666 /* Output the name of type TYPE, with no punctuation.
1667 Such names can be set up either by typedef declarations
1668 or by struct, enum and union tags. */
1671 dbxout_type_name (type)
1675 if (TYPE_NAME (type) == 0)
1677 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
1679 t = TYPE_NAME (type);
1681 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1683 t = DECL_NAME (TYPE_NAME (type));
1688 fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
1689 CHARS (IDENTIFIER_LENGTH (t));
1692 /* Output a .stabs for the symbol defined by DECL,
1693 which must be a ..._DECL node in the normal namespace.
1694 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1695 LOCAL is nonzero if the scope is less than the entire file. */
1698 dbxout_symbol (decl, local)
1700 int local ATTRIBUTE_UNUSED;
1702 tree type = TREE_TYPE (decl);
1703 tree context = NULL_TREE;
1705 /* Cast avoids warning in old compilers. */
1706 current_sym_code = (STAB_CODE_TYPE) 0;
1707 current_sym_value = 0;
1708 current_sym_addr = 0;
1710 /* Ignore nameless syms, but don't ignore type tags. */
1712 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
1713 || DECL_IGNORED_P (decl))
1716 dbxout_prepare_symbol (decl);
1718 /* The output will always start with the symbol name,
1719 so always count that in the length-output-so-far. */
1721 if (DECL_NAME (decl) != 0)
1722 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
1724 switch (TREE_CODE (decl))
1727 /* Enum values are defined by defining the enum type. */
1731 if (DECL_RTL (decl) == 0)
1733 if (DECL_EXTERNAL (decl))
1735 /* Don't mention a nested function under its parent. */
1736 context = decl_function_context (decl);
1737 if (context == current_function_decl)
1739 if (GET_CODE (DECL_RTL (decl)) != MEM
1740 || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
1744 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
1745 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1746 TREE_PUBLIC (decl) ? 'F' : 'f');
1748 current_sym_code = N_FUN;
1749 current_sym_addr = XEXP (DECL_RTL (decl), 0);
1751 if (TREE_TYPE (type))
1752 dbxout_type (TREE_TYPE (type), 0, 0);
1754 dbxout_type (void_type_node, 0, 0);
1756 /* For a nested function, when that function is compiled,
1757 mention the containing function name
1758 as well as (since dbx wants it) our own assembler-name. */
1760 fprintf (asmfile, ",%s,%s",
1761 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1762 IDENTIFIER_POINTER (DECL_NAME (context)));
1764 dbxout_finish_symbol (decl);
1769 /* This seems all wrong. Outputting most kinds of types gives no name
1770 at all. A true definition gives no name; a cross-ref for a
1771 structure can give the tag name, but not a type name.
1772 It seems that no typedef name is defined by outputting a type. */
1774 /* If this typedef name was defined by outputting the type,
1775 don't duplicate it. */
1776 if (typevec[TYPE_SYMTAB_ADDRESS (type)].status == TYPE_DEFINED
1777 && TYPE_NAME (TREE_TYPE (decl)) == decl)
1780 /* Don't output the same typedef twice.
1781 And don't output what language-specific stuff doesn't want output. */
1782 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
1791 if (DECL_NAME (decl))
1793 /* Nonzero means we must output a tag as well as a typedef. */
1796 /* Handle the case of a C++ structure or union
1797 where the TYPE_NAME is a TYPE_DECL
1798 which gives both a typedef name and a tag. */
1799 /* dbx requires the tag first and the typedef second. */
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
1804 && !(use_gnu_debug_info_extensions && have_used_extensions)
1805 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
1806 /* Distinguish the implicit typedefs of C++
1807 from explicit ones that might be found in C. */
1808 && DECL_ARTIFICIAL (decl))
1810 tree name = TYPE_NAME (type);
1811 if (TREE_CODE (name) == TYPE_DECL)
1812 name = DECL_NAME (name);
1814 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1815 current_sym_value = 0;
1816 current_sym_addr = 0;
1817 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1819 fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP,
1820 IDENTIFIER_POINTER (name));
1821 dbxout_type (type, 1, 0);
1822 dbxout_finish_symbol (NULL_TREE);
1825 /* Output typedef name. */
1826 fprintf (asmfile, "%s \"%s:", ASM_STABS_OP,
1827 IDENTIFIER_POINTER (DECL_NAME (decl)));
1829 /* Short cut way to output a tag also. */
1830 if ((TREE_CODE (type) == RECORD_TYPE
1831 || TREE_CODE (type) == UNION_TYPE
1832 || TREE_CODE (type) == QUAL_UNION_TYPE)
1833 && TYPE_NAME (type) == decl
1834 /* Distinguish the implicit typedefs of C++
1835 from explicit ones that might be found in C. */
1836 && DECL_ARTIFICIAL (decl))
1838 if (use_gnu_debug_info_extensions && have_used_extensions)
1840 putc ('T', asmfile);
1841 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
1843 #if 0 /* Now we generate the tag for this case up above. */
1849 putc ('t', asmfile);
1850 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1852 dbxout_type (type, 1, 0);
1853 dbxout_finish_symbol (decl);
1857 /* Don't output a tag if this is an incomplete type (TYPE_SIZE is
1858 zero). This prevents the sun4 Sun OS 4.x dbx from crashing. */
1860 if (tag_needed && TYPE_NAME (type) != 0
1861 && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
1862 || (DECL_NAME (TYPE_NAME (type)) != 0))
1863 && TYPE_SIZE (type) != 0
1864 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
1866 /* For a TYPE_DECL with no name, but the type has a name,
1868 This is what represents `struct foo' with no typedef. */
1869 /* In C++, the name of a type is the corresponding typedef.
1870 In C, it is an IDENTIFIER_NODE. */
1871 tree name = TYPE_NAME (type);
1872 if (TREE_CODE (name) == TYPE_DECL)
1873 name = DECL_NAME (name);
1875 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1876 current_sym_value = 0;
1877 current_sym_addr = 0;
1878 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1880 fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP,
1881 IDENTIFIER_POINTER (name));
1882 dbxout_type (type, 1, 0);
1883 dbxout_finish_symbol (NULL_TREE);
1887 /* If an enum type has no name, it cannot be referred to,
1888 but we must output it anyway, since the enumeration constants
1889 can be referred to. */
1890 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
1892 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1893 current_sym_value = 0;
1894 current_sym_addr = 0;
1895 current_sym_nchars = 2;
1897 /* Some debuggers fail when given NULL names, so give this a
1898 harmless name of ` '. */
1899 fprintf (asmfile, "%s \" :T", ASM_STABS_OP);
1900 dbxout_type (type, 1, 0);
1901 dbxout_finish_symbol (NULL_TREE);
1904 /* Prevent duplicate output of a typedef. */
1905 TREE_ASM_WRITTEN (decl) = 1;
1910 /* Parm decls go in their own separate chains
1911 and are output by dbxout_reg_parms and dbxout_parms. */
1915 /* Named return value, treat like a VAR_DECL. */
1917 if (DECL_RTL (decl) == 0)
1919 /* Don't mention a variable that is external.
1920 Let the file that defines it describe it. */
1921 if (DECL_EXTERNAL (decl))
1924 /* If the variable is really a constant
1925 and not written in memory, inform the debugger. */
1926 if (TREE_STATIC (decl) && TREE_READONLY (decl)
1927 && DECL_INITIAL (decl) != 0
1928 && ! TREE_ASM_WRITTEN (decl)
1929 && (DECL_FIELD_CONTEXT (decl) == NULL_TREE
1930 || TREE_CODE (DECL_FIELD_CONTEXT (decl)) == BLOCK))
1932 if (TREE_PUBLIC (decl) == 0)
1934 /* The sun4 assembler does not grok this. */
1935 const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1936 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
1937 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
1939 HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl));
1940 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1941 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile, name, ival);
1943 fprintf (asmfile, "%s \"%s:c=i", ASM_STABS_OP, name);
1945 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, ival);
1946 fprintf (asmfile, "\",0x%x,0,0,0\n", N_LSYM);
1950 else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
1952 /* don't know how to do this yet. */
1956 /* else it is something we handle like a normal variable. */
1959 DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, NULL_RTX);
1960 #ifdef LEAF_REG_REMAP
1961 if (current_function_uses_only_leaf_regs)
1962 leaf_renumber_regs_insn (DECL_RTL (decl));
1965 dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
1973 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1974 Add SUFFIX to its name, if SUFFIX is not 0.
1975 Describe the variable as residing in HOME
1976 (usually HOME is DECL_RTL (DECL), but not always). */
1979 dbxout_symbol_location (decl, type, suffix, home)
1987 /* Don't mention a variable at all
1988 if it was completely optimized into nothingness.
1990 If the decl was from an inline function, then its rtl
1991 is not identically the rtl that was used in this
1992 particular compilation. */
1993 if (GET_CODE (home) == REG)
1995 regno = REGNO (home);
1996 if (regno >= FIRST_PSEUDO_REGISTER)
1999 else if (GET_CODE (home) == SUBREG)
2003 while (GET_CODE (value) == SUBREG)
2005 offset += SUBREG_WORD (value);
2006 value = SUBREG_REG (value);
2008 if (GET_CODE (value) == REG)
2010 regno = REGNO (value);
2011 if (regno >= FIRST_PSEUDO_REGISTER)
2015 alter_subreg (home);
2018 /* The kind-of-variable letter depends on where
2019 the variable is and on the scope of its name:
2020 G and N_GSYM for static storage and global scope,
2021 S for static storage and file scope,
2022 V for static storage and local scope,
2023 for those two, use N_LCSYM if data is in bss segment,
2024 N_STSYM if in data segment, N_FUN otherwise.
2025 (We used N_FUN originally, then changed to N_STSYM
2026 to please GDB. However, it seems that confused ld.
2027 Now GDB has been fixed to like N_FUN, says Kingdon.)
2028 no letter at all, and N_LSYM, for auto variable,
2029 r and N_RSYM for register variable. */
2031 if (GET_CODE (home) == MEM
2032 && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
2034 if (TREE_PUBLIC (decl))
2037 current_sym_code = N_GSYM;
2041 current_sym_addr = XEXP (home, 0);
2043 letter = decl_function_context (decl) ? 'V' : 'S';
2045 /* This should be the same condition as in assemble_variable, but
2046 we don't have access to dont_output_data here. So, instead,
2047 we rely on the fact that error_mark_node initializers always
2048 end up in bss for C++ and never end up in bss for C. */
2049 if (DECL_INITIAL (decl) == 0
2050 || (!strcmp (lang_identify (), "cplusplus")
2051 && DECL_INITIAL (decl) == error_mark_node))
2052 current_sym_code = N_LCSYM;
2053 else if (DECL_IN_TEXT_SECTION (decl))
2054 /* This is not quite right, but it's the closest
2055 of all the codes that Unix defines. */
2056 current_sym_code = DBX_STATIC_CONST_VAR_CODE;
2059 /* Ultrix `as' seems to need this. */
2060 #ifdef DBX_STATIC_STAB_DATA_SECTION
2063 current_sym_code = N_STSYM;
2067 else if (regno >= 0)
2070 current_sym_code = N_RSYM;
2071 current_sym_value = DBX_REGISTER_NUMBER (regno);
2073 else if (GET_CODE (home) == MEM
2074 && (GET_CODE (XEXP (home, 0)) == MEM
2075 || (GET_CODE (XEXP (home, 0)) == REG
2076 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
2077 && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
2078 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2079 && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
2082 /* If the value is indirect by memory or by a register
2083 that isn't the frame pointer
2084 then it means the object is variable-sized and address through
2085 that register or stack slot. DBX has no way to represent this
2086 so all we can do is output the variable as a pointer.
2087 If it's not a parameter, ignore it.
2088 (VAR_DECLs like this can be made by integrate.c.) */
2090 if (GET_CODE (XEXP (home, 0)) == REG)
2093 current_sym_code = N_RSYM;
2094 current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
2098 current_sym_code = N_LSYM;
2099 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2100 We want the value of that CONST_INT. */
2102 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
2105 /* Effectively do build_pointer_type, but don't cache this type,
2106 since it might be temporary whereas the type it points to
2107 might have been saved for inlining. */
2108 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2109 type = make_node (POINTER_TYPE);
2110 TREE_TYPE (type) = TREE_TYPE (decl);
2112 else if (GET_CODE (home) == MEM
2113 && GET_CODE (XEXP (home, 0)) == REG)
2115 current_sym_code = N_LSYM;
2116 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2118 else if (GET_CODE (home) == MEM
2119 && GET_CODE (XEXP (home, 0)) == PLUS
2120 && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
2122 current_sym_code = N_LSYM;
2123 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2124 We want the value of that CONST_INT. */
2125 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2127 else if (GET_CODE (home) == MEM
2128 && GET_CODE (XEXP (home, 0)) == CONST)
2130 /* Handle an obscure case which can arise when optimizing and
2131 when there are few available registers. (This is *always*
2132 the case for i386/i486 targets). The RTL looks like
2133 (MEM (CONST ...)) even though this variable is a local `auto'
2134 or a local `register' variable. In effect, what has happened
2135 is that the reload pass has seen that all assignments and
2136 references for one such a local variable can be replaced by
2137 equivalent assignments and references to some static storage
2138 variable, thereby avoiding the need for a register. In such
2139 cases we're forced to lie to debuggers and tell them that
2140 this variable was itself `static'. */
2141 current_sym_code = N_LCSYM;
2143 current_sym_addr = XEXP (XEXP (home, 0), 0);
2145 else if (GET_CODE (home) == CONCAT)
2147 tree subtype = TREE_TYPE (type);
2149 /* If the variable's storage is in two parts,
2150 output each as a separate stab with a modified name. */
2151 if (WORDS_BIG_ENDIAN)
2152 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
2154 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
2156 /* Cast avoids warning in old compilers. */
2157 current_sym_code = (STAB_CODE_TYPE) 0;
2158 current_sym_value = 0;
2159 current_sym_addr = 0;
2160 dbxout_prepare_symbol (decl);
2162 if (WORDS_BIG_ENDIAN)
2163 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
2165 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
2169 /* Address might be a MEM, when DECL is a variable-sized object.
2170 Or it might be const0_rtx, meaning previous passes
2171 want us to ignore this variable. */
2174 /* Ok, start a symtab entry and output the variable name. */
2177 #ifdef DBX_STATIC_BLOCK_START
2178 DBX_STATIC_BLOCK_START (asmfile, current_sym_code);
2181 dbxout_symbol_name (decl, suffix, letter);
2182 dbxout_type (type, 0, 0);
2183 dbxout_finish_symbol (decl);
2185 #ifdef DBX_STATIC_BLOCK_END
2186 DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
2190 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2191 Then output LETTER to indicate the kind of location the symbol has. */
2194 dbxout_symbol_name (decl, suffix, letter)
2199 /* One slight hitch: if this is a VAR_DECL which is a static
2200 class member, we must put out the mangled name instead of the
2201 DECL_NAME. Note also that static member (variable) names DO NOT begin
2202 with underscores in .stabs directives. */
2203 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2206 fprintf (asmfile, "%s \"%s%s:", ASM_STABS_OP, name,
2207 (suffix ? suffix : ""));
2209 if (letter) putc (letter, asmfile);
2213 dbxout_prepare_symbol (decl)
2214 tree decl ATTRIBUTE_UNUSED;
2217 const char *filename = DECL_SOURCE_FILE (decl);
2219 dbxout_source_file (asmfile, filename);
2224 dbxout_finish_symbol (sym)
2227 #ifdef DBX_FINISH_SYMBOL
2228 DBX_FINISH_SYMBOL (sym);
2231 if (use_gnu_debug_info_extensions && sym != 0)
2232 line = DECL_SOURCE_LINE (sym);
2234 fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line);
2235 if (current_sym_addr)
2236 output_addr_const (asmfile, current_sym_addr);
2238 fprintf (asmfile, "%d", current_sym_value);
2239 putc ('\n', asmfile);
2243 /* Output definitions of all the decls in a chain. */
2251 dbxout_symbol (syms, 1);
2252 syms = TREE_CHAIN (syms);
2256 /* The following two functions output definitions of function parameters.
2257 Each parameter gets a definition locating it in the parameter list.
2258 Each parameter that is a register variable gets a second definition
2259 locating it in the register.
2261 Printing or argument lists in gdb uses the definitions that
2262 locate in the parameter list. But reference to the variable in
2263 expressions uses preferentially the definition as a register. */
2265 /* Output definitions, referring to storage in the parmlist,
2266 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2269 dbxout_parms (parms)
2272 for (; parms; parms = TREE_CHAIN (parms))
2273 if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node)
2275 dbxout_prepare_symbol (parms);
2277 /* Perform any necessary register eliminations on the parameter's rtl,
2278 so that the debugging output will be accurate. */
2279 DECL_INCOMING_RTL (parms)
2280 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
2281 DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX);
2282 #ifdef LEAF_REG_REMAP
2283 if (current_function_uses_only_leaf_regs)
2285 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
2286 leaf_renumber_regs_insn (DECL_RTL (parms));
2290 if (PARM_PASSED_IN_MEMORY (parms))
2292 rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
2294 /* ??? Here we assume that the parm address is indexed
2295 off the frame pointer or arg pointer.
2296 If that is not true, we produce meaningless results,
2297 but do not crash. */
2298 if (GET_CODE (addr) == PLUS
2299 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
2300 current_sym_value = INTVAL (XEXP (addr, 1));
2302 current_sym_value = 0;
2304 current_sym_code = N_PSYM;
2305 current_sym_addr = 0;
2308 if (DECL_NAME (parms))
2310 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2312 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2313 IDENTIFIER_POINTER (DECL_NAME (parms)),
2314 DBX_MEMPARM_STABS_LETTER);
2318 current_sym_nchars = 8;
2319 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2320 DBX_MEMPARM_STABS_LETTER);
2323 /* It is quite tempting to use:
2325 dbxout_type (TREE_TYPE (parms), 0, 0);
2327 as the next statement, rather than using DECL_ARG_TYPE(), so
2328 that gcc reports the actual type of the parameter, rather
2329 than the promoted type. This certainly makes GDB's life
2330 easier, at least for some ports. The change is a bad idea
2331 however, since GDB expects to be able access the type without
2332 performing any conversions. So for example, if we were
2333 passing a float to an unprototyped function, gcc will store a
2334 double on the stack, but if we emit a stab saying the type is a
2335 float, then gdb will only read in a single value, and this will
2336 produce an erropneous value. */
2337 dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
2338 current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
2339 dbxout_finish_symbol (parms);
2341 else if (GET_CODE (DECL_RTL (parms)) == REG)
2344 char regparm_letter;
2346 /* Parm passed in registers and lives in registers or nowhere. */
2348 current_sym_code = DBX_REGPARM_STABS_CODE;
2349 regparm_letter = DBX_REGPARM_STABS_LETTER;
2350 current_sym_addr = 0;
2352 /* If parm lives in a register, use that register;
2353 pretend the parm was passed there. It would be more consistent
2354 to describe the register where the parm was passed,
2355 but in practice that register usually holds something else.
2357 If we use DECL_RTL, then we must use the declared type of
2358 the variable, not the type that it arrived in. */
2359 if (REGNO (DECL_RTL (parms)) >= 0
2360 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2362 best_rtl = DECL_RTL (parms);
2363 parm_type = TREE_TYPE (parms);
2365 /* If the parm lives nowhere, use the register where it was
2366 passed. It is also better to use the declared type here. */
2369 best_rtl = DECL_INCOMING_RTL (parms);
2370 parm_type = TREE_TYPE (parms);
2372 current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
2375 if (DECL_NAME (parms))
2377 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2378 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2379 IDENTIFIER_POINTER (DECL_NAME (parms)),
2384 current_sym_nchars = 8;
2385 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2389 dbxout_type (parm_type, 0, 0);
2390 dbxout_finish_symbol (parms);
2392 else if (GET_CODE (DECL_RTL (parms)) == MEM
2393 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2394 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
2395 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
2396 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2397 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
2401 /* Parm was passed via invisible reference.
2402 That is, its address was passed in a register.
2403 Output it as if it lived in that register.
2404 The debugger will know from the type
2405 that it was actually passed by invisible reference. */
2407 char regparm_letter;
2408 /* Parm passed in registers and lives in registers or nowhere. */
2410 current_sym_code = DBX_REGPARM_STABS_CODE;
2411 if (use_gnu_debug_info_extensions)
2412 regparm_letter = GDB_INV_REF_REGPARM_STABS_LETTER;
2414 regparm_letter = DBX_REGPARM_STABS_LETTER;
2416 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2417 If it is an unallocated pseudo-reg, then use the register where
2418 it was passed instead. */
2419 if (REGNO (XEXP (DECL_RTL (parms), 0)) >= 0
2420 && REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
2421 current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2423 current_sym_value = REGNO (DECL_INCOMING_RTL (parms));
2425 current_sym_addr = 0;
2428 if (DECL_NAME (parms))
2430 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2432 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2433 IDENTIFIER_POINTER (DECL_NAME (parms)),
2438 current_sym_nchars = 8;
2439 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2443 dbxout_type (TREE_TYPE (parms), 0, 0);
2444 dbxout_finish_symbol (parms);
2446 else if (GET_CODE (DECL_RTL (parms)) == MEM
2447 && XEXP (DECL_RTL (parms), 0) != const0_rtx
2448 /* ??? A constant address for a parm can happen
2449 when the reg it lives in is equiv to a constant in memory.
2450 Should make this not happen, after 2.4. */
2451 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
2453 /* Parm was passed in registers but lives on the stack. */
2454 int aux_sym_value = 0;
2456 current_sym_code = N_PSYM;
2457 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2458 in which case we want the value of that CONST_INT,
2459 or (MEM (REG ...)) or (MEM (MEM ...)),
2460 in which case we use a value of zero. */
2461 if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG)
2462 current_sym_value = 0;
2463 else if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
2465 /* Remember the location on the stack the parm is moved to */
2467 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
2468 current_sym_value = 0;
2472 = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
2474 current_sym_addr = 0;
2476 /* Make a big endian correction if the mode of the type of the
2477 parameter is not the same as the mode of the rtl. */
2478 if (BYTES_BIG_ENDIAN
2479 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
2480 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
2482 current_sym_value += UNITS_PER_WORD - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms)));
2486 if (DECL_NAME (parms))
2489 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2491 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2492 IDENTIFIER_POINTER (DECL_NAME (parms)),
2493 DBX_MEMPARM_STABS_LETTER);
2497 current_sym_nchars = 8;
2498 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2499 DBX_MEMPARM_STABS_LETTER);
2503 = DEBUGGER_ARG_OFFSET (current_sym_value,
2504 XEXP (DECL_RTL (parms), 0));
2505 dbxout_type (TREE_TYPE (parms), 0, 0);
2506 dbxout_finish_symbol (parms);
2507 if (aux_sym_value != 0)
2509 /* Generate an entry for the stack location */
2511 fprintf (asmfile, "%s \"%s:", ASM_STABS_OP,
2512 IDENTIFIER_POINTER (DECL_NAME (parms)));
2513 current_sym_value = aux_sym_value;
2514 current_sym_code = N_LSYM;
2515 dbxout_type (build_reference_type (TREE_TYPE (parms)), 0, 0);
2516 dbxout_finish_symbol (parms);
2522 /* Output definitions for the places where parms live during the function,
2523 when different from where they were passed, when the parms were passed
2526 It is not useful to do this for parms passed in registers
2527 that live during the function in different registers, because it is
2528 impossible to look in the passed register for the passed value,
2529 so we use the within-the-function register to begin with.
2531 PARMS is a chain of PARM_DECL nodes. */
2534 dbxout_reg_parms (parms)
2537 for (; parms; parms = TREE_CHAIN (parms))
2538 if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
2540 dbxout_prepare_symbol (parms);
2542 /* Report parms that live in registers during the function
2543 but were passed in memory. */
2544 if (GET_CODE (DECL_RTL (parms)) == REG
2545 && REGNO (DECL_RTL (parms)) >= 0
2546 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2547 dbxout_symbol_location (parms, TREE_TYPE (parms),
2548 0, DECL_RTL (parms));
2549 else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
2550 dbxout_symbol_location (parms, TREE_TYPE (parms),
2551 0, DECL_RTL (parms));
2552 /* Report parms that live in memory but not where they were passed. */
2553 else if (GET_CODE (DECL_RTL (parms)) == MEM
2554 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
2555 dbxout_symbol_location (parms, TREE_TYPE (parms),
2556 0, DECL_RTL (parms));
2560 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2561 output definitions of those names, in raw form */
2569 putc (',', asmfile);
2570 dbxout_type (TREE_VALUE (args), 0, 0);
2572 args = TREE_CHAIN (args);
2576 /* Given a chain of ..._TYPE nodes,
2577 find those which have typedef names and output those names.
2578 This is to ensure those types get output. */
2581 dbxout_types (types)
2582 register tree types;
2586 if (TYPE_NAME (types)
2587 && TREE_CODE (TYPE_NAME (types)) == TYPE_DECL
2588 && ! TREE_ASM_WRITTEN (TYPE_NAME (types)))
2589 dbxout_symbol (TYPE_NAME (types), 1);
2590 types = TREE_CHAIN (types);
2594 /* Output everything about a symbol block (a BLOCK node
2595 that represents a scope level),
2596 including recursive output of contained blocks.
2598 BLOCK is the BLOCK node.
2599 DEPTH is its depth within containing symbol blocks.
2600 ARGS is usually zero; but for the outermost block of the
2601 body of a function, it is a chain of PARM_DECLs for the function parameters.
2602 We output definitions of all the register parms
2603 as if they were local variables of that block.
2605 If -g1 was used, we count blocks just the same, but output nothing
2606 except for the outermost block.
2608 Actually, BLOCK may be several blocks chained together.
2609 We handle them all in sequence. */
2612 dbxout_block (block, depth, args)
2613 register tree block;
2621 /* Ignore blocks never expanded or otherwise marked as real. */
2622 if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
2624 #ifndef DBX_LBRAC_FIRST
2625 /* In dbx format, the syms of a block come before the N_LBRAC. */
2626 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2627 dbxout_syms (BLOCK_VARS (block));
2629 dbxout_reg_parms (args);
2632 /* Now output an N_LBRAC symbol to represent the beginning of
2633 the block. Use the block's tree-walk order to generate
2634 the assembler symbols LBBn and LBEn
2635 that final will define around the code in this block. */
2636 if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE)
2639 blocknum = BLOCK_NUMBER (block);
2640 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
2642 if (BLOCK_HANDLER_BLOCK (block))
2644 /* A catch block. Must precede N_LBRAC. */
2645 tree decl = BLOCK_VARS (block);
2648 #ifdef DBX_OUTPUT_CATCH
2649 DBX_OUTPUT_CATCH (asmfile, decl, buf);
2651 fprintf (asmfile, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP,
2652 IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
2653 assemble_name (asmfile, buf);
2654 fprintf (asmfile, "\n");
2656 decl = TREE_CHAIN (decl);
2660 #ifdef DBX_OUTPUT_LBRAC
2661 DBX_OUTPUT_LBRAC (asmfile, buf);
2663 fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_LBRAC);
2664 assemble_name (asmfile, buf);
2665 #if DBX_BLOCKS_FUNCTION_RELATIVE
2666 fputc ('-', asmfile);
2667 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
2669 fprintf (asmfile, "\n");
2673 #ifdef DBX_LBRAC_FIRST
2674 /* On some weird machines, the syms of a block
2675 come after the N_LBRAC. */
2676 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2677 dbxout_syms (BLOCK_VARS (block));
2679 dbxout_reg_parms (args);
2682 /* Output the subblocks. */
2683 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
2685 /* Refer to the marker for the end of the block. */
2686 if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE)
2689 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
2690 #ifdef DBX_OUTPUT_RBRAC
2691 DBX_OUTPUT_RBRAC (asmfile, buf);
2693 fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_RBRAC);
2694 assemble_name (asmfile, buf);
2695 #if DBX_BLOCKS_FUNCTION_RELATIVE
2696 fputc ('-', asmfile);
2697 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
2699 fprintf (asmfile, "\n");
2703 block = BLOCK_CHAIN (block);
2707 /* Output the information about a function and its arguments and result.
2708 Usually this follows the function's code,
2709 but on some systems, it comes before. */
2712 dbxout_really_begin_function (decl)
2715 dbxout_symbol (decl, 0);
2716 dbxout_parms (DECL_ARGUMENTS (decl));
2717 if (DECL_NAME (DECL_RESULT (decl)) != 0)
2718 dbxout_symbol (DECL_RESULT (decl), 1);
2721 /* Called at beginning of output of function definition. */
2724 dbxout_begin_function (decl)
2725 tree decl ATTRIBUTE_UNUSED;
2727 #ifdef DBX_FUNCTION_FIRST
2728 dbxout_really_begin_function (decl);
2732 /* Output dbx data for a function definition.
2733 This includes a definition of the function name itself (a symbol),
2734 definitions of the parameters (locating them in the parameter list)
2735 and then output the block that makes up the function's body
2736 (including all the auto variables of the function). */
2739 dbxout_function (decl)
2742 #ifndef DBX_FUNCTION_FIRST
2743 dbxout_really_begin_function (decl);
2745 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
2746 #ifdef DBX_OUTPUT_FUNCTION_END
2747 DBX_OUTPUT_FUNCTION_END (asmfile, decl);
2749 #if defined(ASM_OUTPUT_SECTION_NAME)
2750 if (use_gnu_debug_info_extensions
2751 #if defined(NO_DBX_FUNCTION_END)
2752 && ! NO_DBX_FUNCTION_END
2755 dbxout_function_end ();
2758 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */