1 /* Output sdb-format symbol table information from GNU compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 /* mike@tredysvr.Tredydev.Unisys.COM says:
23 I modified the struct.c example and have a nm of a .o resulting from the
24 AT&T C compiler. From the example below I would conclude the following:
26 1. All .defs from structures are emitted as scanned. The example below
27 clearly shows the symbol table entries for BoxRec2 are after the first
30 2. All functions and their locals (including statics) are emitted as scanned.
32 3. All nested unnamed union and structure .defs must be emitted before
33 the structure in which they are nested. The AT&T assembler is a
34 one pass beast as far as symbolics are concerned.
36 4. All structure .defs are emitted before the typedefs that refer to them.
38 5. All top level static and external variable definitions are moved to the
39 end of file with all top level statics occurring first before externs.
41 6. All undefined references are at the end of the file.
46 #include "coretypes.h"
53 static GTY(()) tree anonymous_types
;
55 /* Counter for sdbout_source_line. */
57 static GTY(()) int sdbout_source_line_counter
;
59 /* Counter to generate unique "names" for nameless struct members. */
61 static GTY(()) int unnamed_struct_number
;
63 /* Declarations whose debug info was deferred till end of compilation. */
65 static GTY(()) varray_type deferred_global_decls
;
67 /* The C front end may call sdbout_symbol before sdbout_init runs.
68 We save all such decls in this list and output them when we get
71 static GTY(()) tree preinit_symbols
;
72 static GTY(()) bool sdbout_initialized
;
74 #ifdef SDB_DEBUGGING_INFO
79 #include "insn-config.h"
85 #include "langhooks.h"
88 /* 1 if PARM is passed to this function in memory. */
90 #define PARM_PASSED_IN_MEMORY(PARM) \
91 (MEM_P (DECL_INCOMING_RTL (PARM)))
93 /* A C expression for the integer offset value of an automatic variable
94 (C_AUTO) having address X (an RTX). */
95 #ifndef DEBUGGER_AUTO_OFFSET
96 #define DEBUGGER_AUTO_OFFSET(X) \
97 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
100 /* A C expression for the integer offset value of an argument (C_ARG)
101 having address X (an RTX). The nominal offset is OFFSET. */
102 #ifndef DEBUGGER_ARG_OFFSET
103 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
106 /* Line number of beginning of current function, minus one.
107 Negative means not in a function or not using sdb. */
109 int sdb_begin_function_line
= -1;
112 extern FILE *asm_out_file
;
114 extern tree current_function_decl
;
118 static void sdbout_init (const char *);
119 static void sdbout_finish (const char *);
120 static void sdbout_start_source_file (unsigned int, const char *);
121 static void sdbout_end_source_file (unsigned int);
122 static void sdbout_begin_block (unsigned int, unsigned int);
123 static void sdbout_end_block (unsigned int, unsigned int);
124 static void sdbout_source_line (unsigned int, const char *);
125 static void sdbout_end_epilogue (unsigned int, const char *);
126 static void sdbout_global_decl (tree
);
127 #ifndef MIPS_DEBUGGING_INFO
128 static void sdbout_begin_prologue (unsigned int, const char *);
130 static void sdbout_end_prologue (unsigned int, const char *);
131 static void sdbout_begin_function (tree
);
132 static void sdbout_end_function (unsigned int);
133 static void sdbout_toplevel_data (tree
);
134 static void sdbout_label (rtx
);
135 static char *gen_fake_label (void);
136 static int plain_type (tree
);
137 static int template_name_p (tree
);
138 static void sdbout_record_type_name (tree
);
139 static int plain_type_1 (tree
, int);
140 static void sdbout_block (tree
);
141 static void sdbout_syms (tree
);
142 #ifdef SDB_ALLOW_FORWARD_REFERENCES
143 static void sdbout_queue_anonymous_type (tree
);
144 static void sdbout_dequeue_anonymous_types (void);
146 static void sdbout_type (tree
);
147 static void sdbout_field_types (tree
);
148 static void sdbout_one_type (tree
);
149 static void sdbout_parms (tree
);
150 static void sdbout_reg_parms (tree
);
151 static void sdbout_global_decl (tree
);
153 /* Random macros describing parts of SDB data. */
155 /* Default value of delimiter is ";". */
157 #define SDB_DELIM ";"
160 /* Maximum number of dimensions the assembler will allow. */
162 #define SDB_MAX_DIM 4
166 #define PUT_SDB_SCL(a) fprintf(asm_out_file, "\t.scl\t%d%s", (a), SDB_DELIM)
169 #ifndef PUT_SDB_INT_VAL
170 #define PUT_SDB_INT_VAL(a) \
172 fprintf (asm_out_file, "\t.val\t" HOST_WIDE_INT_PRINT_DEC "%s", \
173 (HOST_WIDE_INT) (a), SDB_DELIM); \
179 #define PUT_SDB_VAL(a) \
180 ( fputs ("\t.val\t", asm_out_file), \
181 output_addr_const (asm_out_file, (a)), \
182 fprintf (asm_out_file, SDB_DELIM))
186 #define PUT_SDB_DEF(a) \
187 do { fprintf (asm_out_file, "\t.def\t"); \
188 assemble_name (asm_out_file, a); \
189 fprintf (asm_out_file, SDB_DELIM); } while (0)
192 #ifndef PUT_SDB_PLAIN_DEF
193 #define PUT_SDB_PLAIN_DEF(a) fprintf(asm_out_file,"\t.def\t.%s%s",a, SDB_DELIM)
196 #ifndef PUT_SDB_ENDEF
197 #define PUT_SDB_ENDEF fputs("\t.endef\n", asm_out_file)
201 #define PUT_SDB_TYPE(a) fprintf(asm_out_file, "\t.type\t0%o%s", a, SDB_DELIM)
205 #define PUT_SDB_SIZE(a) \
207 fprintf (asm_out_file, "\t.size\t" HOST_WIDE_INT_PRINT_DEC "%s", \
208 (HOST_WIDE_INT) (a), SDB_DELIM); \
212 #ifndef PUT_SDB_START_DIM
213 #define PUT_SDB_START_DIM fprintf(asm_out_file, "\t.dim\t")
216 #ifndef PUT_SDB_NEXT_DIM
217 #define PUT_SDB_NEXT_DIM(a) fprintf(asm_out_file, "%d,", a)
220 #ifndef PUT_SDB_LAST_DIM
221 #define PUT_SDB_LAST_DIM(a) fprintf(asm_out_file, "%d%s", a, SDB_DELIM)
225 #define PUT_SDB_TAG(a) \
226 do { fprintf (asm_out_file, "\t.tag\t"); \
227 assemble_name (asm_out_file, a); \
228 fprintf (asm_out_file, SDB_DELIM); } while (0)
231 #ifndef PUT_SDB_BLOCK_START
232 #define PUT_SDB_BLOCK_START(LINE) \
233 fprintf (asm_out_file, \
234 "\t.def\t.bb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n", \
235 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
238 #ifndef PUT_SDB_BLOCK_END
239 #define PUT_SDB_BLOCK_END(LINE) \
240 fprintf (asm_out_file, \
241 "\t.def\t.eb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n", \
242 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
245 #ifndef PUT_SDB_FUNCTION_START
246 #define PUT_SDB_FUNCTION_START(LINE) \
247 fprintf (asm_out_file, \
248 "\t.def\t.bf%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \
249 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
252 #ifndef PUT_SDB_FUNCTION_END
253 #define PUT_SDB_FUNCTION_END(LINE) \
254 fprintf (asm_out_file, \
255 "\t.def\t.ef%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \
256 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
259 #ifndef SDB_GENERATE_FAKE
260 #define SDB_GENERATE_FAKE(BUFFER, NUMBER) \
261 sprintf ((BUFFER), ".%dfake", (NUMBER));
264 /* Return the sdb tag identifier string for TYPE
265 if TYPE has already been defined; otherwise return a null pointer. */
267 #define KNOWN_TYPE_TAG(type) TYPE_SYMTAB_POINTER (type)
269 /* Set the sdb tag identifier string for TYPE to NAME. */
271 #define SET_KNOWN_TYPE_TAG(TYPE, NAME) \
272 TYPE_SYMTAB_POINTER (TYPE) = (char *)(NAME)
274 /* Return the name (a string) of the struct, union or enum tag
275 described by the TREE_LIST node LINK. This is 0 for an anonymous one. */
277 #define TAG_NAME(link) \
278 (((link) && TREE_PURPOSE ((link)) \
279 && IDENTIFIER_POINTER (TREE_PURPOSE ((link)))) \
280 ? IDENTIFIER_POINTER (TREE_PURPOSE ((link))) : (char *) 0)
282 /* Ensure we don't output a negative line number. */
283 #define MAKE_LINE_SAFE(line) \
284 if ((int) line <= sdb_begin_function_line) \
285 line = sdb_begin_function_line + 1
287 /* Perform linker optimization of merging header file definitions together
288 for targets with MIPS_DEBUGGING_INFO defined. This won't work without a
289 post 960826 version of GAS. Nothing breaks with earlier versions of GAS,
290 the optimization just won't be done. The native assembler already has the
291 necessary support. */
293 #ifdef MIPS_DEBUGGING_INFO
295 #ifndef PUT_SDB_SRC_FILE
296 #define PUT_SDB_SRC_FILE(FILENAME) \
297 output_file_directive (asm_out_file, (FILENAME))
300 /* ECOFF linkers have an optimization that does the same kind of thing as
301 N_BINCL/E_INCL in stabs: eliminate duplicate debug information in the
302 executable. To achieve this, GCC must output a .file for each file
305 /* This is a stack of input files. */
309 struct sdb_file
*next
;
313 /* This is the top of the stack. */
315 static struct sdb_file
*current_file
;
317 #endif /* MIPS_DEBUGGING_INFO */
319 /* The debug hooks structure. */
320 const struct gcc_debug_hooks sdb_debug_hooks
=
322 sdbout_init
, /* init */
323 sdbout_finish
, /* finish */
324 debug_nothing_int_charstar
, /* define */
325 debug_nothing_int_charstar
, /* undef */
326 sdbout_start_source_file
, /* start_source_file */
327 sdbout_end_source_file
, /* end_source_file */
328 sdbout_begin_block
, /* begin_block */
329 sdbout_end_block
, /* end_block */
330 debug_true_tree
, /* ignore_block */
331 sdbout_source_line
, /* source_line */
332 #ifdef MIPS_DEBUGGING_INFO
333 /* Defer on MIPS systems so that parameter descriptions follow
335 debug_nothing_int_charstar
, /* begin_prologue */
336 sdbout_end_prologue
, /* end_prologue */
338 sdbout_begin_prologue
, /* begin_prologue */
339 debug_nothing_int_charstar
, /* end_prologue */
341 sdbout_end_epilogue
, /* end_epilogue */
342 sdbout_begin_function
, /* begin_function */
343 sdbout_end_function
, /* end_function */
344 debug_nothing_tree
, /* function_decl */
345 sdbout_global_decl
, /* global_decl */
346 sdbout_symbol
, /* type_decl */
347 debug_nothing_tree_tree
, /* imported_module_or_decl */
348 debug_nothing_tree
, /* deferred_inline_function */
349 debug_nothing_tree
, /* outlining_inline_function */
350 sdbout_label
, /* label */
351 debug_nothing_int
, /* handle_pch */
352 debug_nothing_rtx
/* var_location */
355 /* Return a unique string to name an anonymous type. */
358 gen_fake_label (void)
362 SDB_GENERATE_FAKE (label
, unnamed_struct_number
);
363 unnamed_struct_number
++;
364 labelstr
= xstrdup (label
);
368 /* Return the number which describes TYPE for SDB.
369 For pointers, etc., this function is recursive.
370 Each record, union or enumeral type must already have had a
371 tag number output. */
373 /* The number is given by d6d5d4d3d2d1bbbb
374 where bbbb is 4 bit basic type, and di indicate one of notype,ptr,fn,array.
375 Thus, char *foo () has bbbb=T_CHAR
378 N_BTMASK= 017 1111 basic type field.
379 N_TSHIFT= 2 derived type shift
380 N_BTSHFT= 4 Basic type shift */
382 /* Produce the number that describes a pointer, function or array type.
383 PREV is the number describing the target, value or element type.
384 DT_type describes how to transform that type. */
385 #define PUSH_DERIVED_LEVEL(DT_type,PREV) \
386 ((((PREV) & ~(int) N_BTMASK) << (int) N_TSHIFT) \
387 | ((int) DT_type << (int) N_BTSHFT) \
388 | ((PREV) & (int) N_BTMASK))
390 /* Number of elements used in sdb_dims. */
391 static int sdb_n_dims
= 0;
393 /* Table of array dimensions of current type. */
394 static int sdb_dims
[SDB_MAX_DIM
];
396 /* Size of outermost array currently being processed. */
397 static int sdb_type_size
= -1;
400 plain_type (tree type
)
402 int val
= plain_type_1 (type
, 0);
404 /* If we have already saved up some array dimensions, print them now. */
409 for (i
= sdb_n_dims
- 1; i
> 0; i
--)
410 PUT_SDB_NEXT_DIM (sdb_dims
[i
]);
411 PUT_SDB_LAST_DIM (sdb_dims
[0]);
414 sdb_type_size
= int_size_in_bytes (type
);
415 /* Don't kill sdb if type is not laid out or has variable size. */
416 if (sdb_type_size
< 0)
419 /* If we have computed the size of an array containing this type,
421 if (sdb_type_size
>= 0)
423 PUT_SDB_SIZE (sdb_type_size
);
430 template_name_p (tree name
)
432 const char *ptr
= IDENTIFIER_POINTER (name
);
433 while (*ptr
&& *ptr
!= '<')
440 sdbout_record_type_name (tree type
)
442 const char *name
= 0;
445 if (KNOWN_TYPE_TAG (type
))
448 if (TYPE_NAME (type
) != 0)
452 /* Find the IDENTIFIER_NODE for the type name. */
453 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
454 t
= TYPE_NAME (type
);
455 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
457 t
= DECL_NAME (TYPE_NAME (type
));
458 /* The DECL_NAME for templates includes "<>", which breaks
459 most assemblers. Use its assembler name instead, which
460 has been mangled into being safe. */
461 if (t
&& template_name_p (t
))
462 t
= DECL_ASSEMBLER_NAME (TYPE_NAME (type
));
465 /* Now get the name as a string, or invent one. */
467 name
= IDENTIFIER_POINTER (t
);
470 no_name
= (name
== 0 || *name
== 0);
472 name
= gen_fake_label ();
474 SET_KNOWN_TYPE_TAG (type
, name
);
475 #ifdef SDB_ALLOW_FORWARD_REFERENCES
477 sdbout_queue_anonymous_type (type
);
481 /* Return the .type value for type TYPE.
483 LEVEL indicates how many levels deep we have recursed into the type.
484 The SDB debug format can only represent 6 derived levels of types.
485 After that, we must output inaccurate debug info. We deliberately
486 stop before the 7th level, so that ADA recursive types will not give an
490 plain_type_1 (tree type
, int level
)
493 type
= void_type_node
;
494 else if (type
== error_mark_node
)
495 type
= integer_type_node
;
497 type
= TYPE_MAIN_VARIANT (type
);
499 switch (TREE_CODE (type
))
506 int size
= int_size_in_bytes (type
) * BITS_PER_UNIT
;
508 /* Carefully distinguish all the standard types of C,
509 without messing up if the language is not C.
510 Note that we check only for the names that contain spaces;
511 other names might occur by coincidence in other languages. */
512 if (TYPE_NAME (type
) != 0
513 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
514 && DECL_NAME (TYPE_NAME (type
)) != 0
515 && TREE_CODE (DECL_NAME (TYPE_NAME (type
))) == IDENTIFIER_NODE
)
517 const char *const name
518 = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
520 if (!strcmp (name
, "char"))
522 if (!strcmp (name
, "unsigned char"))
524 if (!strcmp (name
, "signed char"))
526 if (!strcmp (name
, "int"))
528 if (!strcmp (name
, "unsigned int"))
530 if (!strcmp (name
, "short int"))
532 if (!strcmp (name
, "short unsigned int"))
534 if (!strcmp (name
, "long int"))
536 if (!strcmp (name
, "long unsigned int"))
540 if (size
== INT_TYPE_SIZE
)
541 return (TYPE_UNSIGNED (type
) ? T_UINT
: T_INT
);
542 if (size
== CHAR_TYPE_SIZE
)
543 return (TYPE_UNSIGNED (type
) ? T_UCHAR
: T_CHAR
);
544 if (size
== SHORT_TYPE_SIZE
)
545 return (TYPE_UNSIGNED (type
) ? T_USHORT
: T_SHORT
);
546 if (size
== LONG_TYPE_SIZE
)
547 return (TYPE_UNSIGNED (type
) ? T_ULONG
: T_LONG
);
548 if (size
== LONG_LONG_TYPE_SIZE
) /* better than nothing */
549 return (TYPE_UNSIGNED (type
) ? T_ULONG
: T_LONG
);
555 int precision
= TYPE_PRECISION (type
);
556 if (precision
== FLOAT_TYPE_SIZE
)
558 if (precision
== DOUBLE_TYPE_SIZE
)
560 #ifdef EXTENDED_SDB_BASIC_TYPES
561 if (precision
== LONG_DOUBLE_TYPE_SIZE
)
564 if (precision
== LONG_DOUBLE_TYPE_SIZE
)
565 return T_DOUBLE
; /* better than nothing */
576 m
= plain_type_1 (TREE_TYPE (type
), level
+1);
577 if (sdb_n_dims
< SDB_MAX_DIM
)
578 sdb_dims
[sdb_n_dims
++]
579 = (TYPE_DOMAIN (type
)
580 && TYPE_MIN_VALUE (TYPE_DOMAIN (type
)) != 0
581 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != 0
582 && host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)), 0)
583 && host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)), 0)
584 ? (tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)), 0)
585 - tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)), 0) + 1)
588 return PUSH_DERIVED_LEVEL (DT_ARY
, m
);
593 case QUAL_UNION_TYPE
:
597 #ifdef SDB_ALLOW_FORWARD_REFERENCES
598 sdbout_record_type_name (type
);
600 #ifndef SDB_ALLOW_UNKNOWN_REFERENCES
601 if ((TREE_ASM_WRITTEN (type
) && KNOWN_TYPE_TAG (type
) != 0)
602 #ifdef SDB_ALLOW_FORWARD_REFERENCES
603 || TYPE_MODE (type
) != VOIDmode
608 /* Output the referenced structure tag name
609 only if the .def has already been finished.
610 At least on 386, the Unix assembler
611 cannot handle forward references to tags. */
612 /* But the 88100, it requires them, sigh... */
613 /* And the MIPS requires unknown refs as well... */
614 tag
= KNOWN_TYPE_TAG (type
);
616 /* These 3 lines used to follow the close brace.
617 However, a size of 0 without a tag implies a tag of 0,
618 so if we don't know a tag, we can't mention the size. */
619 sdb_type_size
= int_size_in_bytes (type
);
620 if (sdb_type_size
< 0)
623 return ((TREE_CODE (type
) == RECORD_TYPE
) ? T_STRUCT
624 : (TREE_CODE (type
) == UNION_TYPE
) ? T_UNION
625 : (TREE_CODE (type
) == QUAL_UNION_TYPE
) ? T_UNION
635 m
= plain_type_1 (TREE_TYPE (type
), level
+1);
636 return PUSH_DERIVED_LEVEL (DT_PTR
, m
);
645 m
= plain_type_1 (TREE_TYPE (type
), level
+1);
646 return PUSH_DERIVED_LEVEL (DT_FCN
, m
);
653 /* Output the symbols defined in block number DO_BLOCK.
655 This function works by walking the tree structure of blocks,
656 counting blocks until it finds the desired block. */
658 static int do_block
= 0;
661 sdbout_block (tree block
)
665 /* Ignore blocks never expanded or otherwise marked as real. */
666 if (TREE_USED (block
))
668 /* When we reach the specified block, output its symbols. */
669 if (BLOCK_NUMBER (block
) == do_block
)
670 sdbout_syms (BLOCK_VARS (block
));
672 /* If we are past the specified block, stop the scan. */
673 if (BLOCK_NUMBER (block
) > do_block
)
676 /* Scan the blocks within this block. */
677 sdbout_block (BLOCK_SUBBLOCKS (block
));
680 block
= BLOCK_CHAIN (block
);
684 /* Call sdbout_symbol on each decl in the chain SYMS. */
687 sdbout_syms (tree syms
)
691 if (TREE_CODE (syms
) != LABEL_DECL
)
692 sdbout_symbol (syms
, 1);
693 syms
= TREE_CHAIN (syms
);
697 /* Output SDB information for a symbol described by DECL.
698 LOCAL is nonzero if the symbol is not file-scope. */
701 sdbout_symbol (tree decl
, int local
)
703 tree type
= TREE_TYPE (decl
);
704 tree context
= NULL_TREE
;
709 /* If we are called before sdbout_init is run, just save the symbol
711 if (!sdbout_initialized
)
713 preinit_symbols
= tree_cons (0, decl
, preinit_symbols
);
717 sdbout_one_type (type
);
719 switch (TREE_CODE (decl
))
722 /* Enum values are defined by defining the enum type. */
726 /* Don't mention a nested function under its parent. */
727 context
= decl_function_context (decl
);
728 if (context
== current_function_decl
)
730 /* Check DECL_INITIAL to distinguish declarations from definitions.
731 Don't output debug info here for declarations; they will have
732 a DECL_INITIAL value of 0. */
733 if (! DECL_INITIAL (decl
))
735 if (!MEM_P (DECL_RTL (decl
))
736 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
738 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
739 PUT_SDB_VAL (XEXP (DECL_RTL (decl
), 0));
740 PUT_SDB_SCL (TREE_PUBLIC (decl
) ? C_EXT
: C_STAT
);
744 /* Done with tagged types. */
745 if (DECL_NAME (decl
) == 0)
747 if (DECL_IGNORED_P (decl
))
750 /* Output typedef name. */
751 if (template_name_p (DECL_NAME (decl
)))
752 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
754 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_NAME (decl
)));
755 PUT_SDB_SCL (C_TPDEF
);
759 /* Parm decls go in their own separate chains
760 and are output by sdbout_reg_parms and sdbout_parms. */
764 /* Don't mention a variable that is external.
765 Let the file that defines it describe it. */
766 if (DECL_EXTERNAL (decl
))
769 /* Ignore __FUNCTION__, etc. */
770 if (DECL_IGNORED_P (decl
))
773 /* If there was an error in the declaration, don't dump core
774 if there is no RTL associated with the variable doesn't
776 if (!DECL_RTL_SET_P (decl
))
780 eliminate_regs (DECL_RTL (decl
), 0, NULL_RTX
));
781 #ifdef LEAF_REG_REMAP
782 if (current_function_uses_only_leaf_regs
)
783 leaf_renumber_regs_insn (DECL_RTL (decl
));
785 value
= DECL_RTL (decl
);
787 /* Don't mention a variable at all
788 if it was completely optimized into nothingness.
790 If DECL was from an inline function, then its rtl
791 is not identically the rtl that was used in this
792 particular compilation. */
795 regno
= REGNO (value
);
796 if (regno
>= FIRST_PSEUDO_REGISTER
)
799 else if (GET_CODE (value
) == SUBREG
)
801 while (GET_CODE (value
) == SUBREG
)
802 value
= SUBREG_REG (value
);
805 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
808 regno
= REGNO (alter_subreg (&value
));
809 SET_DECL_RTL (decl
, value
);
811 /* Don't output anything if an auto variable
812 gets RTL that is static.
813 GAS version 2.2 can't handle such output. */
814 else if (MEM_P (value
) && CONSTANT_P (XEXP (value
, 0))
815 && ! TREE_STATIC (decl
))
818 /* Emit any structure, union, or enum type that has not been output.
819 This occurs for tag-less structs (et al) used to declare variables
821 if (TREE_CODE (type
) == ENUMERAL_TYPE
822 || TREE_CODE (type
) == RECORD_TYPE
823 || TREE_CODE (type
) == UNION_TYPE
824 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
826 if (COMPLETE_TYPE_P (type
) /* not a forward reference */
827 && KNOWN_TYPE_TAG (type
) == 0) /* not yet declared */
828 sdbout_one_type (type
);
831 /* Defer SDB information for top-level initialized variables! */
834 && DECL_INITIAL (decl
))
837 /* C++ in 2.3 makes nameless symbols. That will be fixed later.
838 For now, avoid crashing. */
839 if (DECL_NAME (decl
) == NULL_TREE
)
842 /* Record the name for, starting a symtab entry. */
844 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
846 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
849 && GET_CODE (XEXP (value
, 0)) == SYMBOL_REF
)
852 if (TREE_PUBLIC (decl
))
854 PUT_SDB_VAL (XEXP (value
, 0));
859 PUT_SDB_VAL (XEXP (value
, 0));
860 PUT_SDB_SCL (C_STAT
);
866 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (regno
));
869 else if (MEM_P (value
)
870 && (MEM_P (XEXP (value
, 0))
871 || (REG_P (XEXP (value
, 0))
872 && REGNO (XEXP (value
, 0)) != HARD_FRAME_POINTER_REGNUM
873 && REGNO (XEXP (value
, 0)) != STACK_POINTER_REGNUM
)))
874 /* If the value is indirect by memory or by a register
875 that isn't the frame pointer
876 then it means the object is variable-sized and address through
877 that register or stack slot. COFF has no way to represent this
878 so all we can do is output the variable as a pointer. */
881 if (REG_P (XEXP (value
, 0)))
883 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (XEXP (value
, 0))));
888 /* DECL_RTL looks like (MEM (MEM (PLUS (REG...)
890 We want the value of that CONST_INT. */
891 /* Encore compiler hates a newline in a macro arg, it seems. */
892 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
893 (XEXP (XEXP (value
, 0), 0)));
894 PUT_SDB_SCL (C_AUTO
);
897 /* Effectively do build_pointer_type, but don't cache this type,
898 since it might be temporary whereas the type it points to
899 might have been saved for inlining. */
900 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
901 type
= make_node (POINTER_TYPE
);
902 TREE_TYPE (type
) = TREE_TYPE (decl
);
904 else if (MEM_P (value
)
905 && ((GET_CODE (XEXP (value
, 0)) == PLUS
906 && REG_P (XEXP (XEXP (value
, 0), 0))
907 && GET_CODE (XEXP (XEXP (value
, 0), 1)) == CONST_INT
)
908 /* This is for variables which are at offset zero from
909 the frame pointer. This happens on the Alpha.
910 Non-frame pointer registers are excluded above. */
911 || (REG_P (XEXP (value
, 0)))))
913 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
914 or (MEM (REG...)). We want the value of that CONST_INT
917 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET (XEXP (value
, 0)));
918 PUT_SDB_SCL (C_AUTO
);
922 /* It is something we don't know how to represent for SDB. */
930 PUT_SDB_TYPE (plain_type (type
));
934 /* Output SDB information for a top-level initialized variable
935 that has been delayed. */
938 sdbout_toplevel_data (tree decl
)
940 tree type
= TREE_TYPE (decl
);
942 if (DECL_IGNORED_P (decl
))
945 if (! (TREE_CODE (decl
) == VAR_DECL
946 && MEM_P (DECL_RTL (decl
))
947 && DECL_INITIAL (decl
)))
950 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
951 PUT_SDB_VAL (XEXP (DECL_RTL (decl
), 0));
952 if (TREE_PUBLIC (decl
))
958 PUT_SDB_SCL (C_STAT
);
960 PUT_SDB_TYPE (plain_type (type
));
964 #ifdef SDB_ALLOW_FORWARD_REFERENCES
966 /* Machinery to record and output anonymous types. */
969 sdbout_queue_anonymous_type (tree type
)
971 anonymous_types
= tree_cons (NULL_TREE
, type
, anonymous_types
);
975 sdbout_dequeue_anonymous_types (void)
979 while (anonymous_types
)
981 types
= nreverse (anonymous_types
);
982 anonymous_types
= NULL_TREE
;
984 for (link
= types
; link
; link
= TREE_CHAIN (link
))
986 tree type
= TREE_VALUE (link
);
988 if (type
&& ! TREE_ASM_WRITTEN (type
))
989 sdbout_one_type (type
);
996 /* Given a chain of ..._TYPE nodes, all of which have names,
997 output definitions of those names, as typedefs. */
1000 sdbout_types (tree types
)
1004 for (link
= types
; link
; link
= TREE_CHAIN (link
))
1005 sdbout_one_type (link
);
1007 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1008 sdbout_dequeue_anonymous_types ();
1013 sdbout_type (tree type
)
1015 if (type
== error_mark_node
)
1016 type
= integer_type_node
;
1017 PUT_SDB_TYPE (plain_type (type
));
1020 /* Output types of the fields of type TYPE, if they are structs.
1022 Formerly did not chase through pointer types, since that could be circular.
1023 They must come before TYPE, since forward refs are not allowed.
1024 Now james@bigtex.cactus.org says to try them. */
1027 sdbout_field_types (tree type
)
1031 for (tail
= TYPE_FIELDS (type
); tail
; tail
= TREE_CHAIN (tail
))
1032 /* This condition should match the one for emitting the actual
1034 if (TREE_CODE (tail
) == FIELD_DECL
1037 && host_integerp (DECL_SIZE (tail
), 1)
1038 && host_integerp (bit_position (tail
), 0))
1040 if (POINTER_TYPE_P (TREE_TYPE (tail
)))
1041 sdbout_one_type (TREE_TYPE (TREE_TYPE (tail
)));
1043 sdbout_one_type (TREE_TYPE (tail
));
1047 /* Use this to put out the top level defined record and union types
1048 for later reference. If this is a struct with a name, then put that
1049 name out. Other unnamed structs will have .xxfake labels generated so
1050 that they may be referred to later.
1051 The label will be stored in the KNOWN_TYPE_TAG slot of a type.
1052 It may NOT be called recursively. */
1055 sdbout_one_type (tree type
)
1057 if (current_function_decl
!= NULL_TREE
1058 && DECL_SECTION_NAME (current_function_decl
) != NULL_TREE
)
1059 ; /* Don't change section amid function. */
1063 switch (TREE_CODE (type
))
1067 case QUAL_UNION_TYPE
:
1069 type
= TYPE_MAIN_VARIANT (type
);
1070 /* Don't output a type twice. */
1071 if (TREE_ASM_WRITTEN (type
))
1072 /* James said test TREE_ASM_BEING_WRITTEN here. */
1075 /* Output nothing if type is not yet defined. */
1076 if (!COMPLETE_TYPE_P (type
))
1079 TREE_ASM_WRITTEN (type
) = 1;
1081 /* This is reputed to cause trouble with the following case,
1082 but perhaps checking TYPE_SIZE above will fix it. */
1084 /* Here is a testcase:
1090 typedef struct intermediate {
1094 typedef struct badstr {
1098 /* This change, which ought to make better output,
1099 used to make the COFF assembler unhappy.
1100 Changes involving KNOWN_TYPE_TAG may fix the problem. */
1101 /* Before really doing anything, output types we want to refer to. */
1102 /* Note that in version 1 the following two lines
1103 are not used if forward references are in use. */
1104 if (TREE_CODE (type
) != ENUMERAL_TYPE
)
1105 sdbout_field_types (type
);
1107 /* Output a structure type. */
1109 int size
= int_size_in_bytes (type
);
1112 int i
, n_baseclasses
= 0;
1114 /* Record the type tag, but not in its permanent place just yet. */
1115 sdbout_record_type_name (type
);
1117 PUT_SDB_DEF (KNOWN_TYPE_TAG (type
));
1119 switch (TREE_CODE (type
))
1122 case QUAL_UNION_TYPE
:
1123 PUT_SDB_SCL (C_UNTAG
);
1124 PUT_SDB_TYPE (T_UNION
);
1129 PUT_SDB_SCL (C_STRTAG
);
1130 PUT_SDB_TYPE (T_STRUCT
);
1135 PUT_SDB_SCL (C_ENTAG
);
1136 PUT_SDB_TYPE (T_ENUM
);
1144 PUT_SDB_SIZE (size
);
1147 /* Print out the base class information with fields
1148 named after the types they hold. */
1149 /* This is only relevant to aggregate types. TYPE_BINFO is used
1150 for other purposes in an ENUMERAL_TYPE, so we must exclude that
1152 if (TREE_CODE (type
) != ENUMERAL_TYPE
)
1154 if (TYPE_BINFO (type
) && BINFO_BASE_BINFOS (TYPE_BINFO (type
)))
1155 n_baseclasses
= BINFO_N_BASE_BINFOS (TYPE_BINFO (type
));
1157 for (i
= 0; i
< n_baseclasses
; i
++)
1159 tree child
= BINFO_BASE_BINFO (TYPE_BINFO (type
), i
);
1160 tree child_type
= BINFO_TYPE (child
);
1161 tree child_type_name
;
1162 if (TYPE_NAME (child_type
) == 0)
1164 if (TREE_CODE (TYPE_NAME (child_type
)) == IDENTIFIER_NODE
)
1165 child_type_name
= TYPE_NAME (child_type
);
1166 else if (TREE_CODE (TYPE_NAME (child_type
)) == TYPE_DECL
)
1168 child_type_name
= DECL_NAME (TYPE_NAME (child_type
));
1169 if (child_type_name
&& template_name_p (child_type_name
))
1171 = DECL_ASSEMBLER_NAME (TYPE_NAME (child_type
));
1176 PUT_SDB_DEF (IDENTIFIER_POINTER (child_type_name
));
1177 PUT_SDB_INT_VAL (tree_low_cst (BINFO_OFFSET (child
), 0));
1178 PUT_SDB_SCL (member_scl
);
1179 sdbout_type (BINFO_TYPE (child
));
1184 /* Output the individual fields. */
1186 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
1188 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1189 if (host_integerp (TREE_VALUE (tem
), 0))
1191 PUT_SDB_DEF (IDENTIFIER_POINTER (TREE_PURPOSE (tem
)));
1192 PUT_SDB_INT_VAL (tree_low_cst (TREE_VALUE (tem
), 0));
1193 PUT_SDB_SCL (C_MOE
);
1194 PUT_SDB_TYPE (T_MOE
);
1198 else /* record or union type */
1199 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
1200 /* Output the name, type, position (in bits), size (in bits)
1203 /* Omit here the nameless fields that are used to skip bits.
1204 Also omit fields with variable size or position.
1205 Also omit non FIELD_DECL nodes that GNU C++ may put here. */
1206 if (TREE_CODE (tem
) == FIELD_DECL
1209 && host_integerp (DECL_SIZE (tem
), 1)
1210 && host_integerp (bit_position (tem
), 0))
1214 name
= IDENTIFIER_POINTER (DECL_NAME (tem
));
1216 if (DECL_BIT_FIELD_TYPE (tem
))
1218 PUT_SDB_INT_VAL (int_bit_position (tem
));
1219 PUT_SDB_SCL (C_FIELD
);
1220 sdbout_type (DECL_BIT_FIELD_TYPE (tem
));
1221 PUT_SDB_SIZE (tree_low_cst (DECL_SIZE (tem
), 1));
1225 PUT_SDB_INT_VAL (int_bit_position (tem
) / BITS_PER_UNIT
);
1226 PUT_SDB_SCL (member_scl
);
1227 sdbout_type (TREE_TYPE (tem
));
1231 /* Output end of a structure,union, or enumeral definition. */
1233 PUT_SDB_PLAIN_DEF ("eos");
1234 PUT_SDB_INT_VAL (size
);
1235 PUT_SDB_SCL (C_EOS
);
1236 PUT_SDB_TAG (KNOWN_TYPE_TAG (type
));
1237 PUT_SDB_SIZE (size
);
1247 /* The following two functions output definitions of function parameters.
1248 Each parameter gets a definition locating it in the parameter list.
1249 Each parameter that is a register variable gets a second definition
1250 locating it in the register.
1252 Printing or argument lists in gdb uses the definitions that
1253 locate in the parameter list. But reference to the variable in
1254 expressions uses preferentially the definition as a register. */
1256 /* Output definitions, referring to storage in the parmlist,
1257 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
1260 sdbout_parms (tree parms
)
1262 for (; parms
; parms
= TREE_CHAIN (parms
))
1263 if (DECL_NAME (parms
))
1265 int current_sym_value
= 0;
1266 const char *name
= IDENTIFIER_POINTER (DECL_NAME (parms
));
1268 if (name
== 0 || *name
== 0)
1269 name
= gen_fake_label ();
1271 /* Perform any necessary register eliminations on the parameter's rtl,
1272 so that the debugging output will be accurate. */
1273 DECL_INCOMING_RTL (parms
)
1274 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
1275 SET_DECL_RTL (parms
,
1276 eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
));
1278 if (PARM_PASSED_IN_MEMORY (parms
))
1280 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
1283 /* ??? Here we assume that the parm address is indexed
1284 off the frame pointer or arg pointer.
1285 If that is not true, we produce meaningless results,
1286 but do not crash. */
1287 if (GET_CODE (addr
) == PLUS
1288 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
1289 current_sym_value
= INTVAL (XEXP (addr
, 1));
1291 current_sym_value
= 0;
1293 if (REG_P (DECL_RTL (parms
))
1294 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
1295 type
= DECL_ARG_TYPE (parms
);
1298 int original_sym_value
= current_sym_value
;
1300 /* This is the case where the parm is passed as an int or
1301 double and it is converted to a char, short or float
1302 and stored back in the parmlist. In this case, describe
1303 the parm with the variable's declared type, and adjust
1304 the address if the least significant bytes (which we are
1305 using) are not the first ones. */
1306 if (BYTES_BIG_ENDIAN
1307 && TREE_TYPE (parms
) != DECL_ARG_TYPE (parms
))
1308 current_sym_value
+=
1309 (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms
)))
1310 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
))));
1312 if (MEM_P (DECL_RTL (parms
))
1313 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == PLUS
1314 && (GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 1))
1316 && (INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1))
1317 == current_sym_value
))
1318 type
= TREE_TYPE (parms
);
1321 current_sym_value
= original_sym_value
;
1322 type
= DECL_ARG_TYPE (parms
);
1327 PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value
, addr
));
1328 PUT_SDB_SCL (C_ARG
);
1329 PUT_SDB_TYPE (plain_type (type
));
1332 else if (REG_P (DECL_RTL (parms
)))
1335 /* Parm passed in registers and lives in registers or nowhere. */
1337 /* If parm lives in a register, use that register;
1338 pretend the parm was passed there. It would be more consistent
1339 to describe the register where the parm was passed,
1340 but in practice that register usually holds something else. */
1341 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
1342 best_rtl
= DECL_RTL (parms
);
1343 /* If the parm lives nowhere,
1344 use the register where it was passed. */
1346 best_rtl
= DECL_INCOMING_RTL (parms
);
1349 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (best_rtl
)));
1350 PUT_SDB_SCL (C_REGPARM
);
1351 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms
)));
1354 else if (MEM_P (DECL_RTL (parms
))
1355 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
)
1357 /* Parm was passed in registers but lives on the stack. */
1359 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
1360 in which case we want the value of that CONST_INT,
1361 or (MEM (REG ...)) or (MEM (MEM ...)),
1362 in which case we use a value of zero. */
1363 if (REG_P (XEXP (DECL_RTL (parms
), 0))
1364 || MEM_P (XEXP (DECL_RTL (parms
), 0)))
1365 current_sym_value
= 0;
1367 current_sym_value
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
1369 /* Again, this assumes the offset is based on the arg pointer. */
1371 PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value
,
1372 XEXP (DECL_RTL (parms
), 0)));
1373 PUT_SDB_SCL (C_ARG
);
1374 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms
)));
1380 /* Output definitions for the places where parms live during the function,
1381 when different from where they were passed, when the parms were passed
1384 It is not useful to do this for parms passed in registers
1385 that live during the function in different registers, because it is
1386 impossible to look in the passed register for the passed value,
1387 so we use the within-the-function register to begin with.
1389 PARMS is a chain of PARM_DECL nodes. */
1392 sdbout_reg_parms (tree parms
)
1394 for (; parms
; parms
= TREE_CHAIN (parms
))
1395 if (DECL_NAME (parms
))
1397 const char *name
= IDENTIFIER_POINTER (DECL_NAME (parms
));
1399 /* Report parms that live in registers during the function
1400 but were passed in memory. */
1401 if (REG_P (DECL_RTL (parms
))
1402 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
1403 && PARM_PASSED_IN_MEMORY (parms
))
1405 if (name
== 0 || *name
== 0)
1406 name
= gen_fake_label ();
1408 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms
))));
1409 PUT_SDB_SCL (C_REG
);
1410 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms
)));
1413 /* Report parms that live in memory but not where they were passed. */
1414 else if (MEM_P (DECL_RTL (parms
))
1415 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == PLUS
1416 && GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == CONST_INT
1417 && PARM_PASSED_IN_MEMORY (parms
)
1418 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
1420 #if 0 /* ??? It is not clear yet what should replace this. */
1421 int offset
= DECL_OFFSET (parms
) / BITS_PER_UNIT
;
1422 /* A parm declared char is really passed as an int,
1423 so it occupies the least significant bytes.
1424 On a big-endian machine those are not the low-numbered ones. */
1425 if (BYTES_BIG_ENDIAN
1427 && TREE_TYPE (parms
) != DECL_ARG_TYPE (parms
))
1428 offset
+= (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms
)))
1429 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
))));
1430 if (INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) != offset
) {...}
1433 if (name
== 0 || *name
== 0)
1434 name
= gen_fake_label ();
1436 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
1437 (XEXP (DECL_RTL (parms
), 0)));
1438 PUT_SDB_SCL (C_AUTO
);
1439 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms
)));
1446 /* Output debug information for a global DECL. Called from toplev.c
1447 after compilation proper has finished. */
1450 sdbout_global_decl (tree decl
)
1452 if (TREE_CODE (decl
) == VAR_DECL
1453 && !DECL_EXTERNAL (decl
)
1454 && DECL_RTL_SET_P (decl
))
1456 /* The COFF linker can move initialized global vars to the end.
1457 And that can screw up the symbol ordering. Defer those for
1458 sdbout_finish (). */
1459 if (!DECL_INITIAL (decl
) || !TREE_PUBLIC (decl
))
1460 sdbout_symbol (decl
, 0);
1462 VARRAY_PUSH_TREE (deferred_global_decls
, decl
);
1464 /* Output COFF information for non-global file-scope initialized
1466 if (DECL_INITIAL (decl
) && MEM_P (DECL_RTL (decl
)))
1467 sdbout_toplevel_data (decl
);
1471 /* Output initialized global vars at the end, in the order of
1472 definition. See comment in sdbout_global_decl. */
1475 sdbout_finish (const char *main_filename ATTRIBUTE_UNUSED
)
1479 for (i
= 0; i
< VARRAY_ACTIVE_SIZE (deferred_global_decls
); i
++)
1480 sdbout_symbol (VARRAY_TREE (deferred_global_decls
, i
), 0);
1483 /* Describe the beginning of an internal block within a function.
1484 Also output descriptions of variables defined in this block.
1486 N is the number of the block, by order of beginning, counting from 1,
1487 and not counting the outermost (function top-level) block.
1488 The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
1489 if the count starts at 0 for the outermost one. */
1492 sdbout_begin_block (unsigned int line
, unsigned int n
)
1494 tree decl
= current_function_decl
;
1495 MAKE_LINE_SAFE (line
);
1497 /* The SCO compiler does not emit a separate block for the function level
1498 scope, so we avoid it here also. However, mips ECOFF compilers do emit
1499 a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined. */
1500 #ifndef MIPS_DEBUGGING_INFO
1503 PUT_SDB_BLOCK_START (line
- sdb_begin_function_line
);
1507 /* Include the outermost BLOCK's variables in block 1. */
1508 do_block
= BLOCK_NUMBER (DECL_INITIAL (decl
));
1509 sdbout_block (DECL_INITIAL (decl
));
1511 /* If -g1, suppress all the internal symbols of functions
1512 except for arguments. */
1513 if (debug_info_level
!= DINFO_LEVEL_TERSE
)
1516 sdbout_block (DECL_INITIAL (decl
));
1519 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1520 sdbout_dequeue_anonymous_types ();
1524 /* Describe the end line-number of an internal block within a function. */
1527 sdbout_end_block (unsigned int line
, unsigned int n ATTRIBUTE_UNUSED
)
1529 MAKE_LINE_SAFE (line
);
1531 /* The SCO compiler does not emit a separate block for the function level
1532 scope, so we avoid it here also. However, mips ECOFF compilers do emit
1533 a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined. */
1534 #ifndef MIPS_DEBUGGING_INFO
1537 PUT_SDB_BLOCK_END (line
- sdb_begin_function_line
);
1540 /* Output a line number symbol entry for source file FILENAME and line
1544 sdbout_source_line (unsigned int line
, const char *filename ATTRIBUTE_UNUSED
)
1546 /* COFF relative line numbers must be positive. */
1547 if ((int) line
> sdb_begin_function_line
)
1549 #ifdef ASM_OUTPUT_SOURCE_LINE
1550 sdbout_source_line_counter
+= 1;
1551 ASM_OUTPUT_SOURCE_LINE (asm_out_file
, line
, sdbout_source_line_counter
);
1553 fprintf (asm_out_file
, "\t.ln\t%d\n",
1554 ((sdb_begin_function_line
> -1)
1555 ? line
- sdb_begin_function_line
: 1));
1560 /* Output sdb info for the current function name.
1561 Called from assemble_start_function. */
1564 sdbout_begin_function (tree decl ATTRIBUTE_UNUSED
)
1566 sdbout_symbol (current_function_decl
, 0);
1569 /* Called at beginning of function body (before or after prologue,
1570 depending on MIPS_DEBUGGING_INFO). Record the function's starting
1571 line number, so we can output relative line numbers for the other
1572 lines. Describe beginning of outermost block. Also describe the
1575 #ifndef MIPS_DEBUGGING_INFO
1577 sdbout_begin_prologue (unsigned int line
, const char *file ATTRIBUTE_UNUSED
)
1579 sdbout_end_prologue (line
, file
);
1584 sdbout_end_prologue (unsigned int line
, const char *file ATTRIBUTE_UNUSED
)
1586 sdb_begin_function_line
= line
- 1;
1587 PUT_SDB_FUNCTION_START (line
);
1588 sdbout_parms (DECL_ARGUMENTS (current_function_decl
));
1589 sdbout_reg_parms (DECL_ARGUMENTS (current_function_decl
));
1592 /* Called at end of function (before epilogue).
1593 Describe end of outermost block. */
1596 sdbout_end_function (unsigned int line
)
1598 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1599 sdbout_dequeue_anonymous_types ();
1602 MAKE_LINE_SAFE (line
);
1603 PUT_SDB_FUNCTION_END (line
- sdb_begin_function_line
);
1605 /* Indicate we are between functions, for line-number output. */
1606 sdb_begin_function_line
= -1;
1609 /* Output sdb info for the absolute end of a function.
1610 Called after the epilogue is output. */
1613 sdbout_end_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1614 const char *file ATTRIBUTE_UNUSED
)
1616 const char *const name ATTRIBUTE_UNUSED
1617 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
));
1619 #ifdef PUT_SDB_EPILOGUE_END
1620 PUT_SDB_EPILOGUE_END (name
);
1622 fprintf (asm_out_file
, "\t.def\t");
1623 assemble_name (asm_out_file
, name
);
1624 fprintf (asm_out_file
, "%s\t.val\t.%s\t.scl\t-1%s\t.endef\n",
1625 SDB_DELIM
, SDB_DELIM
, SDB_DELIM
);
1629 /* Output sdb info for the given label. Called only if LABEL_NAME (insn)
1633 sdbout_label (rtx insn
)
1635 PUT_SDB_DEF (LABEL_NAME (insn
));
1637 PUT_SDB_SCL (C_LABEL
);
1638 PUT_SDB_TYPE (T_NULL
);
1642 /* Change to reading from a new source file. */
1645 sdbout_start_source_file (unsigned int line ATTRIBUTE_UNUSED
,
1646 const char *filename ATTRIBUTE_UNUSED
)
1648 #ifdef MIPS_DEBUGGING_INFO
1649 struct sdb_file
*n
= xmalloc (sizeof *n
);
1651 n
->next
= current_file
;
1654 PUT_SDB_SRC_FILE (filename
);
1658 /* Revert to reading a previous source file. */
1661 sdbout_end_source_file (unsigned int line ATTRIBUTE_UNUSED
)
1663 #ifdef MIPS_DEBUGGING_INFO
1664 struct sdb_file
*next
;
1666 next
= current_file
->next
;
1667 free (current_file
);
1668 current_file
= next
;
1669 PUT_SDB_SRC_FILE (current_file
->name
);
1673 /* Set up for SDB output at the start of compilation. */
1676 sdbout_init (const char *input_file_name ATTRIBUTE_UNUSED
)
1680 #ifdef MIPS_DEBUGGING_INFO
1681 current_file
= xmalloc (sizeof *current_file
);
1682 current_file
->next
= NULL
;
1683 current_file
->name
= input_file_name
;
1686 VARRAY_TREE_INIT (deferred_global_decls
, 12, "deferred_global_decls");
1688 /* Emit debug information which was queued by sdbout_symbol before
1690 sdbout_initialized
= true;
1692 for (t
= nreverse (preinit_symbols
); t
; t
= TREE_CHAIN (t
))
1693 sdbout_symbol (TREE_VALUE (t
), 0);
1694 preinit_symbols
= 0;
1697 #else /* SDB_DEBUGGING_INFO */
1699 /* This should never be used, but its address is needed for comparisons. */
1700 const struct gcc_debug_hooks sdb_debug_hooks
;
1702 #endif /* SDB_DEBUGGING_INFO */
1704 #include "gt-sdbout.h"