1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987, 88, 92-97, 1998 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
22 /* Output dbx-format symbol table data.
23 This consists of many symbol table entries, each of them
24 a .stabs assembler pseudo-op with four operands:
25 a "name" which is really a description of one symbol and its type,
26 a "code", which is a symbol defined in stab.h whose name starts with N_,
27 an unused operand always 0,
28 and a "value" which is an address or an offset.
29 The name is enclosed in doublequote characters.
31 Each function, variable, typedef, and structure tag
32 has a symbol table entry to define it.
33 The beginning and end of each level of name scoping within
34 a function are also marked by special symbol table entries.
36 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
37 and a data type number. The data type number may be followed by
38 "=" and a type definition; normally this will happen the first time
39 the type number is mentioned. The type definition may refer to
40 other types by number, and those type numbers may be followed
41 by "=" and nested definitions.
43 This can make the "name" quite long.
44 When a name is more than 80 characters, we split the .stabs pseudo-op
45 into two .stabs pseudo-ops, both sharing the same "code" and "value".
46 The first one is marked as continued with a double-backslash at the
49 The kind-of-symbol letter distinguished function names from global
50 variables from file-scope variables from parameters from auto
51 variables in memory from typedef names from register variables.
54 The "code" is mostly redundant with the kind-of-symbol letter
55 that goes in the "name", but not entirely: for symbols located
56 in static storage, the "code" says which segment the address is in,
57 which controls how it is relocated.
59 The "value" for a symbol in static storage
60 is the core address of the symbol (actually, the assembler
61 label for the symbol). For a symbol located in a stack slot
62 it is the stack offset; for one in a register, the register number.
63 For a typedef symbol, it is zero.
65 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
66 output while in the text section.
68 For more on data type definitions, see `dbxout_type'. */
77 #include "insn-config.h"
80 #include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions. */
83 #ifdef XCOFF_DEBUGGING_INFO
88 #define ASM_STABS_OP ".stabs"
92 #define ASM_STABN_OP ".stabn"
95 #ifndef DBX_TYPE_DECL_STABS_CODE
96 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
99 #ifndef DBX_STATIC_CONST_VAR_CODE
100 #define DBX_STATIC_CONST_VAR_CODE N_FUN
103 #ifndef DBX_REGPARM_STABS_CODE
104 #define DBX_REGPARM_STABS_CODE N_RSYM
107 #ifndef DBX_REGPARM_STABS_LETTER
108 #define DBX_REGPARM_STABS_LETTER 'P'
111 /* This is used for parameters passed by invisible reference in a register. */
112 #ifndef GDB_INV_REF_REGPARM_STABS_LETTER
113 #define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
116 #ifndef DBX_MEMPARM_STABS_LETTER
117 #define DBX_MEMPARM_STABS_LETTER 'p'
120 #ifndef FILE_NAME_JOINER
121 #define FILE_NAME_JOINER "/"
124 /* Nonzero means if the type has methods, only output debugging
125 information if methods are actually written to the asm file. This
126 optimization only works if the debugger can detect the special C++
129 #define MINIMAL_DEBUG 1
131 #ifdef NO_DOLLAR_IN_LABEL
132 #ifdef NO_DOT_IN_LABEL
134 #define MINIMAL_DEBUG 0
140 /* Typical USG systems don't have stab.h, and they also have
141 no use for DBX-format debugging info. */
143 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
145 static int flag_minimal_debug = MINIMAL_DEBUG;
147 /* Nonzero if we have actually used any of the GDB extensions
148 to the debugging format. The idea is that we use them for the
149 first time only if there's a strong reason, but once we have done that,
150 we use them whenever convenient. */
152 static int have_used_extensions = 0;
154 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
155 for the N_SO filename stabs label. */
157 static int source_label_number = 1;
159 #ifdef DEBUG_SYMS_TEXT
160 #define FORCE_TEXT text_section ();
165 /* If there is a system stabs.h, use it. Otherwise, use our own. */
172 /* This is a GNU extension we need to reference in this file. */
179 #define STAB_CODE_TYPE enum __stab_debug_code
181 #define STAB_CODE_TYPE int
184 /* 1 if PARM is passed to this function in memory. */
186 #define PARM_PASSED_IN_MEMORY(PARM) \
187 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
189 /* A C expression for the integer offset value of an automatic variable
190 (N_LSYM) having address X (an RTX). */
191 #ifndef DEBUGGER_AUTO_OFFSET
192 #define DEBUGGER_AUTO_OFFSET(X) \
193 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
196 /* A C expression for the integer offset value of an argument (N_PSYM)
197 having address X (an RTX). The nominal offset is OFFSET. */
198 #ifndef DEBUGGER_ARG_OFFSET
199 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
202 /* Stream for writing to assembler file. */
204 static FILE *asmfile;
206 /* Last source file name mentioned in a NOTE insn. */
208 static char *lastfile;
210 /* Current working directory. */
214 enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
216 /* Structure recording information about a C data type.
217 The status element says whether we have yet output
218 the definition of the type. TYPE_XREF says we have
219 output it as a cross-reference only.
220 The file_number and type_number elements are used if DBX_USE_BINCL
225 enum typestatus status;
232 /* Vector recording information about C data types.
233 When we first notice a data type (a tree node),
234 we assign it a number using next_type_number.
235 That is its index in this vector. */
237 struct typeinfo *typevec;
239 /* Number of elements of space allocated in `typevec'. */
241 static int typevec_len;
243 /* In dbx output, each type gets a unique number.
244 This is the number for the next type output.
245 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
247 static int next_type_number;
251 /* When using N_BINCL in dbx output, each type number is actually a
252 pair of the file number and the type number within the file.
253 This is a stack of input files. */
257 struct dbx_file *next;
259 int next_type_number;
262 /* This is the top of the stack. */
264 static struct dbx_file *current_file;
266 /* This is the next file number to use. */
268 static int next_file_number;
270 #endif /* DBX_USE_BINCL */
272 /* In dbx output, we must assign symbol-blocks id numbers
273 in the order in which their beginnings are encountered.
274 We output debugging info that refers to the beginning and
275 end of the ranges of code in each block
276 with assembler labels LBBn and LBEn, where n is the block number.
277 The labels are generated in final, which assigns numbers to the
278 blocks in the same way. */
280 static int next_block_number;
282 /* These variables are for dbxout_symbol to communicate to
283 dbxout_finish_symbol.
284 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
285 current_sym_value and current_sym_addr are two ways to address the
286 value to store in the symtab entry.
287 current_sym_addr if nonzero represents the value as an rtx.
288 If that is zero, current_sym_value is used. This is used
289 when the value is an offset (such as for auto variables,
290 register variables and parms). */
292 static STAB_CODE_TYPE current_sym_code;
293 static int current_sym_value;
294 static rtx current_sym_addr;
296 /* Number of chars of symbol-description generated so far for the
297 current symbol. Used by CHARS and CONTIN. */
299 static int current_sym_nchars;
301 /* Report having output N chars of the current symbol-description. */
303 #define CHARS(N) (current_sym_nchars += (N))
305 /* Break the current symbol-description, generating a continuation,
306 if it has become long. */
308 #ifndef DBX_CONTIN_LENGTH
309 #define DBX_CONTIN_LENGTH 80
312 #if DBX_CONTIN_LENGTH > 0
314 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
319 void dbxout_types ();
321 void dbxout_symbol ();
323 #if defined(ASM_OUTPUT_SECTION_NAME)
324 static void dbxout_function_end PROTO((void));
326 static void dbxout_typedefs PROTO((tree));
327 static void dbxout_type_index PROTO((tree));
328 static void dbxout_continue PROTO((void));
329 static void dbxout_type_fields PROTO((tree));
330 static void dbxout_type_method_1 PROTO((tree, char *));
331 static void dbxout_type_methods PROTO((tree));
332 static void dbxout_range_type PROTO((tree));
333 static void dbxout_type PROTO((tree, int, int));
334 static void print_int_cst_octal PROTO((tree));
335 static void print_octal PROTO((unsigned HOST_WIDE_INT, int));
336 static void dbxout_type_name PROTO((tree));
337 static void dbxout_symbol_location PROTO((tree, tree, char *, rtx));
338 static void dbxout_symbol_name PROTO((tree, char *, int));
339 static void dbxout_prepare_symbol PROTO((tree));
340 static void dbxout_finish_symbol PROTO((tree));
341 static void dbxout_block PROTO((tree, int, tree));
342 static void dbxout_really_begin_function PROTO((tree));
344 #if defined(ASM_OUTPUT_SECTION_NAME)
346 dbxout_function_end ()
348 static int scope_labelno = 0;
349 char lscope_label_name[100];
350 /* Convert Ltext into the appropriate format for local labels in case
351 the system doesn't insert underscores in front of user generated
353 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
354 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Lscope", scope_labelno);
357 /* By convention, GCC will mark the end of a function with an N_FUN
358 symbol and an empty string. */
359 fprintf (asmfile, "%s \"\",%d,0,0,", ASM_STABS_OP, N_FUN);
360 assemble_name (asmfile, lscope_label_name);
361 fputc ('-', asmfile);
362 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
363 fprintf (asmfile, "\n");
365 #endif /* ! NO_DBX_FUNCTION_END */
367 /* At the beginning of compilation, start writing the symbol table.
368 Initialize `typevec' and output the standard data types of C. */
371 dbxout_init (asm_file, input_file_name, syms)
373 char *input_file_name;
376 char ltext_label_name[100];
381 typevec = (struct typeinfo *) xmalloc (typevec_len * sizeof typevec[0]);
382 bzero ((char *) typevec, typevec_len * sizeof typevec[0]);
384 /* Convert Ltext into the appropriate format for local labels in case
385 the system doesn't insert underscores in front of user generated
387 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
389 /* Put the current working directory in an N_SO symbol. */
390 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
391 but GDB always does. */
392 if (use_gnu_debug_info_extensions)
395 if (!cwd && (cwd = getpwd ()) && (!*cwd || cwd[strlen (cwd) - 1] != '/'))
397 char *wdslash = xmalloc (strlen (cwd) + sizeof (FILE_NAME_JOINER));
398 sprintf (wdslash, "%s%s", cwd, FILE_NAME_JOINER);
403 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
404 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd);
405 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
406 fprintf (asmfile, "%s ", ASM_STABS_OP);
407 output_quoted_string (asmfile, cwd);
408 fprintf (asmfile, ",%d,0,0,%s\n", N_SO, <ext_label_name[1]);
409 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
413 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
414 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
415 would give us an N_SOL, and we want an N_SO. */
416 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile, input_file_name);
417 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
418 /* We include outputting `Ltext:' here,
419 because that gives you a way to override it. */
420 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
421 fprintf (asmfile, "%s ", ASM_STABS_OP);
422 output_quoted_string (asmfile, input_file_name);
423 fprintf (asmfile, ",%d,0,0,%s\n",
424 N_SO, <ext_label_name[1]);
426 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Ltext", 0);
427 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
429 /* Possibly output something to inform GDB that this compilation was by
430 GCC. It's easier for GDB to parse it when after the N_SO's. This
431 is used in Solaris 2. */
432 #ifdef ASM_IDENTIFY_GCC_AFTER_SOURCE
433 ASM_IDENTIFY_GCC_AFTER_SOURCE (asmfile);
436 lastfile = input_file_name;
438 next_type_number = 1;
439 next_block_number = 2;
442 current_file = (struct dbx_file *) xmalloc (sizeof *current_file);
443 current_file->next = NULL;
444 current_file->file_number = 0;
445 current_file->next_type_number = 1;
446 next_file_number = 1;
449 /* Make sure that types `int' and `char' have numbers 1 and 2.
450 Definitions of other integer types will refer to those numbers.
451 (Actually it should no longer matter what their numbers are.
452 Also, if any types with tags have been defined, dbxout_symbol
453 will output them first, so the numbers won't be 1 and 2. That
454 happens in C++. So it's a good thing it should no longer matter). */
456 #ifdef DBX_OUTPUT_STANDARD_TYPES
457 DBX_OUTPUT_STANDARD_TYPES (syms);
459 dbxout_symbol (TYPE_NAME (integer_type_node), 0);
460 dbxout_symbol (TYPE_NAME (char_type_node), 0);
463 /* Get all permanent types that have typedef names,
464 and output them all, except for those already output. */
466 dbxout_typedefs (syms);
469 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
470 in the reverse order from that which is found in SYMS. */
473 dbxout_typedefs (syms)
478 dbxout_typedefs (TREE_CHAIN (syms));
479 if (TREE_CODE (syms) == TYPE_DECL)
481 tree type = TREE_TYPE (syms);
483 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
484 && TYPE_SIZE (type) != NULL_TREE
485 && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
486 dbxout_symbol (TYPE_NAME (type), 0);
491 /* Change to reading from a new source file. Generate a N_BINCL stab. */
494 dbxout_start_new_source_file (filename)
498 struct dbx_file *n = (struct dbx_file *) xmalloc (sizeof *n);
500 n->next = current_file;
501 n->file_number = next_file_number++;
502 n->next_type_number = 1;
504 fprintf (asmfile, "%s ", ASM_STABS_OP);
505 output_quoted_string (asmfile, filename);
506 fprintf (asmfile, ",%d,0,0,0\n", N_BINCL);
510 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
513 dbxout_resume_previous_source_file ()
516 struct dbx_file *next;
518 fprintf (asmfile, "%s %d,0,0,0\n", ASM_STABN_OP, N_EINCL);
519 next = current_file->next;
525 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
528 dbxout_source_file (file, filename)
532 char ltext_label_name[100];
534 if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
536 #ifdef DBX_OUTPUT_SOURCE_FILENAME
537 DBX_OUTPUT_SOURCE_FILENAME (file, filename);
539 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext",
540 source_label_number);
541 fprintf (file, "%s ", ASM_STABS_OP);
542 output_quoted_string (file, filename);
543 fprintf (file, ",%d,0,0,%s\n", N_SOL, <ext_label_name[1]);
544 if (current_function_decl != NULL_TREE
545 && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
546 ; /* Don't change section amid function. */
549 ASM_OUTPUT_INTERNAL_LABEL (file, "Ltext", source_label_number);
550 source_label_number++;
556 /* Output a line number symbol entry into output stream FILE,
557 for source file FILENAME and line number LINENO. */
560 dbxout_source_line (file, filename, lineno)
565 dbxout_source_file (file, filename);
567 #ifdef ASM_OUTPUT_SOURCE_LINE
568 ASM_OUTPUT_SOURCE_LINE (file, lineno);
570 fprintf (file, "\t%s %d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno);
574 /* At the end of compilation, finish writing the symbol table.
575 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
579 dbxout_finish (file, filename)
583 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
584 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file, filename);
585 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
588 /* Output the index of a type. */
591 dbxout_type_index (type)
594 #ifndef DBX_USE_BINCL
595 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
598 struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
599 fprintf (asmfile, "(%d,%d)", t->file_number, t->type_number);
604 /* Continue a symbol-description that gets too big.
605 End one symbol table entry with a double-backslash
606 and start a new one, eventually producing something like
607 .stabs "start......\\",code,0,value
608 .stabs "...rest",code,0,value */
613 #ifdef DBX_CONTIN_CHAR
614 fprintf (asmfile, "%c", DBX_CONTIN_CHAR);
616 fprintf (asmfile, "\\\\");
618 dbxout_finish_symbol (NULL_TREE);
619 fprintf (asmfile, "%s \"", ASM_STABS_OP);
620 current_sym_nchars = 0;
623 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
624 This must be a separate function because anonymous unions require
628 dbxout_type_fields (type)
632 /* Output the name, type, position (in bits), size (in bits) of each
634 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
636 /* Omit here local type decls until we know how to support them. */
637 if (TREE_CODE (tem) == TYPE_DECL)
639 /* Omit fields whose position or size are variable. */
640 else if (TREE_CODE (tem) == FIELD_DECL
641 && (TREE_CODE (DECL_FIELD_BITPOS (tem)) != INTEGER_CST
642 || TREE_CODE (DECL_SIZE (tem)) != INTEGER_CST))
644 /* Omit here the nameless fields that are used to skip bits. */
645 else if (DECL_IGNORED_P (tem))
647 else if (TREE_CODE (tem) != CONST_DECL)
649 /* Continue the line if necessary,
650 but not before the first field. */
651 if (tem != TYPE_FIELDS (type))
656 if (use_gnu_debug_info_extensions
657 && flag_minimal_debug
658 && TREE_CODE (tem) == FIELD_DECL
659 && DECL_VIRTUAL_P (tem)
660 && DECL_ASSEMBLER_NAME (tem))
662 have_used_extensions = 1;
663 CHARS (3 + IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (tem)));
664 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem)), asmfile);
665 dbxout_type (DECL_FCONTEXT (tem), 0, 0);
666 fprintf (asmfile, ":");
667 dbxout_type (TREE_TYPE (tem), 0, 0);
668 fputc (',', asmfile);
669 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
670 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)));
671 fputc (';', asmfile);
677 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
678 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem)));
682 fprintf (asmfile, ":");
686 if (use_gnu_debug_info_extensions
687 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
688 || TREE_CODE (tem) != FIELD_DECL))
690 have_used_extensions = 1;
692 putc ((TREE_PRIVATE (tem) ? '0'
693 : TREE_PROTECTED (tem) ? '1' : '2'),
698 dbxout_type ((TREE_CODE (tem) == FIELD_DECL
699 && DECL_BIT_FIELD_TYPE (tem))
700 ? DECL_BIT_FIELD_TYPE (tem)
701 : TREE_TYPE (tem), 0, 0);
703 if (TREE_CODE (tem) == VAR_DECL)
705 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
707 char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem));
708 have_used_extensions = 1;
709 fprintf (asmfile, ":%s;", name);
710 CHARS (strlen (name));
714 /* If TEM is non-static, GDB won't understand it. */
715 fprintf (asmfile, ",0,0;");
718 else if (TREE_CODE (DECL_FIELD_BITPOS (tem)) == INTEGER_CST)
720 fputc (',', asmfile);
721 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
722 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)));
723 fputc (',', asmfile);
724 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
725 TREE_INT_CST_LOW (DECL_SIZE (tem)));
726 fputc (';', asmfile);
733 /* Subroutine of `dbxout_type_methods'. Output debug info about the
734 method described DECL. DEBUG_NAME is an encoding of the method's
735 type signature. ??? We may be able to do without DEBUG_NAME altogether
739 dbxout_type_method_1 (decl, debug_name)
745 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
747 else /* it's a METHOD_TYPE. */
749 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
750 /* A for normal functions.
751 B for `const' member functions.
752 C for `volatile' member functions.
753 D for `const volatile' member functions. */
754 if (TYPE_READONLY (TREE_TYPE (firstarg)))
756 if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
759 if (DECL_VINDEX (decl))
765 fprintf (asmfile, ":%s;%c%c%c", debug_name,
766 TREE_PRIVATE (decl) ? '0' : TREE_PROTECTED (decl) ? '1' : '2', c1, c2);
767 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)) + 6
768 - (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
769 if (DECL_VINDEX (decl))
771 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
772 TREE_INT_CST_LOW (DECL_VINDEX (decl)));
773 fputc (';', asmfile);
774 dbxout_type (DECL_CONTEXT (decl), 0, 0);
775 fprintf (asmfile, ";");
780 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
784 dbxout_type_methods (type)
787 /* C++: put out the method names and their parameter lists */
788 tree methods = TYPE_METHODS (type);
790 register tree fndecl;
792 char formatted_type_identifier_length[16];
793 register int type_identifier_length;
795 if (methods == NULL_TREE)
798 type_encoding = DECL_NAME (TYPE_NAME (type));
801 /* C++: Template classes break some assumptions made by this code about
802 the class names, constructor names, and encodings for assembler
803 label names. For now, disable output of dbx info for them. */
805 char *ptr = IDENTIFIER_POINTER (type_encoding);
806 /* This should use index. (mrs) */
807 while (*ptr && *ptr != '<') ptr++;
814 #ifdef HAVE_TEMPLATES
815 if (warn_template_debugging)
816 warning ("dbx info for template class methods not yet supported");
824 type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
826 sprintf(formatted_type_identifier_length, "%d", type_identifier_length);
828 if (TREE_CODE (methods) != TREE_VEC)
830 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
831 fndecl = TREE_VEC_ELT (methods, 0);
833 fndecl = TREE_VEC_ELT (methods, 1);
837 tree name = DECL_NAME (fndecl);
840 /* Group together all the methods for the same operation.
841 These differ in the types of the arguments. */
842 for (last = NULL_TREE;
843 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
844 fndecl = TREE_CHAIN (fndecl))
845 /* Output the name of the field (after overloading), as
846 well as the name of the field before overloading, along
847 with its parameter list */
849 /* This is the "mangled" name of the method.
850 It encodes the argument types. */
851 char *debug_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
852 int show_arg_types = 0;
858 if (DECL_IGNORED_P (fndecl))
861 if (flag_minimal_debug)
865 /* We can't optimize a method which uses an anonymous
866 class, because the debugger will not be able to
867 associate the arbitrary class name with the actual
869 #ifndef NO_DOLLAR_IN_LABEL
874 if (strchr (debug_name, marker))
876 /* Detect ordinary methods because their mangled names
877 start with the operation name. */
878 else if (!strncmp (IDENTIFIER_POINTER (name), debug_name,
879 IDENTIFIER_LENGTH (name)))
881 debug_name += IDENTIFIER_LENGTH (name);
882 if (debug_name[0] == '_' && debug_name[1] == '_')
884 char *method_name = debug_name + 2;
885 char *length_ptr = formatted_type_identifier_length;
886 /* Get past const and volatile qualifiers. */
887 while (*method_name == 'C' || *method_name == 'V')
889 /* Skip digits for length of type_encoding. */
890 while (*method_name == *length_ptr && *length_ptr)
891 length_ptr++, method_name++;
892 if (! strncmp (method_name,
893 IDENTIFIER_POINTER (type_encoding),
894 type_identifier_length))
895 method_name += type_identifier_length;
896 debug_name = method_name;
899 /* Detect constructors by their style of name mangling. */
900 else if (debug_name[0] == '_' && debug_name[1] == '_')
902 char *ctor_name = debug_name + 2;
903 char *length_ptr = formatted_type_identifier_length;
904 while (*ctor_name == 'C' || *ctor_name == 'V')
906 /* Skip digits for length of type_encoding. */
907 while (*ctor_name == *length_ptr && *length_ptr)
908 length_ptr++, ctor_name++;
909 if (!strncmp (IDENTIFIER_POINTER (type_encoding), ctor_name,
910 type_identifier_length))
911 debug_name = ctor_name + type_identifier_length;
913 /* The other alternative is a destructor. */
917 /* Output the operation name just once, for the first method
921 fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
922 CHARS (IDENTIFIER_LENGTH (name) + 2);
927 dbxout_type (TREE_TYPE (fndecl), 0, show_arg_types);
929 dbxout_type_method_1 (fndecl, debug_name);
939 /* Emit a "range" type specification, which has the form:
940 "r<index type>;<lower bound>;<upper bound>;".
941 TYPE is an INTEGER_TYPE. */
944 dbxout_range_type (type)
947 fprintf (asmfile, "r");
948 if (TREE_TYPE (type))
949 dbxout_type (TREE_TYPE (type), 0, 0);
950 else if (TREE_CODE (type) != INTEGER_TYPE)
951 dbxout_type (type, 0, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
954 /* Traditionally, we made sure 'int' was type 1, and builtin types
955 were defined to be sub-ranges of int. Unfortunately, this
956 does not allow us to distinguish true sub-ranges from integer
957 types. So, instead we define integer (non-sub-range) types as
958 sub-ranges of themselves. */
959 dbxout_type_index (type);
961 if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
963 fputc (';', asmfile);
964 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
965 TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)));
968 fprintf (asmfile, ";0");
969 if (TYPE_MAX_VALUE (type)
970 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
972 fputc (';', asmfile);
973 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
974 TREE_INT_CST_LOW (TYPE_MAX_VALUE (type)));
975 fputc (';', asmfile);
978 fprintf (asmfile, ";-1;");
981 /* Output a reference to a type. If the type has not yet been
982 described in the dbx output, output its definition now.
983 For a type already defined, just refer to its definition
984 using the type number.
986 If FULL is nonzero, and the type has been described only with
987 a forward-reference, output the definition now.
988 If FULL is zero in this case, just refer to the forward-reference
989 using the number previously allocated.
991 If SHOW_ARG_TYPES is nonzero, we output a description of the argument
992 types for a METHOD_TYPE. */
995 dbxout_type (type, full, show_arg_types)
1001 static int anonymous_type_number = 0;
1003 /* If there was an input error and we don't really have a type,
1004 avoid crashing and write something that is at least valid
1005 by assuming `int'. */
1006 if (type == error_mark_node)
1007 type = integer_type_node;
1010 /* Try to find the "main variant" with the same name but not const
1011 or volatile. (Since stabs does not distinguish const and volatile,
1012 there is no need to make them separate types. But types with
1013 different names are usefully distinguished.) */
1015 for (tem = TYPE_MAIN_VARIANT (type); tem; tem = TYPE_NEXT_VARIANT (tem))
1016 if (!TYPE_READONLY (tem) && !TYPE_VOLATILE (tem)
1017 && TYPE_NAME (tem) == TYPE_NAME (type))
1022 if (TYPE_NAME (type)
1023 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1024 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
1028 if (TYPE_SYMTAB_ADDRESS (type) == 0)
1030 /* Type has no dbx number assigned. Assign next available number. */
1031 TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
1033 /* Make sure type vector is long enough to record about this type. */
1035 if (next_type_number == typevec_len)
1038 = (struct typeinfo *) xrealloc (typevec,
1039 typevec_len * 2 * sizeof typevec[0]);
1040 bzero ((char *) (typevec + typevec_len),
1041 typevec_len * sizeof typevec[0]);
1045 #ifdef DBX_USE_BINCL
1046 typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
1047 = current_file->file_number;
1048 typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
1049 = current_file->next_type_number++;
1053 /* Output the number of this type, to refer to it. */
1054 dbxout_type_index (type);
1056 #ifdef DBX_TYPE_DEFINED
1057 if (DBX_TYPE_DEFINED (type))
1061 /* If this type's definition has been output or is now being output,
1064 switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
1069 /* If we have already had a cross reference,
1070 and either that's all we want or that's the best we could do,
1071 don't repeat the cross reference.
1072 Sun dbx crashes if we do. */
1073 if (! full || TYPE_SIZE (type) == 0
1074 /* No way in DBX fmt to describe a variable size. */
1075 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1083 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1084 leave the type-number completely undefined rather than output
1085 a cross-reference. If we have already used GNU debug info extensions,
1086 then it is OK to output a cross reference. This is necessary to get
1087 proper C++ debug output. */
1088 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
1089 || TREE_CODE (type) == QUAL_UNION_TYPE
1090 || TREE_CODE (type) == ENUMERAL_TYPE)
1091 && ! use_gnu_debug_info_extensions)
1092 /* We must use the same test here as we use twice below when deciding
1093 whether to emit a cross-reference. */
1094 if ((TYPE_NAME (type) != 0
1095 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1096 && DECL_IGNORED_P (TYPE_NAME (type)))
1098 || TYPE_SIZE (type) == 0
1099 /* No way in DBX fmt to describe a variable size. */
1100 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1102 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1107 /* Output a definition now. */
1109 fprintf (asmfile, "=");
1112 /* Mark it as defined, so that if it is self-referent
1113 we will not get into an infinite recursion of definitions. */
1115 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
1117 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1118 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1120 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0, 0);
1124 switch (TREE_CODE (type))
1128 /* For a void type, just define it as itself; ie, "5=5".
1129 This makes us consider it defined
1130 without saying what it is. The debugger will make it
1131 a void type when the reference is seen, and nothing will
1132 ever override that default. */
1133 dbxout_type_index (type);
1137 if (type == char_type_node && ! TREE_UNSIGNED (type))
1139 /* Output the type `char' as a subrange of itself!
1140 I don't understand this definition, just copied it
1141 from the output of pcc.
1142 This used to use `r2' explicitly and we used to
1143 take care to make sure that `char' was type number 2. */
1144 fprintf (asmfile, "r");
1145 dbxout_type_index (type);
1146 fprintf (asmfile, ";0;127;");
1148 /* This used to check if the type's precision was more than
1149 HOST_BITS_PER_WIDE_INT. That is wrong since gdb uses a
1150 long (it has no concept of HOST_BITS_PER_WIDE_INT). */
1151 else if (use_gnu_debug_info_extensions
1152 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
1153 || TYPE_PRECISION (type) >= HOST_BITS_PER_LONG))
1155 /* This used to say `r1' and we used to take care
1156 to make sure that `int' was type number 1. */
1157 fprintf (asmfile, "r");
1158 dbxout_type_index (integer_type_node);
1159 fprintf (asmfile, ";");
1160 print_int_cst_octal (TYPE_MIN_VALUE (type));
1161 fprintf (asmfile, ";");
1162 print_int_cst_octal (TYPE_MAX_VALUE (type));
1163 fprintf (asmfile, ";");
1165 else /* Output other integer types as subranges of `int'. */
1166 dbxout_range_type (type);
1171 /* This used to say `r1' and we used to take care
1172 to make sure that `int' was type number 1. */
1173 fprintf (asmfile, "r");
1174 dbxout_type_index (integer_type_node);
1175 fputc (';', asmfile);
1176 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, int_size_in_bytes (type));
1177 fputs (";0;", asmfile);
1182 if (use_gnu_debug_info_extensions)
1184 fputs ("@s", asmfile);
1185 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1186 BITS_PER_UNIT * int_size_in_bytes (type));
1187 fputs (";-20;", asmfile);
1191 /* Output the type `char' as a subrange of itself.
1192 That is what pcc seems to do. */
1193 fprintf (asmfile, "r");
1194 dbxout_type_index (char_type_node);
1195 fprintf (asmfile, ";0;%d;", TREE_UNSIGNED (type) ? 255 : 127);
1201 if (use_gnu_debug_info_extensions)
1203 fputs ("@s", asmfile);
1204 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1205 BITS_PER_UNIT * int_size_in_bytes (type));
1206 fputs (";-16;", asmfile);
1208 else /* Define as enumeral type (False, True) */
1209 fprintf (asmfile, "eFalse:0,True:1,;");
1214 putc ('d', asmfile);
1216 dbxout_type (TREE_TYPE (type), 0, 0);
1220 /* Differs from the REAL_TYPE by its new data type number */
1222 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1224 fprintf (asmfile, "r");
1225 dbxout_type_index (type);
1226 fputc (';', asmfile);
1227 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1228 int_size_in_bytes (TREE_TYPE (type)));
1229 fputs (";0;", asmfile);
1230 CHARS (12); /* The number is probably incorrect here. */
1234 /* Output a complex integer type as a structure,
1235 pending some other way to do it. */
1236 fputc ('s', asmfile);
1237 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, int_size_in_bytes (type));
1239 fprintf (asmfile, "real:");
1241 dbxout_type (TREE_TYPE (type), 0, 0);
1242 fprintf (asmfile, ",%d,%d;",
1243 0, TYPE_PRECISION (TREE_TYPE (type)));
1245 fprintf (asmfile, "imag:");
1247 dbxout_type (TREE_TYPE (type), 0, 0);
1248 fprintf (asmfile, ",%d,%d;;",
1249 TYPE_PRECISION (TREE_TYPE (type)),
1250 TYPE_PRECISION (TREE_TYPE (type)));
1256 if (use_gnu_debug_info_extensions)
1258 have_used_extensions = 1;
1259 fputs ("@s", asmfile);
1260 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1261 BITS_PER_UNIT * int_size_in_bytes (type));
1262 fputc (';', asmfile);
1263 /* Check if a bitstring type, which in Chill is
1264 different from a [power]set. */
1265 if (TYPE_STRING_FLAG (type))
1266 fprintf (asmfile, "@S;");
1268 putc ('S', asmfile);
1270 dbxout_type (TYPE_DOMAIN (type), 0, 0);
1274 /* Output "a" followed by a range type definition
1275 for the index type of the array
1276 followed by a reference to the target-type.
1277 ar1;0;N;M for a C array of type M and size N+1. */
1278 /* Check if a character string type, which in Chill is
1279 different from an array of characters. */
1280 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
1282 have_used_extensions = 1;
1283 fprintf (asmfile, "@S;");
1285 tem = TYPE_DOMAIN (type);
1288 fprintf (asmfile, "ar");
1289 dbxout_type_index (integer_type_node);
1290 fprintf (asmfile, ";0;-1;");
1294 fprintf (asmfile, "a");
1295 dbxout_range_type (tem);
1298 dbxout_type (TREE_TYPE (type), 0, 0);
1303 case QUAL_UNION_TYPE:
1305 int i, n_baseclasses = 0;
1307 if (TYPE_BINFO (type) != 0
1308 && TREE_CODE (TYPE_BINFO (type)) == TREE_VEC
1309 && TYPE_BINFO_BASETYPES (type) != 0)
1310 n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
1312 /* Output a structure type. We must use the same test here as we
1313 use in the DBX_NO_XREFS case above. */
1314 if ((TYPE_NAME (type) != 0
1315 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1316 && DECL_IGNORED_P (TYPE_NAME (type)))
1318 || TYPE_SIZE (type) == 0
1319 /* No way in DBX fmt to describe a variable size. */
1320 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1322 /* If the type is just a cross reference, output one
1323 and mark the type as partially described.
1324 If it later becomes defined, we will output
1325 its real definition.
1326 If the type has a name, don't nest its definition within
1327 another type's definition; instead, output an xref
1328 and let the definition come when the name is defined. */
1329 fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
1331 #if 0 /* This assertion is legitimately false in C++. */
1332 /* We shouldn't be outputting a reference to a type before its
1333 definition unless the type has a tag name.
1334 A typedef name without a tag name should be impossible. */
1335 if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
1338 if (TYPE_NAME (type) != 0)
1339 dbxout_type_name (type);
1341 fprintf (asmfile, "$$%d", anonymous_type_number++);
1342 fprintf (asmfile, ":");
1343 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1347 /* Identify record or union, and print its size. */
1348 fputc (((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'), asmfile);
1349 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1350 int_size_in_bytes (type));
1352 if (use_gnu_debug_info_extensions)
1356 have_used_extensions = 1;
1357 fprintf (asmfile, "!%d,", n_baseclasses);
1361 for (i = 0; i < n_baseclasses; i++)
1363 tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i);
1364 if (use_gnu_debug_info_extensions)
1366 have_used_extensions = 1;
1367 putc (TREE_VIA_VIRTUAL (child) ? '1'
1370 putc (TREE_VIA_PUBLIC (child) ? '2'
1373 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1374 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT);
1375 fputc (',', asmfile);
1377 dbxout_type (BINFO_TYPE (child), 0, 0);
1378 putc (';', asmfile);
1382 /* Print out the base class information with fields
1383 which have the same names at the types they hold. */
1384 dbxout_type_name (BINFO_TYPE (child));
1385 putc (':', asmfile);
1386 dbxout_type (BINFO_TYPE (child), full, 0);
1387 fputc (',', asmfile);
1388 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1389 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT);
1390 fputc (',', asmfile);
1391 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1392 TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child)))) * BITS_PER_UNIT);
1393 fputc (';', asmfile);
1401 /* Write out the field declarations. */
1402 dbxout_type_fields (type);
1403 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
1405 have_used_extensions = 1;
1406 dbxout_type_methods (type);
1408 putc (';', asmfile);
1410 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
1411 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1412 && TYPE_VFIELD (type))
1414 have_used_extensions = 1;
1416 /* Tell GDB+ that it may keep reading. */
1417 putc ('~', asmfile);
1419 /* We need to write out info about what field this class
1420 uses as its "main" vtable pointer field, because if this
1421 field is inherited from a base class, GDB cannot necessarily
1422 figure out which field it's using in time. */
1423 if (TYPE_VFIELD (type))
1425 putc ('%', asmfile);
1426 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0, 0);
1428 putc (';', asmfile);
1434 /* We must use the same test here as we use in the DBX_NO_XREFS case
1435 above. We simplify it a bit since an enum will never have a variable
1437 if ((TYPE_NAME (type) != 0
1438 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1439 && DECL_IGNORED_P (TYPE_NAME (type)))
1441 || TYPE_SIZE (type) == 0)
1443 fprintf (asmfile, "xe");
1445 dbxout_type_name (type);
1446 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1447 fprintf (asmfile, ":");
1450 #ifdef DBX_OUTPUT_ENUM
1451 DBX_OUTPUT_ENUM (asmfile, type);
1453 if (use_gnu_debug_info_extensions
1454 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1455 fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1456 putc ('e', asmfile);
1458 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
1460 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1461 if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
1462 fprintf (asmfile, HOST_WIDE_INT_PRINT_UNSIGNED,
1463 TREE_INT_CST_LOW (TREE_VALUE (tem)));
1464 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
1465 && TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
1466 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1467 TREE_INT_CST_LOW (TREE_VALUE (tem)));
1469 print_int_cst_octal (TREE_VALUE (tem));
1470 fprintf (asmfile, ",");
1471 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem)));
1472 if (TREE_CHAIN (tem) != 0)
1477 putc (';', asmfile);
1483 putc ('*', asmfile);
1485 dbxout_type (TREE_TYPE (type), 0, 0);
1489 if (use_gnu_debug_info_extensions)
1491 have_used_extensions = 1;
1492 putc ('#', asmfile);
1494 if (flag_minimal_debug && !show_arg_types)
1496 /* Normally, just output the return type.
1497 The argument types are encoded in the method name. */
1498 putc ('#', asmfile);
1500 dbxout_type (TREE_TYPE (type), 0, 0);
1501 putc (';', asmfile);
1506 /* When outputting destructors, we need to write
1507 the argument types out longhand. */
1508 dbxout_type (TYPE_METHOD_BASETYPE (type), 0, 0);
1509 putc (',', asmfile);
1511 dbxout_type (TREE_TYPE (type), 0, 0);
1512 dbxout_args (TYPE_ARG_TYPES (type));
1513 putc (';', asmfile);
1519 /* Treat it as a function type. */
1520 dbxout_type (TREE_TYPE (type), 0, 0);
1525 if (use_gnu_debug_info_extensions)
1527 have_used_extensions = 1;
1528 putc ('@', asmfile);
1530 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0, 0);
1531 putc (',', asmfile);
1533 dbxout_type (TREE_TYPE (type), 0, 0);
1537 /* Should print as an int, because it is really
1539 dbxout_type (integer_type_node, 0, 0);
1543 case REFERENCE_TYPE:
1544 if (use_gnu_debug_info_extensions)
1545 have_used_extensions = 1;
1546 putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
1548 dbxout_type (TREE_TYPE (type), 0, 0);
1552 putc ('f', asmfile);
1554 dbxout_type (TREE_TYPE (type), 0, 0);
1562 /* Print the value of integer constant C, in octal,
1563 handling double precision. */
1566 print_int_cst_octal (c)
1569 unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
1570 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
1571 int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
1572 int width = TYPE_PRECISION (TREE_TYPE (c));
1574 /* GDB wants constants with no extra leading "1" bits, so
1575 we need to remove any sign-extension that might be
1577 if (width == HOST_BITS_PER_WIDE_INT * 2)
1579 else if (width > HOST_BITS_PER_WIDE_INT)
1580 high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
1581 else if (width == HOST_BITS_PER_WIDE_INT)
1584 high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
1586 fprintf (asmfile, "0");
1590 print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
1591 print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
1595 unsigned HOST_WIDE_INT beg = high >> excess;
1596 unsigned HOST_WIDE_INT middle
1597 = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
1598 | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
1599 unsigned HOST_WIDE_INT end
1600 = low & (((unsigned HOST_WIDE_INT) 1
1601 << (HOST_BITS_PER_WIDE_INT / 3 * 3))
1604 fprintf (asmfile, "%o%01o", (int)beg, (int)middle);
1605 print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
1610 print_octal (value, digits)
1611 unsigned HOST_WIDE_INT value;
1616 for (i = digits - 1; i >= 0; i--)
1617 fprintf (asmfile, "%01o", (int)((value >> (3 * i)) & 7));
1620 /* Output the name of type TYPE, with no punctuation.
1621 Such names can be set up either by typedef declarations
1622 or by struct, enum and union tags. */
1625 dbxout_type_name (type)
1629 if (TYPE_NAME (type) == 0)
1631 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
1633 t = TYPE_NAME (type);
1635 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1637 t = DECL_NAME (TYPE_NAME (type));
1642 fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
1643 CHARS (IDENTIFIER_LENGTH (t));
1646 /* Output a .stabs for the symbol defined by DECL,
1647 which must be a ..._DECL node in the normal namespace.
1648 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1649 LOCAL is nonzero if the scope is less than the entire file. */
1652 dbxout_symbol (decl, local)
1656 tree type = TREE_TYPE (decl);
1657 tree context = NULL_TREE;
1659 /* Cast avoids warning in old compilers. */
1660 current_sym_code = (STAB_CODE_TYPE) 0;
1661 current_sym_value = 0;
1662 current_sym_addr = 0;
1664 /* Ignore nameless syms, but don't ignore type tags. */
1666 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
1667 || DECL_IGNORED_P (decl))
1670 dbxout_prepare_symbol (decl);
1672 /* The output will always start with the symbol name,
1673 so always count that in the length-output-so-far. */
1675 if (DECL_NAME (decl) != 0)
1676 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
1678 switch (TREE_CODE (decl))
1681 /* Enum values are defined by defining the enum type. */
1685 if (DECL_RTL (decl) == 0)
1687 if (DECL_EXTERNAL (decl))
1689 /* Don't mention a nested function under its parent. */
1690 context = decl_function_context (decl);
1691 if (context == current_function_decl)
1693 if (GET_CODE (DECL_RTL (decl)) != MEM
1694 || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
1698 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
1699 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1700 TREE_PUBLIC (decl) ? 'F' : 'f');
1702 current_sym_code = N_FUN;
1703 current_sym_addr = XEXP (DECL_RTL (decl), 0);
1705 if (TREE_TYPE (type))
1706 dbxout_type (TREE_TYPE (type), 0, 0);
1708 dbxout_type (void_type_node, 0, 0);
1710 /* For a nested function, when that function is compiled,
1711 mention the containing function name
1712 as well as (since dbx wants it) our own assembler-name. */
1714 fprintf (asmfile, ",%s,%s",
1715 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1716 IDENTIFIER_POINTER (DECL_NAME (context)));
1718 dbxout_finish_symbol (decl);
1723 /* This seems all wrong. Outputting most kinds of types gives no name
1724 at all. A true definition gives no name; a cross-ref for a
1725 structure can give the tag name, but not a type name.
1726 It seems that no typedef name is defined by outputting a type. */
1728 /* If this typedef name was defined by outputting the type,
1729 don't duplicate it. */
1730 if (typevec[TYPE_SYMTAB_ADDRESS (type)].status == TYPE_DEFINED
1731 && TYPE_NAME (TREE_TYPE (decl)) == decl)
1734 /* Don't output the same typedef twice.
1735 And don't output what language-specific stuff doesn't want output. */
1736 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
1745 if (DECL_NAME (decl))
1747 /* Nonzero means we must output a tag as well as a typedef. */
1750 /* Handle the case of a C++ structure or union
1751 where the TYPE_NAME is a TYPE_DECL
1752 which gives both a typedef name and a tag. */
1753 /* dbx requires the tag first and the typedef second. */
1754 if ((TREE_CODE (type) == RECORD_TYPE
1755 || TREE_CODE (type) == UNION_TYPE
1756 || TREE_CODE (type) == QUAL_UNION_TYPE)
1757 && TYPE_NAME (type) == decl
1758 && !(use_gnu_debug_info_extensions && have_used_extensions)
1759 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
1760 /* Distinguish the implicit typedefs of C++
1761 from explicit ones that might be found in C. */
1762 && DECL_ARTIFICIAL (decl))
1764 tree name = TYPE_NAME (type);
1765 if (TREE_CODE (name) == TYPE_DECL)
1766 name = DECL_NAME (name);
1768 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1769 current_sym_value = 0;
1770 current_sym_addr = 0;
1771 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1773 fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP,
1774 IDENTIFIER_POINTER (name));
1775 dbxout_type (type, 1, 0);
1776 dbxout_finish_symbol (NULL_TREE);
1779 /* Output typedef name. */
1780 fprintf (asmfile, "%s \"%s:", ASM_STABS_OP,
1781 IDENTIFIER_POINTER (DECL_NAME (decl)));
1783 /* Short cut way to output a tag also. */
1784 if ((TREE_CODE (type) == RECORD_TYPE
1785 || TREE_CODE (type) == UNION_TYPE
1786 || TREE_CODE (type) == QUAL_UNION_TYPE)
1787 && TYPE_NAME (type) == decl
1788 /* Distinguish the implicit typedefs of C++
1789 from explicit ones that might be found in C. */
1790 && DECL_ARTIFICIAL (decl))
1792 if (use_gnu_debug_info_extensions && have_used_extensions)
1794 putc ('T', asmfile);
1795 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
1797 #if 0 /* Now we generate the tag for this case up above. */
1803 putc ('t', asmfile);
1804 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1806 dbxout_type (type, 1, 0);
1807 dbxout_finish_symbol (decl);
1811 /* Don't output a tag if this is an incomplete type (TYPE_SIZE is
1812 zero). This prevents the sun4 Sun OS 4.x dbx from crashing. */
1814 if (tag_needed && TYPE_NAME (type) != 0
1815 && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
1816 || (DECL_NAME (TYPE_NAME (type)) != 0))
1817 && TYPE_SIZE (type) != 0
1818 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
1820 /* For a TYPE_DECL with no name, but the type has a name,
1822 This is what represents `struct foo' with no typedef. */
1823 /* In C++, the name of a type is the corresponding typedef.
1824 In C, it is an IDENTIFIER_NODE. */
1825 tree name = TYPE_NAME (type);
1826 if (TREE_CODE (name) == TYPE_DECL)
1827 name = DECL_NAME (name);
1829 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1830 current_sym_value = 0;
1831 current_sym_addr = 0;
1832 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1834 fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP,
1835 IDENTIFIER_POINTER (name));
1836 dbxout_type (type, 1, 0);
1837 dbxout_finish_symbol (NULL_TREE);
1841 /* If an enum type has no name, it cannot be referred to,
1842 but we must output it anyway, since the enumeration constants
1843 can be referred to. */
1844 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
1846 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1847 current_sym_value = 0;
1848 current_sym_addr = 0;
1849 current_sym_nchars = 2;
1851 /* Some debuggers fail when given NULL names, so give this a
1852 harmless name of ` '. */
1853 fprintf (asmfile, "%s \" :T", ASM_STABS_OP);
1854 dbxout_type (type, 1, 0);
1855 dbxout_finish_symbol (NULL_TREE);
1858 /* Prevent duplicate output of a typedef. */
1859 TREE_ASM_WRITTEN (decl) = 1;
1864 /* Parm decls go in their own separate chains
1865 and are output by dbxout_reg_parms and dbxout_parms. */
1869 /* Named return value, treat like a VAR_DECL. */
1871 if (DECL_RTL (decl) == 0)
1873 /* Don't mention a variable that is external.
1874 Let the file that defines it describe it. */
1875 if (DECL_EXTERNAL (decl))
1878 /* If the variable is really a constant
1879 and not written in memory, inform the debugger. */
1880 if (TREE_STATIC (decl) && TREE_READONLY (decl)
1881 && DECL_INITIAL (decl) != 0
1882 && ! TREE_ASM_WRITTEN (decl)
1883 && (DECL_FIELD_CONTEXT (decl) == NULL_TREE
1884 || TREE_CODE (DECL_FIELD_CONTEXT (decl)) == BLOCK))
1886 if (TREE_PUBLIC (decl) == 0)
1888 /* The sun4 assembler does not grok this. */
1889 char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1890 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
1891 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
1893 HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl));
1894 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1895 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile, name, ival);
1897 fprintf (asmfile, "%s \"%s:c=i", ASM_STABS_OP, name);
1899 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, ival);
1900 fprintf (asmfile, "\",0x%x,0,0,0\n", N_LSYM);
1904 else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
1906 /* don't know how to do this yet. */
1910 /* else it is something we handle like a normal variable. */
1913 DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, NULL_RTX);
1914 #ifdef LEAF_REG_REMAP
1916 leaf_renumber_regs_insn (DECL_RTL (decl));
1919 dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
1927 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1928 Add SUFFIX to its name, if SUFFIX is not 0.
1929 Describe the variable as residing in HOME
1930 (usually HOME is DECL_RTL (DECL), but not always). */
1933 dbxout_symbol_location (decl, type, suffix, home)
1941 /* Don't mention a variable at all
1942 if it was completely optimized into nothingness.
1944 If the decl was from an inline function, then it's rtl
1945 is not identically the rtl that was used in this
1946 particular compilation. */
1947 if (GET_CODE (home) == REG)
1949 regno = REGNO (home);
1950 if (regno >= FIRST_PSEUDO_REGISTER)
1953 else if (GET_CODE (home) == SUBREG)
1957 while (GET_CODE (value) == SUBREG)
1959 offset += SUBREG_WORD (value);
1960 value = SUBREG_REG (value);
1962 if (GET_CODE (value) == REG)
1964 regno = REGNO (value);
1965 if (regno >= FIRST_PSEUDO_REGISTER)
1969 alter_subreg (home);
1972 /* The kind-of-variable letter depends on where
1973 the variable is and on the scope of its name:
1974 G and N_GSYM for static storage and global scope,
1975 S for static storage and file scope,
1976 V for static storage and local scope,
1977 for those two, use N_LCSYM if data is in bss segment,
1978 N_STSYM if in data segment, N_FUN otherwise.
1979 (We used N_FUN originally, then changed to N_STSYM
1980 to please GDB. However, it seems that confused ld.
1981 Now GDB has been fixed to like N_FUN, says Kingdon.)
1982 no letter at all, and N_LSYM, for auto variable,
1983 r and N_RSYM for register variable. */
1985 if (GET_CODE (home) == MEM
1986 && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
1988 if (TREE_PUBLIC (decl))
1991 current_sym_code = N_GSYM;
1995 current_sym_addr = XEXP (home, 0);
1997 letter = decl_function_context (decl) ? 'V' : 'S';
1999 /* This should be the same condition as in assemble_variable, but
2000 we don't have access to dont_output_data here. So, instead,
2001 we rely on the fact that error_mark_node initializers always
2002 end up in bss for C++ and never end up in bss for C. */
2003 if (DECL_INITIAL (decl) == 0
2004 || (!strcmp (lang_identify (), "cplusplus")
2005 && DECL_INITIAL (decl) == error_mark_node))
2006 current_sym_code = N_LCSYM;
2007 else if (DECL_IN_TEXT_SECTION (decl))
2008 /* This is not quite right, but it's the closest
2009 of all the codes that Unix defines. */
2010 current_sym_code = DBX_STATIC_CONST_VAR_CODE;
2013 /* Ultrix `as' seems to need this. */
2014 #ifdef DBX_STATIC_STAB_DATA_SECTION
2017 current_sym_code = N_STSYM;
2021 else if (regno >= 0)
2024 current_sym_code = N_RSYM;
2025 current_sym_value = DBX_REGISTER_NUMBER (regno);
2027 else if (GET_CODE (home) == MEM
2028 && (GET_CODE (XEXP (home, 0)) == MEM
2029 || (GET_CODE (XEXP (home, 0)) == REG
2030 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
2031 && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
2032 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2033 && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
2036 /* If the value is indirect by memory or by a register
2037 that isn't the frame pointer
2038 then it means the object is variable-sized and address through
2039 that register or stack slot. DBX has no way to represent this
2040 so all we can do is output the variable as a pointer.
2041 If it's not a parameter, ignore it.
2042 (VAR_DECLs like this can be made by integrate.c.) */
2044 if (GET_CODE (XEXP (home, 0)) == REG)
2047 current_sym_code = N_RSYM;
2048 current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
2052 current_sym_code = N_LSYM;
2053 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2054 We want the value of that CONST_INT. */
2056 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
2059 /* Effectively do build_pointer_type, but don't cache this type,
2060 since it might be temporary whereas the type it points to
2061 might have been saved for inlining. */
2062 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2063 type = make_node (POINTER_TYPE);
2064 TREE_TYPE (type) = TREE_TYPE (decl);
2066 else if (GET_CODE (home) == MEM
2067 && GET_CODE (XEXP (home, 0)) == REG)
2069 current_sym_code = N_LSYM;
2070 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2072 else if (GET_CODE (home) == MEM
2073 && GET_CODE (XEXP (home, 0)) == PLUS
2074 && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
2076 current_sym_code = N_LSYM;
2077 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2078 We want the value of that CONST_INT. */
2079 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2081 else if (GET_CODE (home) == MEM
2082 && GET_CODE (XEXP (home, 0)) == CONST)
2084 /* Handle an obscure case which can arise when optimizing and
2085 when there are few available registers. (This is *always*
2086 the case for i386/i486 targets). The RTL looks like
2087 (MEM (CONST ...)) even though this variable is a local `auto'
2088 or a local `register' variable. In effect, what has happened
2089 is that the reload pass has seen that all assignments and
2090 references for one such a local variable can be replaced by
2091 equivalent assignments and references to some static storage
2092 variable, thereby avoiding the need for a register. In such
2093 cases we're forced to lie to debuggers and tell them that
2094 this variable was itself `static'. */
2095 current_sym_code = N_LCSYM;
2097 current_sym_addr = XEXP (XEXP (home, 0), 0);
2099 else if (GET_CODE (home) == CONCAT)
2101 tree subtype = TREE_TYPE (type);
2103 /* If the variable's storage is in two parts,
2104 output each as a separate stab with a modified name. */
2105 if (WORDS_BIG_ENDIAN)
2106 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
2108 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
2110 /* Cast avoids warning in old compilers. */
2111 current_sym_code = (STAB_CODE_TYPE) 0;
2112 current_sym_value = 0;
2113 current_sym_addr = 0;
2114 dbxout_prepare_symbol (decl);
2116 if (WORDS_BIG_ENDIAN)
2117 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
2119 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
2123 /* Address might be a MEM, when DECL is a variable-sized object.
2124 Or it might be const0_rtx, meaning previous passes
2125 want us to ignore this variable. */
2128 /* Ok, start a symtab entry and output the variable name. */
2131 #ifdef DBX_STATIC_BLOCK_START
2132 DBX_STATIC_BLOCK_START (asmfile, current_sym_code);
2135 dbxout_symbol_name (decl, suffix, letter);
2136 dbxout_type (type, 0, 0);
2137 dbxout_finish_symbol (decl);
2139 #ifdef DBX_STATIC_BLOCK_END
2140 DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
2144 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2145 Then output LETTER to indicate the kind of location the symbol has. */
2148 dbxout_symbol_name (decl, suffix, letter)
2153 /* One slight hitch: if this is a VAR_DECL which is a static
2154 class member, we must put out the mangled name instead of the
2155 DECL_NAME. Note also that static member (variable) names DO NOT begin
2156 with underscores in .stabs directives. */
2157 char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2160 fprintf (asmfile, "%s \"%s%s:", ASM_STABS_OP, name,
2161 (suffix ? suffix : ""));
2163 if (letter) putc (letter, asmfile);
2167 dbxout_prepare_symbol (decl)
2171 char *filename = DECL_SOURCE_FILE (decl);
2173 dbxout_source_file (asmfile, filename);
2178 dbxout_finish_symbol (sym)
2181 #ifdef DBX_FINISH_SYMBOL
2182 DBX_FINISH_SYMBOL (sym);
2185 if (use_gnu_debug_info_extensions && sym != 0)
2186 line = DECL_SOURCE_LINE (sym);
2188 fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line);
2189 if (current_sym_addr)
2190 output_addr_const (asmfile, current_sym_addr);
2192 fprintf (asmfile, "%d", current_sym_value);
2193 putc ('\n', asmfile);
2197 /* Output definitions of all the decls in a chain. */
2205 dbxout_symbol (syms, 1);
2206 syms = TREE_CHAIN (syms);
2210 /* The following two functions output definitions of function parameters.
2211 Each parameter gets a definition locating it in the parameter list.
2212 Each parameter that is a register variable gets a second definition
2213 locating it in the register.
2215 Printing or argument lists in gdb uses the definitions that
2216 locate in the parameter list. But reference to the variable in
2217 expressions uses preferentially the definition as a register. */
2219 /* Output definitions, referring to storage in the parmlist,
2220 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2223 dbxout_parms (parms)
2226 for (; parms; parms = TREE_CHAIN (parms))
2227 if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node)
2229 dbxout_prepare_symbol (parms);
2231 /* Perform any necessary register eliminations on the parameter's rtl,
2232 so that the debugging output will be accurate. */
2233 DECL_INCOMING_RTL (parms)
2234 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
2235 DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX);
2236 #ifdef LEAF_REG_REMAP
2239 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
2240 leaf_renumber_regs_insn (DECL_RTL (parms));
2244 if (PARM_PASSED_IN_MEMORY (parms))
2246 rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
2248 /* ??? Here we assume that the parm address is indexed
2249 off the frame pointer or arg pointer.
2250 If that is not true, we produce meaningless results,
2251 but do not crash. */
2252 if (GET_CODE (addr) == PLUS
2253 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
2254 current_sym_value = INTVAL (XEXP (addr, 1));
2256 current_sym_value = 0;
2258 current_sym_code = N_PSYM;
2259 current_sym_addr = 0;
2262 if (DECL_NAME (parms))
2264 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2266 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2267 IDENTIFIER_POINTER (DECL_NAME (parms)),
2268 DBX_MEMPARM_STABS_LETTER);
2272 current_sym_nchars = 8;
2273 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2274 DBX_MEMPARM_STABS_LETTER);
2277 dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
2278 current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
2279 dbxout_finish_symbol (parms);
2281 else if (GET_CODE (DECL_RTL (parms)) == REG)
2284 char regparm_letter;
2286 /* Parm passed in registers and lives in registers or nowhere. */
2288 current_sym_code = DBX_REGPARM_STABS_CODE;
2289 regparm_letter = DBX_REGPARM_STABS_LETTER;
2290 current_sym_addr = 0;
2292 /* If parm lives in a register, use that register;
2293 pretend the parm was passed there. It would be more consistent
2294 to describe the register where the parm was passed,
2295 but in practice that register usually holds something else.
2297 If we use DECL_RTL, then we must use the declared type of
2298 the variable, not the type that it arrived in. */
2299 if (REGNO (DECL_RTL (parms)) >= 0
2300 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2302 best_rtl = DECL_RTL (parms);
2303 parm_type = TREE_TYPE (parms);
2305 /* If the parm lives nowhere, use the register where it was
2306 passed. It is also better to use the declared type here. */
2309 best_rtl = DECL_INCOMING_RTL (parms);
2310 parm_type = TREE_TYPE (parms);
2312 current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
2315 if (DECL_NAME (parms))
2317 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2318 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2319 IDENTIFIER_POINTER (DECL_NAME (parms)),
2324 current_sym_nchars = 8;
2325 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2329 dbxout_type (parm_type, 0, 0);
2330 dbxout_finish_symbol (parms);
2332 else if (GET_CODE (DECL_RTL (parms)) == MEM
2333 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2334 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
2335 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
2336 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2337 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
2341 /* Parm was passed via invisible reference.
2342 That is, its address was passed in a register.
2343 Output it as if it lived in that register.
2344 The debugger will know from the type
2345 that it was actually passed by invisible reference. */
2347 char regparm_letter;
2348 /* Parm passed in registers and lives in registers or nowhere. */
2350 current_sym_code = DBX_REGPARM_STABS_CODE;
2351 if (use_gnu_debug_info_extensions)
2352 regparm_letter = GDB_INV_REF_REGPARM_STABS_LETTER;
2354 regparm_letter = DBX_REGPARM_STABS_LETTER;
2356 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2357 If it is an unallocated pseudo-reg, then use the register where
2358 it was passed instead. */
2359 if (REGNO (XEXP (DECL_RTL (parms), 0)) >= 0
2360 && REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
2361 current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2363 current_sym_value = REGNO (DECL_INCOMING_RTL (parms));
2365 current_sym_addr = 0;
2368 if (DECL_NAME (parms))
2370 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2372 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2373 IDENTIFIER_POINTER (DECL_NAME (parms)),
2378 current_sym_nchars = 8;
2379 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2383 dbxout_type (TREE_TYPE (parms), 0, 0);
2384 dbxout_finish_symbol (parms);
2386 else if (GET_CODE (DECL_RTL (parms)) == MEM
2387 && XEXP (DECL_RTL (parms), 0) != const0_rtx
2388 /* ??? A constant address for a parm can happen
2389 when the reg it lives in is equiv to a constant in memory.
2390 Should make this not happen, after 2.4. */
2391 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
2393 /* Parm was passed in registers but lives on the stack. */
2395 current_sym_code = N_PSYM;
2396 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2397 in which case we want the value of that CONST_INT,
2398 or (MEM (REG ...)) or (MEM (MEM ...)),
2399 in which case we use a value of zero. */
2400 if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2401 || GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
2402 current_sym_value = 0;
2404 current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
2405 current_sym_addr = 0;
2407 /* Make a big endian correction if the mode of the type of the
2408 parameter is not the same as the mode of the rtl. */
2409 if (BYTES_BIG_ENDIAN
2410 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
2411 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
2413 current_sym_value += UNITS_PER_WORD - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms)));
2417 if (DECL_NAME (parms))
2419 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2421 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2422 IDENTIFIER_POINTER (DECL_NAME (parms)),
2423 DBX_MEMPARM_STABS_LETTER);
2427 current_sym_nchars = 8;
2428 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2429 DBX_MEMPARM_STABS_LETTER);
2433 = DEBUGGER_ARG_OFFSET (current_sym_value,
2434 XEXP (DECL_RTL (parms), 0));
2435 dbxout_type (TREE_TYPE (parms), 0, 0);
2436 dbxout_finish_symbol (parms);
2441 /* Output definitions for the places where parms live during the function,
2442 when different from where they were passed, when the parms were passed
2445 It is not useful to do this for parms passed in registers
2446 that live during the function in different registers, because it is
2447 impossible to look in the passed register for the passed value,
2448 so we use the within-the-function register to begin with.
2450 PARMS is a chain of PARM_DECL nodes. */
2453 dbxout_reg_parms (parms)
2456 for (; parms; parms = TREE_CHAIN (parms))
2457 if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
2459 dbxout_prepare_symbol (parms);
2461 /* Report parms that live in registers during the function
2462 but were passed in memory. */
2463 if (GET_CODE (DECL_RTL (parms)) == REG
2464 && REGNO (DECL_RTL (parms)) >= 0
2465 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2466 dbxout_symbol_location (parms, TREE_TYPE (parms),
2467 0, DECL_RTL (parms));
2468 else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
2469 dbxout_symbol_location (parms, TREE_TYPE (parms),
2470 0, DECL_RTL (parms));
2471 /* Report parms that live in memory but not where they were passed. */
2472 else if (GET_CODE (DECL_RTL (parms)) == MEM
2473 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
2474 dbxout_symbol_location (parms, TREE_TYPE (parms),
2475 0, DECL_RTL (parms));
2479 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2480 output definitions of those names, in raw form */
2488 putc (',', asmfile);
2489 dbxout_type (TREE_VALUE (args), 0, 0);
2491 args = TREE_CHAIN (args);
2495 /* Given a chain of ..._TYPE nodes,
2496 find those which have typedef names and output those names.
2497 This is to ensure those types get output. */
2500 dbxout_types (types)
2501 register tree types;
2505 if (TYPE_NAME (types)
2506 && TREE_CODE (TYPE_NAME (types)) == TYPE_DECL
2507 && ! TREE_ASM_WRITTEN (TYPE_NAME (types)))
2508 dbxout_symbol (TYPE_NAME (types), 1);
2509 types = TREE_CHAIN (types);
2513 /* Output everything about a symbol block (a BLOCK node
2514 that represents a scope level),
2515 including recursive output of contained blocks.
2517 BLOCK is the BLOCK node.
2518 DEPTH is its depth within containing symbol blocks.
2519 ARGS is usually zero; but for the outermost block of the
2520 body of a function, it is a chain of PARM_DECLs for the function parameters.
2521 We output definitions of all the register parms
2522 as if they were local variables of that block.
2524 If -g1 was used, we count blocks just the same, but output nothing
2525 except for the outermost block.
2527 Actually, BLOCK may be several blocks chained together.
2528 We handle them all in sequence. */
2531 dbxout_block (block, depth, args)
2532 register tree block;
2540 /* Ignore blocks never expanded or otherwise marked as real. */
2541 if (TREE_USED (block))
2543 #ifndef DBX_LBRAC_FIRST
2544 /* In dbx format, the syms of a block come before the N_LBRAC. */
2545 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2546 dbxout_syms (BLOCK_VARS (block));
2548 dbxout_reg_parms (args);
2551 /* Now output an N_LBRAC symbol to represent the beginning of
2552 the block. Use the block's tree-walk order to generate
2553 the assembler symbols LBBn and LBEn
2554 that final will define around the code in this block. */
2555 if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE)
2558 blocknum = next_block_number++;
2559 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
2561 if (BLOCK_HANDLER_BLOCK (block))
2563 /* A catch block. Must precede N_LBRAC. */
2564 tree decl = BLOCK_VARS (block);
2567 #ifdef DBX_OUTPUT_CATCH
2568 DBX_OUTPUT_CATCH (asmfile, decl, buf);
2570 fprintf (asmfile, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP,
2571 IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
2572 assemble_name (asmfile, buf);
2573 fprintf (asmfile, "\n");
2575 decl = TREE_CHAIN (decl);
2579 #ifdef DBX_OUTPUT_LBRAC
2580 DBX_OUTPUT_LBRAC (asmfile, buf);
2582 fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_LBRAC);
2583 assemble_name (asmfile, buf);
2584 #if DBX_BLOCKS_FUNCTION_RELATIVE
2585 fputc ('-', asmfile);
2586 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
2588 fprintf (asmfile, "\n");
2592 /* Count blocks the same way regardless of debug_info_level. */
2593 next_block_number++;
2595 #ifdef DBX_LBRAC_FIRST
2596 /* On some weird machines, the syms of a block
2597 come after the N_LBRAC. */
2598 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2599 dbxout_syms (BLOCK_VARS (block));
2601 dbxout_reg_parms (args);
2604 /* Output the subblocks. */
2605 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
2607 /* Refer to the marker for the end of the block. */
2608 if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE)
2611 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
2612 #ifdef DBX_OUTPUT_RBRAC
2613 DBX_OUTPUT_RBRAC (asmfile, buf);
2615 fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_RBRAC);
2616 assemble_name (asmfile, buf);
2617 #if DBX_BLOCKS_FUNCTION_RELATIVE
2618 fputc ('-', asmfile);
2619 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
2621 fprintf (asmfile, "\n");
2625 block = BLOCK_CHAIN (block);
2629 /* Output the information about a function and its arguments and result.
2630 Usually this follows the function's code,
2631 but on some systems, it comes before. */
2634 dbxout_really_begin_function (decl)
2637 dbxout_symbol (decl, 0);
2638 dbxout_parms (DECL_ARGUMENTS (decl));
2639 if (DECL_NAME (DECL_RESULT (decl)) != 0)
2640 dbxout_symbol (DECL_RESULT (decl), 1);
2643 /* Called at beginning of output of function definition. */
2646 dbxout_begin_function (decl)
2649 #ifdef DBX_FUNCTION_FIRST
2650 dbxout_really_begin_function (decl);
2654 /* Output dbx data for a function definition.
2655 This includes a definition of the function name itself (a symbol),
2656 definitions of the parameters (locating them in the parameter list)
2657 and then output the block that makes up the function's body
2658 (including all the auto variables of the function). */
2661 dbxout_function (decl)
2664 #ifndef DBX_FUNCTION_FIRST
2665 dbxout_really_begin_function (decl);
2667 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
2668 #ifdef DBX_OUTPUT_FUNCTION_END
2669 DBX_OUTPUT_FUNCTION_END (asmfile, decl);
2671 #if defined(ASM_OUTPUT_SECTION_NAME)
2672 if (use_gnu_debug_info_extensions
2673 #if defined(NO_DBX_FUNCTION_END)
2674 && ! NO_DBX_FUNCTION_END
2677 dbxout_function_end ();
2680 #endif /* DBX_DEBUGGING_INFO */