1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987, 88, 92-97, 1998 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
22 /* Output dbx-format symbol table data.
23 This consists of many symbol table entries, each of them
24 a .stabs assembler pseudo-op with four operands:
25 a "name" which is really a description of one symbol and its type,
26 a "code", which is a symbol defined in stab.h whose name starts with N_,
27 an unused operand always 0,
28 and a "value" which is an address or an offset.
29 The name is enclosed in doublequote characters.
31 Each function, variable, typedef, and structure tag
32 has a symbol table entry to define it.
33 The beginning and end of each level of name scoping within
34 a function are also marked by special symbol table entries.
36 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
37 and a data type number. The data type number may be followed by
38 "=" and a type definition; normally this will happen the first time
39 the type number is mentioned. The type definition may refer to
40 other types by number, and those type numbers may be followed
41 by "=" and nested definitions.
43 This can make the "name" quite long.
44 When a name is more than 80 characters, we split the .stabs pseudo-op
45 into two .stabs pseudo-ops, both sharing the same "code" and "value".
46 The first one is marked as continued with a double-backslash at the
49 The kind-of-symbol letter distinguished function names from global
50 variables from file-scope variables from parameters from auto
51 variables in memory from typedef names from register variables.
54 The "code" is mostly redundant with the kind-of-symbol letter
55 that goes in the "name", but not entirely: for symbols located
56 in static storage, the "code" says which segment the address is in,
57 which controls how it is relocated.
59 The "value" for a symbol in static storage
60 is the core address of the symbol (actually, the assembler
61 label for the symbol). For a symbol located in a stack slot
62 it is the stack offset; for one in a register, the register number.
63 For a typedef symbol, it is zero.
65 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
66 output while in the text section.
68 For more on data type definitions, see `dbxout_type'. */
77 #include "insn-config.h"
80 #include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions. */
84 #ifdef XCOFF_DEBUGGING_INFO
89 #define ASM_STABS_OP ".stabs"
93 #define ASM_STABN_OP ".stabn"
96 #ifndef DBX_TYPE_DECL_STABS_CODE
97 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
100 #ifndef DBX_STATIC_CONST_VAR_CODE
101 #define DBX_STATIC_CONST_VAR_CODE N_FUN
104 #ifndef DBX_REGPARM_STABS_CODE
105 #define DBX_REGPARM_STABS_CODE N_RSYM
108 #ifndef DBX_REGPARM_STABS_LETTER
109 #define DBX_REGPARM_STABS_LETTER 'P'
112 /* This is used for parameters passed by invisible reference in a register. */
113 #ifndef GDB_INV_REF_REGPARM_STABS_LETTER
114 #define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
117 #ifndef DBX_MEMPARM_STABS_LETTER
118 #define DBX_MEMPARM_STABS_LETTER 'p'
121 #ifndef FILE_NAME_JOINER
122 #define FILE_NAME_JOINER "/"
125 /* Nonzero means if the type has methods, only output debugging
126 information if methods are actually written to the asm file. This
127 optimization only works if the debugger can detect the special C++
130 #define MINIMAL_DEBUG 1
132 #ifdef NO_DOLLAR_IN_LABEL
133 #ifdef NO_DOT_IN_LABEL
135 #define MINIMAL_DEBUG 0
141 /* Typical USG systems don't have stab.h, and they also have
142 no use for DBX-format debugging info. */
144 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
146 static int flag_minimal_debug = MINIMAL_DEBUG;
148 /* Nonzero if we have actually used any of the GDB extensions
149 to the debugging format. The idea is that we use them for the
150 first time only if there's a strong reason, but once we have done that,
151 we use them whenever convenient. */
153 static int have_used_extensions = 0;
155 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
156 for the N_SO filename stabs label. */
158 static int source_label_number = 1;
160 #ifdef DEBUG_SYMS_TEXT
161 #define FORCE_TEXT text_section ();
166 /* If there is a system stabs.h, use it. Otherwise, use our own. */
173 /* This is a GNU extension we need to reference in this file. */
180 #define STAB_CODE_TYPE enum __stab_debug_code
182 #define STAB_CODE_TYPE int
185 /* 1 if PARM is passed to this function in memory. */
187 #define PARM_PASSED_IN_MEMORY(PARM) \
188 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
190 /* A C expression for the integer offset value of an automatic variable
191 (N_LSYM) having address X (an RTX). */
192 #ifndef DEBUGGER_AUTO_OFFSET
193 #define DEBUGGER_AUTO_OFFSET(X) \
194 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
197 /* A C expression for the integer offset value of an argument (N_PSYM)
198 having address X (an RTX). The nominal offset is OFFSET. */
199 #ifndef DEBUGGER_ARG_OFFSET
200 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
203 /* Stream for writing to assembler file. */
205 static FILE *asmfile;
207 /* Last source file name mentioned in a NOTE insn. */
209 static char *lastfile;
211 /* Current working directory. */
215 enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
217 /* Structure recording information about a C data type.
218 The status element says whether we have yet output
219 the definition of the type. TYPE_XREF says we have
220 output it as a cross-reference only.
221 The file_number and type_number elements are used if DBX_USE_BINCL
226 enum typestatus status;
233 /* Vector recording information about C data types.
234 When we first notice a data type (a tree node),
235 we assign it a number using next_type_number.
236 That is its index in this vector. */
238 struct typeinfo *typevec;
240 /* Number of elements of space allocated in `typevec'. */
242 static int typevec_len;
244 /* In dbx output, each type gets a unique number.
245 This is the number for the next type output.
246 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
248 static int next_type_number;
252 /* When using N_BINCL in dbx output, each type number is actually a
253 pair of the file number and the type number within the file.
254 This is a stack of input files. */
258 struct dbx_file *next;
260 int next_type_number;
263 /* This is the top of the stack. */
265 static struct dbx_file *current_file;
267 /* This is the next file number to use. */
269 static int next_file_number;
271 #endif /* DBX_USE_BINCL */
273 /* In dbx output, we must assign symbol-blocks id numbers
274 in the order in which their beginnings are encountered.
275 We output debugging info that refers to the beginning and
276 end of the ranges of code in each block
277 with assembler labels LBBn and LBEn, where n is the block number.
278 The labels are generated in final, which assigns numbers to the
279 blocks in the same way. */
281 static int next_block_number;
283 /* These variables are for dbxout_symbol to communicate to
284 dbxout_finish_symbol.
285 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
286 current_sym_value and current_sym_addr are two ways to address the
287 value to store in the symtab entry.
288 current_sym_addr if nonzero represents the value as an rtx.
289 If that is zero, current_sym_value is used. This is used
290 when the value is an offset (such as for auto variables,
291 register variables and parms). */
293 static STAB_CODE_TYPE current_sym_code;
294 static int current_sym_value;
295 static rtx current_sym_addr;
297 /* Number of chars of symbol-description generated so far for the
298 current symbol. Used by CHARS and CONTIN. */
300 static int current_sym_nchars;
302 /* Report having output N chars of the current symbol-description. */
304 #define CHARS(N) (current_sym_nchars += (N))
306 /* Break the current symbol-description, generating a continuation,
307 if it has become long. */
309 #ifndef DBX_CONTIN_LENGTH
310 #define DBX_CONTIN_LENGTH 80
313 #if DBX_CONTIN_LENGTH > 0
315 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
320 void dbxout_types ();
322 void dbxout_symbol ();
324 #if defined(ASM_OUTPUT_SECTION_NAME)
325 static void dbxout_function_end PROTO((void));
327 static void dbxout_typedefs PROTO((tree));
328 static void dbxout_type_index PROTO((tree));
329 #if DBX_CONTIN_LENGTH > 0
330 static void dbxout_continue PROTO((void));
332 static void dbxout_type_fields PROTO((tree));
333 static void dbxout_type_method_1 PROTO((tree, char *));
334 static void dbxout_type_methods PROTO((tree));
335 static void dbxout_range_type PROTO((tree));
336 static void dbxout_type PROTO((tree, int, int));
337 static void print_int_cst_octal PROTO((tree));
338 static void print_octal PROTO((unsigned HOST_WIDE_INT, int));
339 static void dbxout_type_name PROTO((tree));
340 static void dbxout_symbol_location PROTO((tree, tree, char *, rtx));
341 static void dbxout_symbol_name PROTO((tree, char *, int));
342 static void dbxout_prepare_symbol PROTO((tree));
343 static void dbxout_finish_symbol PROTO((tree));
344 static void dbxout_block PROTO((tree, int, tree));
345 static void dbxout_really_begin_function PROTO((tree));
347 #if defined(ASM_OUTPUT_SECTION_NAME)
349 dbxout_function_end ()
351 static int scope_labelno = 0;
352 char lscope_label_name[100];
353 /* Convert Ltext into the appropriate format for local labels in case
354 the system doesn't insert underscores in front of user generated
356 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
357 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Lscope", scope_labelno);
360 /* By convention, GCC will mark the end of a function with an N_FUN
361 symbol and an empty string. */
362 fprintf (asmfile, "%s \"\",%d,0,0,", ASM_STABS_OP, N_FUN);
363 assemble_name (asmfile, lscope_label_name);
364 fputc ('-', asmfile);
365 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
366 fprintf (asmfile, "\n");
368 #endif /* ! NO_DBX_FUNCTION_END */
370 /* At the beginning of compilation, start writing the symbol table.
371 Initialize `typevec' and output the standard data types of C. */
374 dbxout_init (asm_file, input_file_name, syms)
376 char *input_file_name;
379 char ltext_label_name[100];
384 typevec = (struct typeinfo *) xmalloc (typevec_len * sizeof typevec[0]);
385 bzero ((char *) typevec, typevec_len * sizeof typevec[0]);
387 /* Convert Ltext into the appropriate format for local labels in case
388 the system doesn't insert underscores in front of user generated
390 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
392 /* Put the current working directory in an N_SO symbol. */
393 #ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this,
394 but GDB always does. */
395 if (use_gnu_debug_info_extensions)
398 if (!cwd && (cwd = getpwd ()) && (!*cwd || cwd[strlen (cwd) - 1] != '/'))
400 char *wdslash = xmalloc (strlen (cwd) + sizeof (FILE_NAME_JOINER));
401 sprintf (wdslash, "%s%s", cwd, FILE_NAME_JOINER);
406 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
407 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd);
408 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
409 fprintf (asmfile, "%s ", ASM_STABS_OP);
410 output_quoted_string (asmfile, cwd);
411 fprintf (asmfile, ",%d,0,0,%s\n", N_SO, <ext_label_name[1]);
412 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
416 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
417 /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That
418 would give us an N_SOL, and we want an N_SO. */
419 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile, input_file_name);
420 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
421 /* We include outputting `Ltext:' here,
422 because that gives you a way to override it. */
423 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
424 fprintf (asmfile, "%s ", ASM_STABS_OP);
425 output_quoted_string (asmfile, input_file_name);
426 fprintf (asmfile, ",%d,0,0,%s\n",
427 N_SO, <ext_label_name[1]);
429 ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Ltext", 0);
430 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
432 /* Possibly output something to inform GDB that this compilation was by
433 GCC. It's easier for GDB to parse it when after the N_SO's. This
434 is used in Solaris 2. */
435 #ifdef ASM_IDENTIFY_GCC_AFTER_SOURCE
436 ASM_IDENTIFY_GCC_AFTER_SOURCE (asmfile);
439 lastfile = input_file_name;
441 next_type_number = 1;
442 next_block_number = 2;
445 current_file = (struct dbx_file *) xmalloc (sizeof *current_file);
446 current_file->next = NULL;
447 current_file->file_number = 0;
448 current_file->next_type_number = 1;
449 next_file_number = 1;
452 /* Make sure that types `int' and `char' have numbers 1 and 2.
453 Definitions of other integer types will refer to those numbers.
454 (Actually it should no longer matter what their numbers are.
455 Also, if any types with tags have been defined, dbxout_symbol
456 will output them first, so the numbers won't be 1 and 2. That
457 happens in C++. So it's a good thing it should no longer matter). */
459 #ifdef DBX_OUTPUT_STANDARD_TYPES
460 DBX_OUTPUT_STANDARD_TYPES (syms);
462 dbxout_symbol (TYPE_NAME (integer_type_node), 0);
463 dbxout_symbol (TYPE_NAME (char_type_node), 0);
466 /* Get all permanent types that have typedef names,
467 and output them all, except for those already output. */
469 dbxout_typedefs (syms);
472 /* Output any typedef names for types described by TYPE_DECLs in SYMS,
473 in the reverse order from that which is found in SYMS. */
476 dbxout_typedefs (syms)
481 dbxout_typedefs (TREE_CHAIN (syms));
482 if (TREE_CODE (syms) == TYPE_DECL)
484 tree type = TREE_TYPE (syms);
486 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
487 && TYPE_SIZE (type) != NULL_TREE
488 && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
489 dbxout_symbol (TYPE_NAME (type), 0);
494 /* Change to reading from a new source file. Generate a N_BINCL stab. */
497 dbxout_start_new_source_file (filename)
501 struct dbx_file *n = (struct dbx_file *) xmalloc (sizeof *n);
503 n->next = current_file;
504 n->file_number = next_file_number++;
505 n->next_type_number = 1;
507 fprintf (asmfile, "%s ", ASM_STABS_OP);
508 output_quoted_string (asmfile, filename);
509 fprintf (asmfile, ",%d,0,0,0\n", N_BINCL);
513 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
516 dbxout_resume_previous_source_file ()
519 struct dbx_file *next;
521 fprintf (asmfile, "%s %d,0,0,0\n", ASM_STABN_OP, N_EINCL);
522 next = current_file->next;
528 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
531 dbxout_source_file (file, filename)
535 char ltext_label_name[100];
537 if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
539 #ifdef DBX_OUTPUT_SOURCE_FILENAME
540 DBX_OUTPUT_SOURCE_FILENAME (file, filename);
542 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext",
543 source_label_number);
544 fprintf (file, "%s ", ASM_STABS_OP);
545 output_quoted_string (file, filename);
546 fprintf (file, ",%d,0,0,%s\n", N_SOL, <ext_label_name[1]);
547 if (current_function_decl != NULL_TREE
548 && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
549 ; /* Don't change section amid function. */
552 ASM_OUTPUT_INTERNAL_LABEL (file, "Ltext", source_label_number);
553 source_label_number++;
559 /* Output a line number symbol entry into output stream FILE,
560 for source file FILENAME and line number LINENO. */
563 dbxout_source_line (file, filename, lineno)
568 dbxout_source_file (file, filename);
570 #ifdef ASM_OUTPUT_SOURCE_LINE
571 ASM_OUTPUT_SOURCE_LINE (file, lineno);
573 fprintf (file, "\t%s %d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno);
577 /* At the end of compilation, finish writing the symbol table.
578 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
582 dbxout_finish (file, filename)
586 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
587 DBX_OUTPUT_MAIN_SOURCE_FILE_END (file, filename);
588 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
591 /* Output the index of a type. */
594 dbxout_type_index (type)
597 #ifndef DBX_USE_BINCL
598 fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
601 struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
602 fprintf (asmfile, "(%d,%d)", t->file_number, t->type_number);
607 #if DBX_CONTIN_LENGTH > 0
608 /* Continue a symbol-description that gets too big.
609 End one symbol table entry with a double-backslash
610 and start a new one, eventually producing something like
611 .stabs "start......\\",code,0,value
612 .stabs "...rest",code,0,value */
617 #ifdef DBX_CONTIN_CHAR
618 fprintf (asmfile, "%c", DBX_CONTIN_CHAR);
620 fprintf (asmfile, "\\\\");
622 dbxout_finish_symbol (NULL_TREE);
623 fprintf (asmfile, "%s \"", ASM_STABS_OP);
624 current_sym_nchars = 0;
626 #endif /* DBX_CONTIN_LENGTH > 0 */
628 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
629 This must be a separate function because anonymous unions require
633 dbxout_type_fields (type)
637 /* Output the name, type, position (in bits), size (in bits) of each
639 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
641 /* Omit here local type decls until we know how to support them. */
642 if (TREE_CODE (tem) == TYPE_DECL)
644 /* Omit fields whose position or size are variable. */
645 else if (TREE_CODE (tem) == FIELD_DECL
646 && (TREE_CODE (DECL_FIELD_BITPOS (tem)) != INTEGER_CST
647 || TREE_CODE (DECL_SIZE (tem)) != INTEGER_CST))
649 /* Omit here the nameless fields that are used to skip bits. */
650 else if (DECL_IGNORED_P (tem))
652 else if (TREE_CODE (tem) != CONST_DECL)
654 /* Continue the line if necessary,
655 but not before the first field. */
656 if (tem != TYPE_FIELDS (type))
661 if (use_gnu_debug_info_extensions
662 && flag_minimal_debug
663 && TREE_CODE (tem) == FIELD_DECL
664 && DECL_VIRTUAL_P (tem)
665 && DECL_ASSEMBLER_NAME (tem))
667 have_used_extensions = 1;
668 CHARS (3 + IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (tem)));
669 fputs (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem)), asmfile);
670 dbxout_type (DECL_FCONTEXT (tem), 0, 0);
671 fprintf (asmfile, ":");
672 dbxout_type (TREE_TYPE (tem), 0, 0);
673 fputc (',', asmfile);
674 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
675 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)));
676 fputc (';', asmfile);
682 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
683 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem)));
687 fprintf (asmfile, ":");
691 if (use_gnu_debug_info_extensions
692 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
693 || TREE_CODE (tem) != FIELD_DECL))
695 have_used_extensions = 1;
697 putc ((TREE_PRIVATE (tem) ? '0'
698 : TREE_PROTECTED (tem) ? '1' : '2'),
703 dbxout_type ((TREE_CODE (tem) == FIELD_DECL
704 && DECL_BIT_FIELD_TYPE (tem))
705 ? DECL_BIT_FIELD_TYPE (tem)
706 : TREE_TYPE (tem), 0, 0);
708 if (TREE_CODE (tem) == VAR_DECL)
710 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
712 char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (tem));
713 have_used_extensions = 1;
714 fprintf (asmfile, ":%s;", name);
715 CHARS (strlen (name));
719 /* If TEM is non-static, GDB won't understand it. */
720 fprintf (asmfile, ",0,0;");
723 else if (TREE_CODE (DECL_FIELD_BITPOS (tem)) == INTEGER_CST)
725 fputc (',', asmfile);
726 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
727 TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)));
728 fputc (',', asmfile);
729 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
730 TREE_INT_CST_LOW (DECL_SIZE (tem)));
731 fputc (';', asmfile);
738 /* Subroutine of `dbxout_type_methods'. Output debug info about the
739 method described DECL. DEBUG_NAME is an encoding of the method's
740 type signature. ??? We may be able to do without DEBUG_NAME altogether
744 dbxout_type_method_1 (decl, debug_name)
750 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
752 else /* it's a METHOD_TYPE. */
754 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
755 /* A for normal functions.
756 B for `const' member functions.
757 C for `volatile' member functions.
758 D for `const volatile' member functions. */
759 if (TYPE_READONLY (TREE_TYPE (firstarg)))
761 if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
764 if (DECL_VINDEX (decl))
770 fprintf (asmfile, ":%s;%c%c%c", debug_name,
771 TREE_PRIVATE (decl) ? '0' : TREE_PROTECTED (decl) ? '1' : '2', c1, c2);
772 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)) + 6
773 - (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
774 if (DECL_VINDEX (decl))
776 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
777 TREE_INT_CST_LOW (DECL_VINDEX (decl)));
778 fputc (';', asmfile);
779 dbxout_type (DECL_CONTEXT (decl), 0, 0);
780 fprintf (asmfile, ";");
785 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
789 dbxout_type_methods (type)
792 /* C++: put out the method names and their parameter lists */
793 tree methods = TYPE_METHODS (type);
795 register tree fndecl;
797 char formatted_type_identifier_length[16];
798 register int type_identifier_length;
800 if (methods == NULL_TREE)
803 type_encoding = DECL_NAME (TYPE_NAME (type));
806 /* C++: Template classes break some assumptions made by this code about
807 the class names, constructor names, and encodings for assembler
808 label names. For now, disable output of dbx info for them. */
810 char *ptr = IDENTIFIER_POINTER (type_encoding);
811 /* This should use index. (mrs) */
812 while (*ptr && *ptr != '<') ptr++;
819 #ifdef HAVE_TEMPLATES
820 if (warn_template_debugging)
821 warning ("dbx info for template class methods not yet supported");
829 type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
831 sprintf(formatted_type_identifier_length, "%d", type_identifier_length);
833 if (TREE_CODE (methods) != TREE_VEC)
835 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
836 fndecl = TREE_VEC_ELT (methods, 0);
838 fndecl = TREE_VEC_ELT (methods, 1);
842 tree name = DECL_NAME (fndecl);
845 /* Group together all the methods for the same operation.
846 These differ in the types of the arguments. */
847 for (last = NULL_TREE;
848 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
849 fndecl = TREE_CHAIN (fndecl))
850 /* Output the name of the field (after overloading), as
851 well as the name of the field before overloading, along
852 with its parameter list */
854 /* This is the "mangled" name of the method.
855 It encodes the argument types. */
856 char *debug_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
857 int show_arg_types = 0;
863 if (DECL_IGNORED_P (fndecl))
866 if (flag_minimal_debug)
870 /* We can't optimize a method which uses an anonymous
871 class, because the debugger will not be able to
872 associate the arbitrary class name with the actual
874 #ifndef NO_DOLLAR_IN_LABEL
879 if (strchr (debug_name, marker))
881 /* Detect ordinary methods because their mangled names
882 start with the operation name. */
883 else if (!strncmp (IDENTIFIER_POINTER (name), debug_name,
884 IDENTIFIER_LENGTH (name)))
886 debug_name += IDENTIFIER_LENGTH (name);
887 if (debug_name[0] == '_' && debug_name[1] == '_')
889 char *method_name = debug_name + 2;
890 char *length_ptr = formatted_type_identifier_length;
891 /* Get past const and volatile qualifiers. */
892 while (*method_name == 'C' || *method_name == 'V')
894 /* Skip digits for length of type_encoding. */
895 while (*method_name == *length_ptr && *length_ptr)
896 length_ptr++, method_name++;
897 if (! strncmp (method_name,
898 IDENTIFIER_POINTER (type_encoding),
899 type_identifier_length))
900 method_name += type_identifier_length;
901 debug_name = method_name;
904 /* Detect constructors by their style of name mangling. */
905 else if (debug_name[0] == '_' && debug_name[1] == '_')
907 char *ctor_name = debug_name + 2;
908 char *length_ptr = formatted_type_identifier_length;
909 while (*ctor_name == 'C' || *ctor_name == 'V')
911 /* Skip digits for length of type_encoding. */
912 while (*ctor_name == *length_ptr && *length_ptr)
913 length_ptr++, ctor_name++;
914 if (!strncmp (IDENTIFIER_POINTER (type_encoding), ctor_name,
915 type_identifier_length))
916 debug_name = ctor_name + type_identifier_length;
918 /* The other alternative is a destructor. */
922 /* Output the operation name just once, for the first method
926 fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
927 CHARS (IDENTIFIER_LENGTH (name) + 2);
932 dbxout_type (TREE_TYPE (fndecl), 0, show_arg_types);
934 dbxout_type_method_1 (fndecl, debug_name);
944 /* Emit a "range" type specification, which has the form:
945 "r<index type>;<lower bound>;<upper bound>;".
946 TYPE is an INTEGER_TYPE. */
949 dbxout_range_type (type)
952 fprintf (asmfile, "r");
953 if (TREE_TYPE (type))
954 dbxout_type (TREE_TYPE (type), 0, 0);
955 else if (TREE_CODE (type) != INTEGER_TYPE)
956 dbxout_type (type, 0, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
959 /* Traditionally, we made sure 'int' was type 1, and builtin types
960 were defined to be sub-ranges of int. Unfortunately, this
961 does not allow us to distinguish true sub-ranges from integer
962 types. So, instead we define integer (non-sub-range) types as
963 sub-ranges of themselves. */
964 dbxout_type_index (type);
966 if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
968 fputc (';', asmfile);
969 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
970 TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)));
973 fprintf (asmfile, ";0");
974 if (TYPE_MAX_VALUE (type)
975 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
977 fputc (';', asmfile);
978 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
979 TREE_INT_CST_LOW (TYPE_MAX_VALUE (type)));
980 fputc (';', asmfile);
983 fprintf (asmfile, ";-1;");
986 /* Output a reference to a type. If the type has not yet been
987 described in the dbx output, output its definition now.
988 For a type already defined, just refer to its definition
989 using the type number.
991 If FULL is nonzero, and the type has been described only with
992 a forward-reference, output the definition now.
993 If FULL is zero in this case, just refer to the forward-reference
994 using the number previously allocated.
996 If SHOW_ARG_TYPES is nonzero, we output a description of the argument
997 types for a METHOD_TYPE. */
1000 dbxout_type (type, full, show_arg_types)
1006 static int anonymous_type_number = 0;
1008 /* If there was an input error and we don't really have a type,
1009 avoid crashing and write something that is at least valid
1010 by assuming `int'. */
1011 if (type == error_mark_node)
1012 type = integer_type_node;
1015 /* Try to find the "main variant" with the same name but not const
1016 or volatile. (Since stabs does not distinguish const and volatile,
1017 there is no need to make them separate types. But types with
1018 different names are usefully distinguished.) */
1020 for (tem = TYPE_MAIN_VARIANT (type); tem; tem = TYPE_NEXT_VARIANT (tem))
1021 if (!TYPE_READONLY (tem) && !TYPE_VOLATILE (tem)
1022 && TYPE_NAME (tem) == TYPE_NAME (type))
1027 if (TYPE_NAME (type)
1028 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1029 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
1033 if (TYPE_SYMTAB_ADDRESS (type) == 0)
1035 /* Type has no dbx number assigned. Assign next available number. */
1036 TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
1038 /* Make sure type vector is long enough to record about this type. */
1040 if (next_type_number == typevec_len)
1043 = (struct typeinfo *) xrealloc (typevec,
1044 typevec_len * 2 * sizeof typevec[0]);
1045 bzero ((char *) (typevec + typevec_len),
1046 typevec_len * sizeof typevec[0]);
1050 #ifdef DBX_USE_BINCL
1051 typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
1052 = current_file->file_number;
1053 typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
1054 = current_file->next_type_number++;
1058 /* Output the number of this type, to refer to it. */
1059 dbxout_type_index (type);
1061 #ifdef DBX_TYPE_DEFINED
1062 if (DBX_TYPE_DEFINED (type))
1066 /* If this type's definition has been output or is now being output,
1069 switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
1074 /* If we have already had a cross reference,
1075 and either that's all we want or that's the best we could do,
1076 don't repeat the cross reference.
1077 Sun dbx crashes if we do. */
1078 if (! full || TYPE_SIZE (type) == 0
1079 /* No way in DBX fmt to describe a variable size. */
1080 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1088 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1089 leave the type-number completely undefined rather than output
1090 a cross-reference. If we have already used GNU debug info extensions,
1091 then it is OK to output a cross reference. This is necessary to get
1092 proper C++ debug output. */
1093 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
1094 || TREE_CODE (type) == QUAL_UNION_TYPE
1095 || TREE_CODE (type) == ENUMERAL_TYPE)
1096 && ! use_gnu_debug_info_extensions)
1097 /* We must use the same test here as we use twice below when deciding
1098 whether to emit a cross-reference. */
1099 if ((TYPE_NAME (type) != 0
1100 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1101 && DECL_IGNORED_P (TYPE_NAME (type)))
1103 || TYPE_SIZE (type) == 0
1104 /* No way in DBX fmt to describe a variable size. */
1105 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1107 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1112 /* Output a definition now. */
1114 fprintf (asmfile, "=");
1117 /* Mark it as defined, so that if it is self-referent
1118 we will not get into an infinite recursion of definitions. */
1120 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
1122 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1123 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1125 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0, 0);
1129 switch (TREE_CODE (type))
1133 /* For a void type, just define it as itself; ie, "5=5".
1134 This makes us consider it defined
1135 without saying what it is. The debugger will make it
1136 a void type when the reference is seen, and nothing will
1137 ever override that default. */
1138 dbxout_type_index (type);
1142 if (type == char_type_node && ! TREE_UNSIGNED (type))
1144 /* Output the type `char' as a subrange of itself!
1145 I don't understand this definition, just copied it
1146 from the output of pcc.
1147 This used to use `r2' explicitly and we used to
1148 take care to make sure that `char' was type number 2. */
1149 fprintf (asmfile, "r");
1150 dbxout_type_index (type);
1151 fprintf (asmfile, ";0;127;");
1153 /* This used to check if the type's precision was more than
1154 HOST_BITS_PER_WIDE_INT. That is wrong since gdb uses a
1155 long (it has no concept of HOST_BITS_PER_WIDE_INT). */
1156 else if (use_gnu_debug_info_extensions
1157 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
1158 || TYPE_PRECISION (type) >= HOST_BITS_PER_LONG))
1160 /* This used to say `r1' and we used to take care
1161 to make sure that `int' was type number 1. */
1162 fprintf (asmfile, "r");
1163 dbxout_type_index (integer_type_node);
1164 fprintf (asmfile, ";");
1165 print_int_cst_octal (TYPE_MIN_VALUE (type));
1166 fprintf (asmfile, ";");
1167 print_int_cst_octal (TYPE_MAX_VALUE (type));
1168 fprintf (asmfile, ";");
1170 else /* Output other integer types as subranges of `int'. */
1171 dbxout_range_type (type);
1176 /* This used to say `r1' and we used to take care
1177 to make sure that `int' was type number 1. */
1178 fprintf (asmfile, "r");
1179 dbxout_type_index (integer_type_node);
1180 fputc (';', asmfile);
1181 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, int_size_in_bytes (type));
1182 fputs (";0;", asmfile);
1187 if (use_gnu_debug_info_extensions)
1189 fputs ("@s", asmfile);
1190 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1191 BITS_PER_UNIT * int_size_in_bytes (type));
1192 fputs (";-20;", asmfile);
1196 /* Output the type `char' as a subrange of itself.
1197 That is what pcc seems to do. */
1198 fprintf (asmfile, "r");
1199 dbxout_type_index (char_type_node);
1200 fprintf (asmfile, ";0;%d;", TREE_UNSIGNED (type) ? 255 : 127);
1206 if (use_gnu_debug_info_extensions)
1208 fputs ("@s", asmfile);
1209 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1210 BITS_PER_UNIT * int_size_in_bytes (type));
1211 fputs (";-16;", asmfile);
1213 else /* Define as enumeral type (False, True) */
1214 fprintf (asmfile, "eFalse:0,True:1,;");
1219 putc ('d', asmfile);
1221 dbxout_type (TREE_TYPE (type), 0, 0);
1225 /* Differs from the REAL_TYPE by its new data type number */
1227 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1229 fprintf (asmfile, "r");
1230 dbxout_type_index (type);
1231 fputc (';', asmfile);
1232 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1233 int_size_in_bytes (TREE_TYPE (type)));
1234 fputs (";0;", asmfile);
1235 CHARS (12); /* The number is probably incorrect here. */
1239 /* Output a complex integer type as a structure,
1240 pending some other way to do it. */
1241 fputc ('s', asmfile);
1242 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, int_size_in_bytes (type));
1244 fprintf (asmfile, "real:");
1246 dbxout_type (TREE_TYPE (type), 0, 0);
1247 fprintf (asmfile, ",%d,%d;",
1248 0, TYPE_PRECISION (TREE_TYPE (type)));
1250 fprintf (asmfile, "imag:");
1252 dbxout_type (TREE_TYPE (type), 0, 0);
1253 fprintf (asmfile, ",%d,%d;;",
1254 TYPE_PRECISION (TREE_TYPE (type)),
1255 TYPE_PRECISION (TREE_TYPE (type)));
1261 if (use_gnu_debug_info_extensions)
1263 have_used_extensions = 1;
1264 fputs ("@s", asmfile);
1265 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1266 BITS_PER_UNIT * int_size_in_bytes (type));
1267 fputc (';', asmfile);
1268 /* Check if a bitstring type, which in Chill is
1269 different from a [power]set. */
1270 if (TYPE_STRING_FLAG (type))
1271 fprintf (asmfile, "@S;");
1273 putc ('S', asmfile);
1275 dbxout_type (TYPE_DOMAIN (type), 0, 0);
1279 /* Make arrays of packed bits look like bitstrings for chill. */
1280 if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
1282 have_used_extensions = 1;
1283 fputs ("@s", asmfile);
1284 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1285 BITS_PER_UNIT * int_size_in_bytes (type));
1286 fputc (';', asmfile);
1287 fprintf (asmfile, "@S;");
1288 putc ('S', asmfile);
1290 dbxout_type (TYPE_DOMAIN (type), 0, 0);
1293 /* Output "a" followed by a range type definition
1294 for the index type of the array
1295 followed by a reference to the target-type.
1296 ar1;0;N;M for a C array of type M and size N+1. */
1297 /* Check if a character string type, which in Chill is
1298 different from an array of characters. */
1299 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
1301 have_used_extensions = 1;
1302 fprintf (asmfile, "@S;");
1304 tem = TYPE_DOMAIN (type);
1307 fprintf (asmfile, "ar");
1308 dbxout_type_index (integer_type_node);
1309 fprintf (asmfile, ";0;-1;");
1313 fprintf (asmfile, "a");
1314 dbxout_range_type (tem);
1317 dbxout_type (TREE_TYPE (type), 0, 0);
1322 case QUAL_UNION_TYPE:
1324 int i, n_baseclasses = 0;
1326 if (TYPE_BINFO (type) != 0
1327 && TREE_CODE (TYPE_BINFO (type)) == TREE_VEC
1328 && TYPE_BINFO_BASETYPES (type) != 0)
1329 n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
1331 /* Output a structure type. We must use the same test here as we
1332 use in the DBX_NO_XREFS case above. */
1333 if ((TYPE_NAME (type) != 0
1334 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1335 && DECL_IGNORED_P (TYPE_NAME (type)))
1337 || TYPE_SIZE (type) == 0
1338 /* No way in DBX fmt to describe a variable size. */
1339 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1341 /* If the type is just a cross reference, output one
1342 and mark the type as partially described.
1343 If it later becomes defined, we will output
1344 its real definition.
1345 If the type has a name, don't nest its definition within
1346 another type's definition; instead, output an xref
1347 and let the definition come when the name is defined. */
1348 fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
1350 #if 0 /* This assertion is legitimately false in C++. */
1351 /* We shouldn't be outputting a reference to a type before its
1352 definition unless the type has a tag name.
1353 A typedef name without a tag name should be impossible. */
1354 if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
1357 if (TYPE_NAME (type) != 0)
1358 dbxout_type_name (type);
1360 fprintf (asmfile, "$$%d", anonymous_type_number++);
1361 fprintf (asmfile, ":");
1362 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1366 /* Identify record or union, and print its size. */
1367 fputc (((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'), asmfile);
1368 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1369 int_size_in_bytes (type));
1371 if (use_gnu_debug_info_extensions)
1375 have_used_extensions = 1;
1376 fprintf (asmfile, "!%d,", n_baseclasses);
1380 for (i = 0; i < n_baseclasses; i++)
1382 tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i);
1383 if (use_gnu_debug_info_extensions)
1385 have_used_extensions = 1;
1386 putc (TREE_VIA_VIRTUAL (child) ? '1'
1389 putc (TREE_VIA_PUBLIC (child) ? '2'
1392 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1393 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT);
1394 fputc (',', asmfile);
1396 dbxout_type (BINFO_TYPE (child), 0, 0);
1397 putc (';', asmfile);
1401 /* Print out the base class information with fields
1402 which have the same names at the types they hold. */
1403 dbxout_type_name (BINFO_TYPE (child));
1404 putc (':', asmfile);
1405 dbxout_type (BINFO_TYPE (child), full, 0);
1406 fputc (',', asmfile);
1407 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1408 TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT);
1409 fputc (',', asmfile);
1410 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1411 TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child)))) * BITS_PER_UNIT);
1412 fputc (';', asmfile);
1420 /* Write out the field declarations. */
1421 dbxout_type_fields (type);
1422 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
1424 have_used_extensions = 1;
1425 dbxout_type_methods (type);
1427 putc (';', asmfile);
1429 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
1430 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1431 && TYPE_VFIELD (type))
1433 have_used_extensions = 1;
1435 /* Tell GDB+ that it may keep reading. */
1436 putc ('~', asmfile);
1438 /* We need to write out info about what field this class
1439 uses as its "main" vtable pointer field, because if this
1440 field is inherited from a base class, GDB cannot necessarily
1441 figure out which field it's using in time. */
1442 if (TYPE_VFIELD (type))
1444 putc ('%', asmfile);
1445 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0, 0);
1447 putc (';', asmfile);
1453 /* We must use the same test here as we use in the DBX_NO_XREFS case
1454 above. We simplify it a bit since an enum will never have a variable
1456 if ((TYPE_NAME (type) != 0
1457 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1458 && DECL_IGNORED_P (TYPE_NAME (type)))
1460 || TYPE_SIZE (type) == 0)
1462 fprintf (asmfile, "xe");
1464 dbxout_type_name (type);
1465 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1466 fprintf (asmfile, ":");
1469 #ifdef DBX_OUTPUT_ENUM
1470 DBX_OUTPUT_ENUM (asmfile, type);
1472 if (use_gnu_debug_info_extensions
1473 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1474 fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
1475 putc ('e', asmfile);
1477 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
1479 fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1480 if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
1481 fprintf (asmfile, HOST_WIDE_INT_PRINT_UNSIGNED,
1482 TREE_INT_CST_LOW (TREE_VALUE (tem)));
1483 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
1484 && TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
1485 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
1486 TREE_INT_CST_LOW (TREE_VALUE (tem)));
1488 print_int_cst_octal (TREE_VALUE (tem));
1489 fprintf (asmfile, ",");
1490 CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem)));
1491 if (TREE_CHAIN (tem) != 0)
1496 putc (';', asmfile);
1502 putc ('*', asmfile);
1504 dbxout_type (TREE_TYPE (type), 0, 0);
1508 if (use_gnu_debug_info_extensions)
1510 have_used_extensions = 1;
1511 putc ('#', asmfile);
1513 if (flag_minimal_debug && !show_arg_types)
1515 /* Normally, just output the return type.
1516 The argument types are encoded in the method name. */
1517 putc ('#', asmfile);
1519 dbxout_type (TREE_TYPE (type), 0, 0);
1520 putc (';', asmfile);
1525 /* When outputting destructors, we need to write
1526 the argument types out longhand. */
1527 dbxout_type (TYPE_METHOD_BASETYPE (type), 0, 0);
1528 putc (',', asmfile);
1530 dbxout_type (TREE_TYPE (type), 0, 0);
1531 dbxout_args (TYPE_ARG_TYPES (type));
1532 putc (';', asmfile);
1538 /* Treat it as a function type. */
1539 dbxout_type (TREE_TYPE (type), 0, 0);
1544 if (use_gnu_debug_info_extensions)
1546 have_used_extensions = 1;
1547 putc ('@', asmfile);
1549 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0, 0);
1550 putc (',', asmfile);
1552 dbxout_type (TREE_TYPE (type), 0, 0);
1556 /* Should print as an int, because it is really
1558 dbxout_type (integer_type_node, 0, 0);
1562 case REFERENCE_TYPE:
1563 if (use_gnu_debug_info_extensions)
1564 have_used_extensions = 1;
1565 putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
1567 dbxout_type (TREE_TYPE (type), 0, 0);
1571 putc ('f', asmfile);
1573 dbxout_type (TREE_TYPE (type), 0, 0);
1581 /* Print the value of integer constant C, in octal,
1582 handling double precision. */
1585 print_int_cst_octal (c)
1588 unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
1589 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
1590 int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
1591 int width = TYPE_PRECISION (TREE_TYPE (c));
1593 /* GDB wants constants with no extra leading "1" bits, so
1594 we need to remove any sign-extension that might be
1596 if (width == HOST_BITS_PER_WIDE_INT * 2)
1598 else if (width > HOST_BITS_PER_WIDE_INT)
1599 high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
1600 else if (width == HOST_BITS_PER_WIDE_INT)
1603 high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
1605 fprintf (asmfile, "0");
1609 print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
1610 print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
1614 unsigned HOST_WIDE_INT beg = high >> excess;
1615 unsigned HOST_WIDE_INT middle
1616 = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
1617 | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
1618 unsigned HOST_WIDE_INT end
1619 = low & (((unsigned HOST_WIDE_INT) 1
1620 << (HOST_BITS_PER_WIDE_INT / 3 * 3))
1623 fprintf (asmfile, "%o%01o", (int)beg, (int)middle);
1624 print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
1629 print_octal (value, digits)
1630 unsigned HOST_WIDE_INT value;
1635 for (i = digits - 1; i >= 0; i--)
1636 fprintf (asmfile, "%01o", (int)((value >> (3 * i)) & 7));
1639 /* Output the name of type TYPE, with no punctuation.
1640 Such names can be set up either by typedef declarations
1641 or by struct, enum and union tags. */
1644 dbxout_type_name (type)
1648 if (TYPE_NAME (type) == 0)
1650 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
1652 t = TYPE_NAME (type);
1654 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1656 t = DECL_NAME (TYPE_NAME (type));
1661 fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
1662 CHARS (IDENTIFIER_LENGTH (t));
1665 /* Output a .stabs for the symbol defined by DECL,
1666 which must be a ..._DECL node in the normal namespace.
1667 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
1668 LOCAL is nonzero if the scope is less than the entire file. */
1671 dbxout_symbol (decl, local)
1675 tree type = TREE_TYPE (decl);
1676 tree context = NULL_TREE;
1678 /* Cast avoids warning in old compilers. */
1679 current_sym_code = (STAB_CODE_TYPE) 0;
1680 current_sym_value = 0;
1681 current_sym_addr = 0;
1683 /* Ignore nameless syms, but don't ignore type tags. */
1685 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
1686 || DECL_IGNORED_P (decl))
1689 dbxout_prepare_symbol (decl);
1691 /* The output will always start with the symbol name,
1692 so always count that in the length-output-so-far. */
1694 if (DECL_NAME (decl) != 0)
1695 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
1697 switch (TREE_CODE (decl))
1700 /* Enum values are defined by defining the enum type. */
1704 if (DECL_RTL (decl) == 0)
1706 if (DECL_EXTERNAL (decl))
1708 /* Don't mention a nested function under its parent. */
1709 context = decl_function_context (decl);
1710 if (context == current_function_decl)
1712 if (GET_CODE (DECL_RTL (decl)) != MEM
1713 || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
1717 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
1718 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1719 TREE_PUBLIC (decl) ? 'F' : 'f');
1721 current_sym_code = N_FUN;
1722 current_sym_addr = XEXP (DECL_RTL (decl), 0);
1724 if (TREE_TYPE (type))
1725 dbxout_type (TREE_TYPE (type), 0, 0);
1727 dbxout_type (void_type_node, 0, 0);
1729 /* For a nested function, when that function is compiled,
1730 mention the containing function name
1731 as well as (since dbx wants it) our own assembler-name. */
1733 fprintf (asmfile, ",%s,%s",
1734 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
1735 IDENTIFIER_POINTER (DECL_NAME (context)));
1737 dbxout_finish_symbol (decl);
1742 /* This seems all wrong. Outputting most kinds of types gives no name
1743 at all. A true definition gives no name; a cross-ref for a
1744 structure can give the tag name, but not a type name.
1745 It seems that no typedef name is defined by outputting a type. */
1747 /* If this typedef name was defined by outputting the type,
1748 don't duplicate it. */
1749 if (typevec[TYPE_SYMTAB_ADDRESS (type)].status == TYPE_DEFINED
1750 && TYPE_NAME (TREE_TYPE (decl)) == decl)
1753 /* Don't output the same typedef twice.
1754 And don't output what language-specific stuff doesn't want output. */
1755 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
1764 if (DECL_NAME (decl))
1766 /* Nonzero means we must output a tag as well as a typedef. */
1769 /* Handle the case of a C++ structure or union
1770 where the TYPE_NAME is a TYPE_DECL
1771 which gives both a typedef name and a tag. */
1772 /* dbx requires the tag first and the typedef second. */
1773 if ((TREE_CODE (type) == RECORD_TYPE
1774 || TREE_CODE (type) == UNION_TYPE
1775 || TREE_CODE (type) == QUAL_UNION_TYPE)
1776 && TYPE_NAME (type) == decl
1777 && !(use_gnu_debug_info_extensions && have_used_extensions)
1778 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
1779 /* Distinguish the implicit typedefs of C++
1780 from explicit ones that might be found in C. */
1781 && DECL_ARTIFICIAL (decl))
1783 tree name = TYPE_NAME (type);
1784 if (TREE_CODE (name) == TYPE_DECL)
1785 name = DECL_NAME (name);
1787 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1788 current_sym_value = 0;
1789 current_sym_addr = 0;
1790 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1792 fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP,
1793 IDENTIFIER_POINTER (name));
1794 dbxout_type (type, 1, 0);
1795 dbxout_finish_symbol (NULL_TREE);
1798 /* Output typedef name. */
1799 fprintf (asmfile, "%s \"%s:", ASM_STABS_OP,
1800 IDENTIFIER_POINTER (DECL_NAME (decl)));
1802 /* Short cut way to output a tag also. */
1803 if ((TREE_CODE (type) == RECORD_TYPE
1804 || TREE_CODE (type) == UNION_TYPE
1805 || TREE_CODE (type) == QUAL_UNION_TYPE)
1806 && TYPE_NAME (type) == decl
1807 /* Distinguish the implicit typedefs of C++
1808 from explicit ones that might be found in C. */
1809 && DECL_ARTIFICIAL (decl))
1811 if (use_gnu_debug_info_extensions && have_used_extensions)
1813 putc ('T', asmfile);
1814 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
1816 #if 0 /* Now we generate the tag for this case up above. */
1822 putc ('t', asmfile);
1823 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1825 dbxout_type (type, 1, 0);
1826 dbxout_finish_symbol (decl);
1830 /* Don't output a tag if this is an incomplete type (TYPE_SIZE is
1831 zero). This prevents the sun4 Sun OS 4.x dbx from crashing. */
1833 if (tag_needed && TYPE_NAME (type) != 0
1834 && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
1835 || (DECL_NAME (TYPE_NAME (type)) != 0))
1836 && TYPE_SIZE (type) != 0
1837 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
1839 /* For a TYPE_DECL with no name, but the type has a name,
1841 This is what represents `struct foo' with no typedef. */
1842 /* In C++, the name of a type is the corresponding typedef.
1843 In C, it is an IDENTIFIER_NODE. */
1844 tree name = TYPE_NAME (type);
1845 if (TREE_CODE (name) == TYPE_DECL)
1846 name = DECL_NAME (name);
1848 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1849 current_sym_value = 0;
1850 current_sym_addr = 0;
1851 current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
1853 fprintf (asmfile, "%s \"%s:T", ASM_STABS_OP,
1854 IDENTIFIER_POINTER (name));
1855 dbxout_type (type, 1, 0);
1856 dbxout_finish_symbol (NULL_TREE);
1860 /* If an enum type has no name, it cannot be referred to,
1861 but we must output it anyway, since the enumeration constants
1862 can be referred to. */
1863 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
1865 current_sym_code = DBX_TYPE_DECL_STABS_CODE;
1866 current_sym_value = 0;
1867 current_sym_addr = 0;
1868 current_sym_nchars = 2;
1870 /* Some debuggers fail when given NULL names, so give this a
1871 harmless name of ` '. */
1872 fprintf (asmfile, "%s \" :T", ASM_STABS_OP);
1873 dbxout_type (type, 1, 0);
1874 dbxout_finish_symbol (NULL_TREE);
1877 /* Prevent duplicate output of a typedef. */
1878 TREE_ASM_WRITTEN (decl) = 1;
1883 /* Parm decls go in their own separate chains
1884 and are output by dbxout_reg_parms and dbxout_parms. */
1888 /* Named return value, treat like a VAR_DECL. */
1890 if (DECL_RTL (decl) == 0)
1892 /* Don't mention a variable that is external.
1893 Let the file that defines it describe it. */
1894 if (DECL_EXTERNAL (decl))
1897 /* If the variable is really a constant
1898 and not written in memory, inform the debugger. */
1899 if (TREE_STATIC (decl) && TREE_READONLY (decl)
1900 && DECL_INITIAL (decl) != 0
1901 && ! TREE_ASM_WRITTEN (decl)
1902 && (DECL_FIELD_CONTEXT (decl) == NULL_TREE
1903 || TREE_CODE (DECL_FIELD_CONTEXT (decl)) == BLOCK))
1905 if (TREE_PUBLIC (decl) == 0)
1907 /* The sun4 assembler does not grok this. */
1908 char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
1909 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
1910 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
1912 HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl));
1913 #ifdef DBX_OUTPUT_CONSTANT_SYMBOL
1914 DBX_OUTPUT_CONSTANT_SYMBOL (asmfile, name, ival);
1916 fprintf (asmfile, "%s \"%s:c=i", ASM_STABS_OP, name);
1918 fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, ival);
1919 fprintf (asmfile, "\",0x%x,0,0,0\n", N_LSYM);
1923 else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
1925 /* don't know how to do this yet. */
1929 /* else it is something we handle like a normal variable. */
1932 DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, NULL_RTX);
1933 #ifdef LEAF_REG_REMAP
1935 leaf_renumber_regs_insn (DECL_RTL (decl));
1938 dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
1946 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
1947 Add SUFFIX to its name, if SUFFIX is not 0.
1948 Describe the variable as residing in HOME
1949 (usually HOME is DECL_RTL (DECL), but not always). */
1952 dbxout_symbol_location (decl, type, suffix, home)
1960 /* Don't mention a variable at all
1961 if it was completely optimized into nothingness.
1963 If the decl was from an inline function, then it's rtl
1964 is not identically the rtl that was used in this
1965 particular compilation. */
1966 if (GET_CODE (home) == REG)
1968 regno = REGNO (home);
1969 if (regno >= FIRST_PSEUDO_REGISTER)
1972 else if (GET_CODE (home) == SUBREG)
1976 while (GET_CODE (value) == SUBREG)
1978 offset += SUBREG_WORD (value);
1979 value = SUBREG_REG (value);
1981 if (GET_CODE (value) == REG)
1983 regno = REGNO (value);
1984 if (regno >= FIRST_PSEUDO_REGISTER)
1988 alter_subreg (home);
1991 /* The kind-of-variable letter depends on where
1992 the variable is and on the scope of its name:
1993 G and N_GSYM for static storage and global scope,
1994 S for static storage and file scope,
1995 V for static storage and local scope,
1996 for those two, use N_LCSYM if data is in bss segment,
1997 N_STSYM if in data segment, N_FUN otherwise.
1998 (We used N_FUN originally, then changed to N_STSYM
1999 to please GDB. However, it seems that confused ld.
2000 Now GDB has been fixed to like N_FUN, says Kingdon.)
2001 no letter at all, and N_LSYM, for auto variable,
2002 r and N_RSYM for register variable. */
2004 if (GET_CODE (home) == MEM
2005 && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
2007 if (TREE_PUBLIC (decl))
2010 current_sym_code = N_GSYM;
2014 current_sym_addr = XEXP (home, 0);
2016 letter = decl_function_context (decl) ? 'V' : 'S';
2018 /* This should be the same condition as in assemble_variable, but
2019 we don't have access to dont_output_data here. So, instead,
2020 we rely on the fact that error_mark_node initializers always
2021 end up in bss for C++ and never end up in bss for C. */
2022 if (DECL_INITIAL (decl) == 0
2023 || (!strcmp (lang_identify (), "cplusplus")
2024 && DECL_INITIAL (decl) == error_mark_node))
2025 current_sym_code = N_LCSYM;
2026 else if (DECL_IN_TEXT_SECTION (decl))
2027 /* This is not quite right, but it's the closest
2028 of all the codes that Unix defines. */
2029 current_sym_code = DBX_STATIC_CONST_VAR_CODE;
2032 /* Ultrix `as' seems to need this. */
2033 #ifdef DBX_STATIC_STAB_DATA_SECTION
2036 current_sym_code = N_STSYM;
2040 else if (regno >= 0)
2043 current_sym_code = N_RSYM;
2044 current_sym_value = DBX_REGISTER_NUMBER (regno);
2046 else if (GET_CODE (home) == MEM
2047 && (GET_CODE (XEXP (home, 0)) == MEM
2048 || (GET_CODE (XEXP (home, 0)) == REG
2049 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
2050 && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
2051 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2052 && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
2055 /* If the value is indirect by memory or by a register
2056 that isn't the frame pointer
2057 then it means the object is variable-sized and address through
2058 that register or stack slot. DBX has no way to represent this
2059 so all we can do is output the variable as a pointer.
2060 If it's not a parameter, ignore it.
2061 (VAR_DECLs like this can be made by integrate.c.) */
2063 if (GET_CODE (XEXP (home, 0)) == REG)
2066 current_sym_code = N_RSYM;
2067 current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
2071 current_sym_code = N_LSYM;
2072 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2073 We want the value of that CONST_INT. */
2075 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
2078 /* Effectively do build_pointer_type, but don't cache this type,
2079 since it might be temporary whereas the type it points to
2080 might have been saved for inlining. */
2081 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2082 type = make_node (POINTER_TYPE);
2083 TREE_TYPE (type) = TREE_TYPE (decl);
2085 else if (GET_CODE (home) == MEM
2086 && GET_CODE (XEXP (home, 0)) == REG)
2088 current_sym_code = N_LSYM;
2089 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2091 else if (GET_CODE (home) == MEM
2092 && GET_CODE (XEXP (home, 0)) == PLUS
2093 && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
2095 current_sym_code = N_LSYM;
2096 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2097 We want the value of that CONST_INT. */
2098 current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2100 else if (GET_CODE (home) == MEM
2101 && GET_CODE (XEXP (home, 0)) == CONST)
2103 /* Handle an obscure case which can arise when optimizing and
2104 when there are few available registers. (This is *always*
2105 the case for i386/i486 targets). The RTL looks like
2106 (MEM (CONST ...)) even though this variable is a local `auto'
2107 or a local `register' variable. In effect, what has happened
2108 is that the reload pass has seen that all assignments and
2109 references for one such a local variable can be replaced by
2110 equivalent assignments and references to some static storage
2111 variable, thereby avoiding the need for a register. In such
2112 cases we're forced to lie to debuggers and tell them that
2113 this variable was itself `static'. */
2114 current_sym_code = N_LCSYM;
2116 current_sym_addr = XEXP (XEXP (home, 0), 0);
2118 else if (GET_CODE (home) == CONCAT)
2120 tree subtype = TREE_TYPE (type);
2122 /* If the variable's storage is in two parts,
2123 output each as a separate stab with a modified name. */
2124 if (WORDS_BIG_ENDIAN)
2125 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
2127 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
2129 /* Cast avoids warning in old compilers. */
2130 current_sym_code = (STAB_CODE_TYPE) 0;
2131 current_sym_value = 0;
2132 current_sym_addr = 0;
2133 dbxout_prepare_symbol (decl);
2135 if (WORDS_BIG_ENDIAN)
2136 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
2138 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
2142 /* Address might be a MEM, when DECL is a variable-sized object.
2143 Or it might be const0_rtx, meaning previous passes
2144 want us to ignore this variable. */
2147 /* Ok, start a symtab entry and output the variable name. */
2150 #ifdef DBX_STATIC_BLOCK_START
2151 DBX_STATIC_BLOCK_START (asmfile, current_sym_code);
2154 dbxout_symbol_name (decl, suffix, letter);
2155 dbxout_type (type, 0, 0);
2156 dbxout_finish_symbol (decl);
2158 #ifdef DBX_STATIC_BLOCK_END
2159 DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
2163 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2164 Then output LETTER to indicate the kind of location the symbol has. */
2167 dbxout_symbol_name (decl, suffix, letter)
2172 /* One slight hitch: if this is a VAR_DECL which is a static
2173 class member, we must put out the mangled name instead of the
2174 DECL_NAME. Note also that static member (variable) names DO NOT begin
2175 with underscores in .stabs directives. */
2176 char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2179 fprintf (asmfile, "%s \"%s%s:", ASM_STABS_OP, name,
2180 (suffix ? suffix : ""));
2182 if (letter) putc (letter, asmfile);
2186 dbxout_prepare_symbol (decl)
2190 char *filename = DECL_SOURCE_FILE (decl);
2192 dbxout_source_file (asmfile, filename);
2197 dbxout_finish_symbol (sym)
2200 #ifdef DBX_FINISH_SYMBOL
2201 DBX_FINISH_SYMBOL (sym);
2204 if (use_gnu_debug_info_extensions && sym != 0)
2205 line = DECL_SOURCE_LINE (sym);
2207 fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line);
2208 if (current_sym_addr)
2209 output_addr_const (asmfile, current_sym_addr);
2211 fprintf (asmfile, "%d", current_sym_value);
2212 putc ('\n', asmfile);
2216 /* Output definitions of all the decls in a chain. */
2224 dbxout_symbol (syms, 1);
2225 syms = TREE_CHAIN (syms);
2229 /* The following two functions output definitions of function parameters.
2230 Each parameter gets a definition locating it in the parameter list.
2231 Each parameter that is a register variable gets a second definition
2232 locating it in the register.
2234 Printing or argument lists in gdb uses the definitions that
2235 locate in the parameter list. But reference to the variable in
2236 expressions uses preferentially the definition as a register. */
2238 /* Output definitions, referring to storage in the parmlist,
2239 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2242 dbxout_parms (parms)
2245 for (; parms; parms = TREE_CHAIN (parms))
2246 if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node)
2248 dbxout_prepare_symbol (parms);
2250 /* Perform any necessary register eliminations on the parameter's rtl,
2251 so that the debugging output will be accurate. */
2252 DECL_INCOMING_RTL (parms)
2253 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
2254 DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX);
2255 #ifdef LEAF_REG_REMAP
2258 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
2259 leaf_renumber_regs_insn (DECL_RTL (parms));
2263 if (PARM_PASSED_IN_MEMORY (parms))
2265 rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
2267 /* ??? Here we assume that the parm address is indexed
2268 off the frame pointer or arg pointer.
2269 If that is not true, we produce meaningless results,
2270 but do not crash. */
2271 if (GET_CODE (addr) == PLUS
2272 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
2273 current_sym_value = INTVAL (XEXP (addr, 1));
2275 current_sym_value = 0;
2277 current_sym_code = N_PSYM;
2278 current_sym_addr = 0;
2281 if (DECL_NAME (parms))
2283 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2285 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2286 IDENTIFIER_POINTER (DECL_NAME (parms)),
2287 DBX_MEMPARM_STABS_LETTER);
2291 current_sym_nchars = 8;
2292 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2293 DBX_MEMPARM_STABS_LETTER);
2296 /* It is quite tempting to use:
2298 dbxout_type (TREE_TYPE (parms), 0, 0);
2300 as the next statement, rather than using DECL_ARG_TYPE(), so
2301 that gcc reports the actual type of the parameter, rather
2302 than the promoted type. This certainly makes GDB's life
2303 easier, at least for some ports. The change is a bad idea
2304 however, since GDB expects to be able access the type without
2305 performing any conversions. So for example, if we were
2306 passing a float to an unprototyped function, gcc will store a
2307 double on the stack, but if we emit a stab saying the type is a
2308 float, then gdb will only read in a single value, and this will
2309 produce an erropneous value. */
2310 dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
2311 current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
2312 dbxout_finish_symbol (parms);
2314 else if (GET_CODE (DECL_RTL (parms)) == REG)
2317 char regparm_letter;
2319 /* Parm passed in registers and lives in registers or nowhere. */
2321 current_sym_code = DBX_REGPARM_STABS_CODE;
2322 regparm_letter = DBX_REGPARM_STABS_LETTER;
2323 current_sym_addr = 0;
2325 /* If parm lives in a register, use that register;
2326 pretend the parm was passed there. It would be more consistent
2327 to describe the register where the parm was passed,
2328 but in practice that register usually holds something else.
2330 If we use DECL_RTL, then we must use the declared type of
2331 the variable, not the type that it arrived in. */
2332 if (REGNO (DECL_RTL (parms)) >= 0
2333 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2335 best_rtl = DECL_RTL (parms);
2336 parm_type = TREE_TYPE (parms);
2338 /* If the parm lives nowhere, use the register where it was
2339 passed. It is also better to use the declared type here. */
2342 best_rtl = DECL_INCOMING_RTL (parms);
2343 parm_type = TREE_TYPE (parms);
2345 current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
2348 if (DECL_NAME (parms))
2350 current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
2351 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2352 IDENTIFIER_POINTER (DECL_NAME (parms)),
2357 current_sym_nchars = 8;
2358 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2362 dbxout_type (parm_type, 0, 0);
2363 dbxout_finish_symbol (parms);
2365 else if (GET_CODE (DECL_RTL (parms)) == MEM
2366 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2367 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
2368 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
2369 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2370 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
2374 /* Parm was passed via invisible reference.
2375 That is, its address was passed in a register.
2376 Output it as if it lived in that register.
2377 The debugger will know from the type
2378 that it was actually passed by invisible reference. */
2380 char regparm_letter;
2381 /* Parm passed in registers and lives in registers or nowhere. */
2383 current_sym_code = DBX_REGPARM_STABS_CODE;
2384 if (use_gnu_debug_info_extensions)
2385 regparm_letter = GDB_INV_REF_REGPARM_STABS_LETTER;
2387 regparm_letter = DBX_REGPARM_STABS_LETTER;
2389 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2390 If it is an unallocated pseudo-reg, then use the register where
2391 it was passed instead. */
2392 if (REGNO (XEXP (DECL_RTL (parms), 0)) >= 0
2393 && REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
2394 current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
2396 current_sym_value = REGNO (DECL_INCOMING_RTL (parms));
2398 current_sym_addr = 0;
2401 if (DECL_NAME (parms))
2403 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2405 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2406 IDENTIFIER_POINTER (DECL_NAME (parms)),
2411 current_sym_nchars = 8;
2412 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2416 dbxout_type (TREE_TYPE (parms), 0, 0);
2417 dbxout_finish_symbol (parms);
2419 else if (GET_CODE (DECL_RTL (parms)) == MEM
2420 && XEXP (DECL_RTL (parms), 0) != const0_rtx
2421 /* ??? A constant address for a parm can happen
2422 when the reg it lives in is equiv to a constant in memory.
2423 Should make this not happen, after 2.4. */
2424 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
2426 /* Parm was passed in registers but lives on the stack. */
2428 current_sym_code = N_PSYM;
2429 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
2430 in which case we want the value of that CONST_INT,
2431 or (MEM (REG ...)) or (MEM (MEM ...)),
2432 in which case we use a value of zero. */
2433 if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
2434 || GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
2435 current_sym_value = 0;
2437 current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
2438 current_sym_addr = 0;
2440 /* Make a big endian correction if the mode of the type of the
2441 parameter is not the same as the mode of the rtl. */
2442 if (BYTES_BIG_ENDIAN
2443 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
2444 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
2446 current_sym_value += UNITS_PER_WORD - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms)));
2450 if (DECL_NAME (parms))
2452 current_sym_nchars = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
2454 fprintf (asmfile, "%s \"%s:%c", ASM_STABS_OP,
2455 IDENTIFIER_POINTER (DECL_NAME (parms)),
2456 DBX_MEMPARM_STABS_LETTER);
2460 current_sym_nchars = 8;
2461 fprintf (asmfile, "%s \"(anon):%c", ASM_STABS_OP,
2462 DBX_MEMPARM_STABS_LETTER);
2466 = DEBUGGER_ARG_OFFSET (current_sym_value,
2467 XEXP (DECL_RTL (parms), 0));
2468 dbxout_type (TREE_TYPE (parms), 0, 0);
2469 dbxout_finish_symbol (parms);
2474 /* Output definitions for the places where parms live during the function,
2475 when different from where they were passed, when the parms were passed
2478 It is not useful to do this for parms passed in registers
2479 that live during the function in different registers, because it is
2480 impossible to look in the passed register for the passed value,
2481 so we use the within-the-function register to begin with.
2483 PARMS is a chain of PARM_DECL nodes. */
2486 dbxout_reg_parms (parms)
2489 for (; parms; parms = TREE_CHAIN (parms))
2490 if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
2492 dbxout_prepare_symbol (parms);
2494 /* Report parms that live in registers during the function
2495 but were passed in memory. */
2496 if (GET_CODE (DECL_RTL (parms)) == REG
2497 && REGNO (DECL_RTL (parms)) >= 0
2498 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
2499 dbxout_symbol_location (parms, TREE_TYPE (parms),
2500 0, DECL_RTL (parms));
2501 else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
2502 dbxout_symbol_location (parms, TREE_TYPE (parms),
2503 0, DECL_RTL (parms));
2504 /* Report parms that live in memory but not where they were passed. */
2505 else if (GET_CODE (DECL_RTL (parms)) == MEM
2506 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
2507 dbxout_symbol_location (parms, TREE_TYPE (parms),
2508 0, DECL_RTL (parms));
2512 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
2513 output definitions of those names, in raw form */
2521 putc (',', asmfile);
2522 dbxout_type (TREE_VALUE (args), 0, 0);
2524 args = TREE_CHAIN (args);
2528 /* Given a chain of ..._TYPE nodes,
2529 find those which have typedef names and output those names.
2530 This is to ensure those types get output. */
2533 dbxout_types (types)
2534 register tree types;
2538 if (TYPE_NAME (types)
2539 && TREE_CODE (TYPE_NAME (types)) == TYPE_DECL
2540 && ! TREE_ASM_WRITTEN (TYPE_NAME (types)))
2541 dbxout_symbol (TYPE_NAME (types), 1);
2542 types = TREE_CHAIN (types);
2546 /* Output everything about a symbol block (a BLOCK node
2547 that represents a scope level),
2548 including recursive output of contained blocks.
2550 BLOCK is the BLOCK node.
2551 DEPTH is its depth within containing symbol blocks.
2552 ARGS is usually zero; but for the outermost block of the
2553 body of a function, it is a chain of PARM_DECLs for the function parameters.
2554 We output definitions of all the register parms
2555 as if they were local variables of that block.
2557 If -g1 was used, we count blocks just the same, but output nothing
2558 except for the outermost block.
2560 Actually, BLOCK may be several blocks chained together.
2561 We handle them all in sequence. */
2564 dbxout_block (block, depth, args)
2565 register tree block;
2573 /* Ignore blocks never expanded or otherwise marked as real. */
2574 if (TREE_USED (block))
2576 #ifndef DBX_LBRAC_FIRST
2577 /* In dbx format, the syms of a block come before the N_LBRAC. */
2578 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2579 dbxout_syms (BLOCK_VARS (block));
2581 dbxout_reg_parms (args);
2584 /* Now output an N_LBRAC symbol to represent the beginning of
2585 the block. Use the block's tree-walk order to generate
2586 the assembler symbols LBBn and LBEn
2587 that final will define around the code in this block. */
2588 if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE)
2591 blocknum = next_block_number++;
2592 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
2594 if (BLOCK_HANDLER_BLOCK (block))
2596 /* A catch block. Must precede N_LBRAC. */
2597 tree decl = BLOCK_VARS (block);
2600 #ifdef DBX_OUTPUT_CATCH
2601 DBX_OUTPUT_CATCH (asmfile, decl, buf);
2603 fprintf (asmfile, "%s \"%s:C1\",%d,0,0,", ASM_STABS_OP,
2604 IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
2605 assemble_name (asmfile, buf);
2606 fprintf (asmfile, "\n");
2608 decl = TREE_CHAIN (decl);
2612 #ifdef DBX_OUTPUT_LBRAC
2613 DBX_OUTPUT_LBRAC (asmfile, buf);
2615 fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_LBRAC);
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 /* Count blocks the same way regardless of debug_info_level. */
2626 next_block_number++;
2628 #ifdef DBX_LBRAC_FIRST
2629 /* On some weird machines, the syms of a block
2630 come after the N_LBRAC. */
2631 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
2632 dbxout_syms (BLOCK_VARS (block));
2634 dbxout_reg_parms (args);
2637 /* Output the subblocks. */
2638 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
2640 /* Refer to the marker for the end of the block. */
2641 if (depth > 0 && debug_info_level != DINFO_LEVEL_TERSE)
2644 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
2645 #ifdef DBX_OUTPUT_RBRAC
2646 DBX_OUTPUT_RBRAC (asmfile, buf);
2648 fprintf (asmfile, "%s %d,0,0,", ASM_STABN_OP, N_RBRAC);
2649 assemble_name (asmfile, buf);
2650 #if DBX_BLOCKS_FUNCTION_RELATIVE
2651 fputc ('-', asmfile);
2652 assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
2654 fprintf (asmfile, "\n");
2658 block = BLOCK_CHAIN (block);
2662 /* Output the information about a function and its arguments and result.
2663 Usually this follows the function's code,
2664 but on some systems, it comes before. */
2667 dbxout_really_begin_function (decl)
2670 dbxout_symbol (decl, 0);
2671 dbxout_parms (DECL_ARGUMENTS (decl));
2672 if (DECL_NAME (DECL_RESULT (decl)) != 0)
2673 dbxout_symbol (DECL_RESULT (decl), 1);
2676 /* Called at beginning of output of function definition. */
2679 dbxout_begin_function (decl)
2682 #ifdef DBX_FUNCTION_FIRST
2683 dbxout_really_begin_function (decl);
2687 /* Output dbx data for a function definition.
2688 This includes a definition of the function name itself (a symbol),
2689 definitions of the parameters (locating them in the parameter list)
2690 and then output the block that makes up the function's body
2691 (including all the auto variables of the function). */
2694 dbxout_function (decl)
2697 #ifndef DBX_FUNCTION_FIRST
2698 dbxout_really_begin_function (decl);
2700 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
2701 #ifdef DBX_OUTPUT_FUNCTION_END
2702 DBX_OUTPUT_FUNCTION_END (asmfile, decl);
2704 #if defined(ASM_OUTPUT_SECTION_NAME)
2705 if (use_gnu_debug_info_extensions
2706 #if defined(NO_DBX_FUNCTION_END)
2707 && ! NO_DBX_FUNCTION_END
2710 dbxout_function_end ();
2713 #endif /* DBX_DEBUGGING_INFO */