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 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.
50 static GTY(()) tree anonymous_types
;
52 #ifdef SDB_DEBUGGING_INFO
57 #include "insn-config.h"
63 #include "langhooks.h"
65 /* 1 if PARM is passed to this function in memory. */
67 #define PARM_PASSED_IN_MEMORY(PARM) \
68 (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
70 /* A C expression for the integer offset value of an automatic variable
71 (C_AUTO) having address X (an RTX). */
72 #ifndef DEBUGGER_AUTO_OFFSET
73 #define DEBUGGER_AUTO_OFFSET(X) \
74 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
77 /* A C expression for the integer offset value of an argument (C_ARG)
78 having address X (an RTX). The nominal offset is OFFSET. */
79 #ifndef DEBUGGER_ARG_OFFSET
80 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
83 /* Line number of beginning of current function, minus one.
84 Negative means not in a function or not using sdb. */
86 int sdb_begin_function_line
= -1;
88 /* Counter to generate unique "names" for nameless struct members. */
90 static int unnamed_struct_number
= 0;
92 extern FILE *asm_out_file
;
94 extern tree current_function_decl
;
98 static void sdbout_init
PARAMS ((const char *));
99 static void sdbout_finish
PARAMS ((const char *));
100 static void sdbout_start_source_file
PARAMS ((unsigned int, const char *));
101 static void sdbout_end_source_file
PARAMS ((unsigned int));
102 static void sdbout_begin_block
PARAMS ((unsigned int, unsigned int));
103 static void sdbout_end_block
PARAMS ((unsigned int, unsigned int));
104 static void sdbout_source_line
PARAMS ((unsigned int, const char *));
105 static void sdbout_end_epilogue
PARAMS ((void));
106 static void sdbout_global_decl
PARAMS ((tree
));
107 #ifndef MIPS_DEBUGGING_INFO
108 static void sdbout_begin_prologue
PARAMS ((unsigned int, const char *));
110 static void sdbout_end_prologue
PARAMS ((unsigned int));
111 static void sdbout_begin_function
PARAMS ((tree
));
112 static void sdbout_end_function
PARAMS ((unsigned int));
113 static void sdbout_toplevel_data
PARAMS ((tree
));
114 static void sdbout_label
PARAMS ((rtx
));
115 static char *gen_fake_label
PARAMS ((void));
116 static int plain_type
PARAMS ((tree
));
117 static int template_name_p
PARAMS ((tree
));
118 static void sdbout_record_type_name
PARAMS ((tree
));
119 static int plain_type_1
PARAMS ((tree
, int));
120 static void sdbout_block
PARAMS ((tree
));
121 static void sdbout_syms
PARAMS ((tree
));
122 #ifdef SDB_ALLOW_FORWARD_REFERENCES
123 static void sdbout_queue_anonymous_type
PARAMS ((tree
));
124 static void sdbout_dequeue_anonymous_types
PARAMS ((void));
126 static void sdbout_type
PARAMS ((tree
));
127 static void sdbout_field_types
PARAMS ((tree
));
128 static void sdbout_one_type
PARAMS ((tree
));
129 static void sdbout_parms
PARAMS ((tree
));
130 static void sdbout_reg_parms
PARAMS ((tree
));
131 static void sdbout_global_decl
PARAMS ((tree
));
133 /* Random macros describing parts of SDB data. */
135 /* Put something here if lines get too long */
138 /* Default value of delimiter is ";". */
140 #define SDB_DELIM ";"
143 /* Maximum number of dimensions the assembler will allow. */
145 #define SDB_MAX_DIM 4
149 #define PUT_SDB_SCL(a) fprintf(asm_out_file, "\t.scl\t%d%s", (a), SDB_DELIM)
152 #ifndef PUT_SDB_INT_VAL
153 #define PUT_SDB_INT_VAL(a) \
155 fputs ("\t.val\t", asm_out_file); \
156 fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT) (a)); \
157 fprintf (asm_out_file, "%s", SDB_DELIM); \
163 #define PUT_SDB_VAL(a) \
164 ( fputs ("\t.val\t", asm_out_file), \
165 output_addr_const (asm_out_file, (a)), \
166 fprintf (asm_out_file, SDB_DELIM))
170 #define PUT_SDB_DEF(a) \
171 do { fprintf (asm_out_file, "\t.def\t"); \
172 assemble_name (asm_out_file, a); \
173 fprintf (asm_out_file, SDB_DELIM); } while (0)
176 #ifndef PUT_SDB_PLAIN_DEF
177 #define PUT_SDB_PLAIN_DEF(a) fprintf(asm_out_file,"\t.def\t.%s%s",a, SDB_DELIM)
180 #ifndef PUT_SDB_ENDEF
181 #define PUT_SDB_ENDEF fputs("\t.endef\n", asm_out_file)
185 #define PUT_SDB_TYPE(a) fprintf(asm_out_file, "\t.type\t0%o%s", a, SDB_DELIM)
189 #define PUT_SDB_SIZE(a) \
191 fputs ("\t.size\t", asm_out_file); \
192 fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT) (a)); \
193 fprintf (asm_out_file, "%s", SDB_DELIM); \
197 #ifndef PUT_SDB_START_DIM
198 #define PUT_SDB_START_DIM fprintf(asm_out_file, "\t.dim\t")
201 #ifndef PUT_SDB_NEXT_DIM
202 #define PUT_SDB_NEXT_DIM(a) fprintf(asm_out_file, "%d,", a)
205 #ifndef PUT_SDB_LAST_DIM
206 #define PUT_SDB_LAST_DIM(a) fprintf(asm_out_file, "%d%s", a, SDB_DELIM)
210 #define PUT_SDB_TAG(a) \
211 do { fprintf (asm_out_file, "\t.tag\t"); \
212 assemble_name (asm_out_file, a); \
213 fprintf (asm_out_file, SDB_DELIM); } while (0)
216 #ifndef PUT_SDB_BLOCK_START
217 #define PUT_SDB_BLOCK_START(LINE) \
218 fprintf (asm_out_file, \
219 "\t.def\t.bb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n", \
220 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
223 #ifndef PUT_SDB_BLOCK_END
224 #define PUT_SDB_BLOCK_END(LINE) \
225 fprintf (asm_out_file, \
226 "\t.def\t.eb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n", \
227 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
230 #ifndef PUT_SDB_FUNCTION_START
231 #define PUT_SDB_FUNCTION_START(LINE) \
232 fprintf (asm_out_file, \
233 "\t.def\t.bf%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \
234 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
237 #ifndef PUT_SDB_FUNCTION_END
238 #define PUT_SDB_FUNCTION_END(LINE) \
239 fprintf (asm_out_file, \
240 "\t.def\t.ef%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \
241 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
244 #ifndef SDB_GENERATE_FAKE
245 #define SDB_GENERATE_FAKE(BUFFER, NUMBER) \
246 sprintf ((BUFFER), ".%dfake", (NUMBER));
249 /* Return the sdb tag identifier string for TYPE
250 if TYPE has already been defined; otherwise return a null pointer. */
252 #define KNOWN_TYPE_TAG(type) TYPE_SYMTAB_POINTER (type)
254 /* Set the sdb tag identifier string for TYPE to NAME. */
256 #define SET_KNOWN_TYPE_TAG(TYPE, NAME) \
257 TYPE_SYMTAB_POINTER (TYPE) = (NAME)
259 /* Return the name (a string) of the struct, union or enum tag
260 described by the TREE_LIST node LINK. This is 0 for an anonymous one. */
262 #define TAG_NAME(link) \
263 (((link) && TREE_PURPOSE ((link)) \
264 && IDENTIFIER_POINTER (TREE_PURPOSE ((link)))) \
265 ? IDENTIFIER_POINTER (TREE_PURPOSE ((link))) : (char *) 0)
267 /* Ensure we don't output a negative line number. */
268 #define MAKE_LINE_SAFE(line) \
269 if ((int) line <= sdb_begin_function_line) \
270 line = sdb_begin_function_line + 1
272 /* Perform linker optimization of merging header file definitions together
273 for targets with MIPS_DEBUGGING_INFO defined. This won't work without a
274 post 960826 version of GAS. Nothing breaks with earlier versions of GAS,
275 the optimization just won't be done. The native assembler already has the
276 necessary support. */
278 #ifdef MIPS_DEBUGGING_INFO
280 #ifndef PUT_SDB_SRC_FILE
281 #define PUT_SDB_SRC_FILE(FILENAME) \
282 output_file_directive (asm_out_file, (FILENAME))
285 /* ECOFF linkers have an optimization that does the same kind of thing as
286 N_BINCL/E_INCL in stabs: eliminate duplicate debug information in the
287 executable. To achieve this, GCC must output a .file for each file
290 /* This is a stack of input files. */
294 struct sdb_file
*next
;
298 /* This is the top of the stack. */
300 static struct sdb_file
*current_file
;
302 #endif /* MIPS_DEBUGGING_INFO */
304 /* The debug hooks structure. */
305 const struct gcc_debug_hooks sdb_debug_hooks
=
307 sdbout_init
, /* init */
308 sdbout_finish
, /* finish */
309 debug_nothing_int_charstar
, /* define */
310 debug_nothing_int_charstar
, /* undef */
311 sdbout_start_source_file
, /* start_source_file */
312 sdbout_end_source_file
, /* end_source_file */
313 sdbout_begin_block
, /* begin_block */
314 sdbout_end_block
, /* end_block */
315 debug_true_tree
, /* ignore_block */
316 sdbout_source_line
, /* source_line */
317 #ifdef MIPS_DEBUGGING_INFO
318 /* Defer on MIPS systems so that parameter descriptions follow
320 debug_nothing_int_charstar
, /* begin_prologue */
321 sdbout_end_prologue
, /* end_prologue */
323 sdbout_begin_prologue
, /* begin_prologue */
324 debug_nothing_int
, /* end_prologue */
326 sdbout_end_epilogue
, /* end_epilogue */
327 sdbout_begin_function
, /* begin_function */
328 sdbout_end_function
, /* end_function */
329 debug_nothing_tree
, /* function_decl */
330 sdbout_global_decl
, /* global_decl */
331 debug_nothing_tree
, /* deferred_inline_function */
332 debug_nothing_tree
, /* outlining_inline_function */
338 /* return the tag identifier for type
342 tag_of_ru_type (type
,link
)
345 if (TYPE_SYMTAB_ADDRESS (type
))
346 return TYPE_SYMTAB_ADDRESS (type
);
347 if (link
&& TREE_PURPOSE (link
)
348 && IDENTIFIER_POINTER (TREE_PURPOSE (link
)))
349 TYPE_SYMTAB_ADDRESS (type
) = IDENTIFIER_POINTER (TREE_PURPOSE (link
));
351 return (char *) TYPE_SYMTAB_ADDRESS (type
);
355 /* Return a unique string to name an anonymous type. */
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;
403 int val
= plain_type_1 (type
, 0);
405 /* If we have already saved up some array dimensions, print them now. */
410 for (i
= sdb_n_dims
- 1; i
> 0; i
--)
411 PUT_SDB_NEXT_DIM (sdb_dims
[i
]);
412 PUT_SDB_LAST_DIM (sdb_dims
[0]);
415 sdb_type_size
= int_size_in_bytes (type
);
416 /* Don't kill sdb if type is not laid out or has variable size. */
417 if (sdb_type_size
< 0)
420 /* If we have computed the size of an array containing this type,
422 if (sdb_type_size
>= 0)
424 PUT_SDB_SIZE (sdb_type_size
);
431 template_name_p (name
)
434 const char *ptr
= IDENTIFIER_POINTER (name
);
435 while (*ptr
&& *ptr
!= '<')
442 sdbout_record_type_name (type
)
445 const char *name
= 0;
448 if (KNOWN_TYPE_TAG (type
))
451 if (TYPE_NAME (type
) != 0)
455 /* Find the IDENTIFIER_NODE for the type name. */
456 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
457 t
= TYPE_NAME (type
);
458 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
460 t
= DECL_NAME (TYPE_NAME (type
));
461 /* The DECL_NAME for templates includes "<>", which breaks
462 most assemblers. Use its assembler name instead, which
463 has been mangled into being safe. */
464 if (t
&& template_name_p (t
))
465 t
= DECL_ASSEMBLER_NAME (TYPE_NAME (type
));
468 /* Now get the name as a string, or invent one. */
470 name
= IDENTIFIER_POINTER (t
);
473 no_name
= (name
== 0 || *name
== 0);
475 name
= gen_fake_label ();
477 SET_KNOWN_TYPE_TAG (type
, name
);
478 #ifdef SDB_ALLOW_FORWARD_REFERENCES
480 sdbout_queue_anonymous_type (type
);
484 /* Return the .type value for type TYPE.
486 LEVEL indicates how many levels deep we have recursed into the type.
487 The SDB debug format can only represent 6 derived levels of types.
488 After that, we must output inaccurate debug info. We deliberately
489 stop before the 7th level, so that ADA recursive types will not give an
493 plain_type_1 (type
, level
)
498 type
= void_type_node
;
499 else if (type
== error_mark_node
)
500 type
= integer_type_node
;
502 type
= TYPE_MAIN_VARIANT (type
);
504 switch (TREE_CODE (type
))
511 int size
= int_size_in_bytes (type
) * BITS_PER_UNIT
;
513 /* Carefully distinguish all the standard types of C,
514 without messing up if the language is not C.
515 Note that we check only for the names that contain spaces;
516 other names might occur by coincidence in other languages. */
517 if (TYPE_NAME (type
) != 0
518 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
519 && DECL_NAME (TYPE_NAME (type
)) != 0
520 && TREE_CODE (DECL_NAME (TYPE_NAME (type
))) == IDENTIFIER_NODE
)
522 const char *const name
523 = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
525 if (!strcmp (name
, "char"))
527 if (!strcmp (name
, "unsigned char"))
529 if (!strcmp (name
, "signed char"))
531 if (!strcmp (name
, "int"))
533 if (!strcmp (name
, "unsigned int"))
535 if (!strcmp (name
, "short int"))
537 if (!strcmp (name
, "short unsigned int"))
539 if (!strcmp (name
, "long int"))
541 if (!strcmp (name
, "long unsigned int"))
545 if (size
== INT_TYPE_SIZE
)
546 return (TREE_UNSIGNED (type
) ? T_UINT
: T_INT
);
547 if (size
== CHAR_TYPE_SIZE
)
548 return (TREE_UNSIGNED (type
) ? T_UCHAR
: T_CHAR
);
549 if (size
== SHORT_TYPE_SIZE
)
550 return (TREE_UNSIGNED (type
) ? T_USHORT
: T_SHORT
);
551 if (size
== LONG_TYPE_SIZE
)
552 return (TREE_UNSIGNED (type
) ? T_ULONG
: T_LONG
);
553 if (size
== LONG_LONG_TYPE_SIZE
) /* better than nothing */
554 return (TREE_UNSIGNED (type
) ? T_ULONG
: T_LONG
);
560 int precision
= TYPE_PRECISION (type
);
561 if (precision
== FLOAT_TYPE_SIZE
)
563 if (precision
== DOUBLE_TYPE_SIZE
)
565 #ifdef EXTENDED_SDB_BASIC_TYPES
566 if (precision
== LONG_DOUBLE_TYPE_SIZE
)
569 if (precision
== LONG_DOUBLE_TYPE_SIZE
)
570 return T_DOUBLE
; /* better than nothing */
581 m
= plain_type_1 (TREE_TYPE (type
), level
+1);
582 if (sdb_n_dims
< SDB_MAX_DIM
)
583 sdb_dims
[sdb_n_dims
++]
584 = (TYPE_DOMAIN (type
)
585 && TYPE_MIN_VALUE (TYPE_DOMAIN (type
)) != 0
586 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != 0
587 && host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)), 0)
588 && host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)), 0)
589 ? (tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)), 0)
590 - tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)), 0) + 1)
593 return PUSH_DERIVED_LEVEL (DT_ARY
, m
);
598 case QUAL_UNION_TYPE
:
602 #ifdef SDB_ALLOW_FORWARD_REFERENCES
603 sdbout_record_type_name (type
);
605 #ifndef SDB_ALLOW_UNKNOWN_REFERENCES
606 if ((TREE_ASM_WRITTEN (type
) && KNOWN_TYPE_TAG (type
) != 0)
607 #ifdef SDB_ALLOW_FORWARD_REFERENCES
608 || TYPE_MODE (type
) != VOIDmode
613 /* Output the referenced structure tag name
614 only if the .def has already been finished.
615 At least on 386, the Unix assembler
616 cannot handle forward references to tags. */
617 /* But the 88100, it requires them, sigh... */
618 /* And the MIPS requires unknown refs as well... */
619 tag
= KNOWN_TYPE_TAG (type
);
621 /* These 3 lines used to follow the close brace.
622 However, a size of 0 without a tag implies a tag of 0,
623 so if we don't know a tag, we can't mention the size. */
624 sdb_type_size
= int_size_in_bytes (type
);
625 if (sdb_type_size
< 0)
628 return ((TREE_CODE (type
) == RECORD_TYPE
) ? T_STRUCT
629 : (TREE_CODE (type
) == UNION_TYPE
) ? T_UNION
630 : (TREE_CODE (type
) == QUAL_UNION_TYPE
) ? T_UNION
640 m
= plain_type_1 (TREE_TYPE (type
), level
+1);
641 return PUSH_DERIVED_LEVEL (DT_PTR
, m
);
650 m
= plain_type_1 (TREE_TYPE (type
), level
+1);
651 return PUSH_DERIVED_LEVEL (DT_FCN
, m
);
658 /* Output the symbols defined in block number DO_BLOCK.
660 This function works by walking the tree structure of blocks,
661 counting blocks until it finds the desired block. */
663 static int do_block
= 0;
671 /* Ignore blocks never expanded or otherwise marked as real. */
672 if (TREE_USED (block
))
674 /* When we reach the specified block, output its symbols. */
675 if (BLOCK_NUMBER (block
) == do_block
)
676 sdbout_syms (BLOCK_VARS (block
));
678 /* If we are past the specified block, stop the scan. */
679 if (BLOCK_NUMBER (block
) > do_block
)
682 /* Scan the blocks within this block. */
683 sdbout_block (BLOCK_SUBBLOCKS (block
));
686 block
= BLOCK_CHAIN (block
);
690 /* Call sdbout_symbol on each decl in the chain SYMS. */
698 if (TREE_CODE (syms
) != LABEL_DECL
)
699 sdbout_symbol (syms
, 1);
700 syms
= TREE_CHAIN (syms
);
704 /* Output SDB information for a symbol described by DECL.
705 LOCAL is nonzero if the symbol is not file-scope. */
708 sdbout_symbol (decl
, local
)
712 tree type
= TREE_TYPE (decl
);
713 tree context
= NULL_TREE
;
718 sdbout_one_type (type
);
720 #if 0 /* This loses when functions are marked to be ignored,
721 which happens in the C++ front end. */
722 if (DECL_IGNORED_P (decl
))
726 switch (TREE_CODE (decl
))
729 /* Enum values are defined by defining the enum type. */
733 /* Don't mention a nested function under its parent. */
734 context
= decl_function_context (decl
);
735 if (context
== current_function_decl
)
737 /* Check DECL_INITIAL to distinguish declarations from definitions.
738 Don't output debug info here for declarations; they will have
739 a DECL_INITIAL value of 0. */
740 if (! DECL_INITIAL (decl
))
742 if (GET_CODE (DECL_RTL (decl
)) != MEM
743 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
745 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
746 PUT_SDB_VAL (XEXP (DECL_RTL (decl
), 0));
747 PUT_SDB_SCL (TREE_PUBLIC (decl
) ? C_EXT
: C_STAT
);
751 /* Done with tagged types. */
752 if (DECL_NAME (decl
) == 0)
754 if (DECL_IGNORED_P (decl
))
757 /* Output typedef name. */
758 if (template_name_p (DECL_NAME (decl
)))
759 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
761 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_NAME (decl
)));
762 PUT_SDB_SCL (C_TPDEF
);
766 /* Parm decls go in their own separate chains
767 and are output by sdbout_reg_parms and sdbout_parms. */
771 /* Don't mention a variable that is external.
772 Let the file that defines it describe it. */
773 if (DECL_EXTERNAL (decl
))
776 /* Ignore __FUNCTION__, etc. */
777 if (DECL_IGNORED_P (decl
))
780 /* If there was an error in the declaration, don't dump core
781 if there is no RTL associated with the variable doesn't
783 if (!DECL_RTL_SET_P (decl
))
787 eliminate_regs (DECL_RTL (decl
), 0, NULL_RTX
));
788 #ifdef LEAF_REG_REMAP
789 if (current_function_uses_only_leaf_regs
)
790 leaf_renumber_regs_insn (DECL_RTL (decl
));
792 value
= DECL_RTL (decl
);
794 /* Don't mention a variable at all
795 if it was completely optimized into nothingness.
797 If DECL was from an inline function, then its rtl
798 is not identically the rtl that was used in this
799 particular compilation. */
800 if (GET_CODE (value
) == REG
)
802 regno
= REGNO (value
);
803 if (regno
>= FIRST_PSEUDO_REGISTER
)
806 else if (GET_CODE (value
) == SUBREG
)
808 while (GET_CODE (value
) == SUBREG
)
809 value
= SUBREG_REG (value
);
810 if (GET_CODE (value
) == REG
)
812 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
815 regno
= REGNO (alter_subreg (&value
));
816 SET_DECL_RTL (decl
, value
);
818 /* Don't output anything if an auto variable
819 gets RTL that is static.
820 GAS version 2.2 can't handle such output. */
821 else if (GET_CODE (value
) == MEM
&& CONSTANT_P (XEXP (value
, 0))
822 && ! TREE_STATIC (decl
))
825 /* Emit any structure, union, or enum type that has not been output.
826 This occurs for tag-less structs (et al) used to declare variables
828 if (TREE_CODE (type
) == ENUMERAL_TYPE
829 || TREE_CODE (type
) == RECORD_TYPE
830 || TREE_CODE (type
) == UNION_TYPE
831 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
833 if (COMPLETE_TYPE_P (type
) /* not a forward reference */
834 && KNOWN_TYPE_TAG (type
) == 0) /* not yet declared */
835 sdbout_one_type (type
);
838 /* Defer SDB information for top-level initialized variables! */
840 && GET_CODE (value
) == MEM
841 && DECL_INITIAL (decl
))
844 /* C++ in 2.3 makes nameless symbols. That will be fixed later.
845 For now, avoid crashing. */
846 if (DECL_NAME (decl
) == NULL_TREE
)
849 /* Record the name for, starting a symtab entry. */
851 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
853 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
855 if (GET_CODE (value
) == MEM
856 && GET_CODE (XEXP (value
, 0)) == SYMBOL_REF
)
859 if (TREE_PUBLIC (decl
))
861 PUT_SDB_VAL (XEXP (value
, 0));
866 PUT_SDB_VAL (XEXP (value
, 0));
867 PUT_SDB_SCL (C_STAT
);
873 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (regno
));
876 else if (GET_CODE (value
) == MEM
877 && (GET_CODE (XEXP (value
, 0)) == MEM
878 || (GET_CODE (XEXP (value
, 0)) == REG
879 && REGNO (XEXP (value
, 0)) != HARD_FRAME_POINTER_REGNUM
880 && REGNO (XEXP (value
, 0)) != STACK_POINTER_REGNUM
)))
881 /* If the value is indirect by memory or by a register
882 that isn't the frame pointer
883 then it means the object is variable-sized and address through
884 that register or stack slot. COFF has no way to represent this
885 so all we can do is output the variable as a pointer. */
888 if (GET_CODE (XEXP (value
, 0)) == REG
)
890 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (XEXP (value
, 0))));
895 /* DECL_RTL looks like (MEM (MEM (PLUS (REG...)
897 We want the value of that CONST_INT. */
898 /* Encore compiler hates a newline in a macro arg, it seems. */
899 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
900 (XEXP (XEXP (value
, 0), 0)));
901 PUT_SDB_SCL (C_AUTO
);
904 /* Effectively do build_pointer_type, but don't cache this type,
905 since it might be temporary whereas the type it points to
906 might have been saved for inlining. */
907 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
908 type
= make_node (POINTER_TYPE
);
909 TREE_TYPE (type
) = TREE_TYPE (decl
);
911 else if (GET_CODE (value
) == MEM
912 && ((GET_CODE (XEXP (value
, 0)) == PLUS
913 && GET_CODE (XEXP (XEXP (value
, 0), 0)) == REG
914 && GET_CODE (XEXP (XEXP (value
, 0), 1)) == CONST_INT
)
915 /* This is for variables which are at offset zero from
916 the frame pointer. This happens on the Alpha.
917 Non-frame pointer registers are excluded above. */
918 || (GET_CODE (XEXP (value
, 0)) == REG
)))
920 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
921 or (MEM (REG...)). We want the value of that CONST_INT
924 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET (XEXP (value
, 0)));
925 PUT_SDB_SCL (C_AUTO
);
927 else if (GET_CODE (value
) == MEM
&& GET_CODE (XEXP (value
, 0)) == CONST
)
929 /* Handle an obscure case which can arise when optimizing and
930 when there are few available registers. (This is *always*
931 the case for i386/i486 targets). The DECL_RTL looks like
932 (MEM (CONST ...)) even though this variable is a local `auto'
933 or a local `register' variable. In effect, what has happened
934 is that the reload pass has seen that all assignments and
935 references for one such a local variable can be replaced by
936 equivalent assignments and references to some static storage
937 variable, thereby avoiding the need for a register. In such
938 cases we're forced to lie to debuggers and tell them that
939 this variable was itself `static'. */
941 PUT_SDB_VAL (XEXP (XEXP (value
, 0), 0));
942 PUT_SDB_SCL (C_STAT
);
946 /* It is something we don't know how to represent for SDB. */
954 PUT_SDB_TYPE (plain_type (type
));
958 /* Output SDB information for a top-level initialized variable
959 that has been delayed. */
962 sdbout_toplevel_data (decl
)
965 tree type
= TREE_TYPE (decl
);
967 if (DECL_IGNORED_P (decl
))
970 if (! (TREE_CODE (decl
) == VAR_DECL
971 && GET_CODE (DECL_RTL (decl
)) == MEM
972 && DECL_INITIAL (decl
)))
975 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
976 PUT_SDB_VAL (XEXP (DECL_RTL (decl
), 0));
977 if (TREE_PUBLIC (decl
))
983 PUT_SDB_SCL (C_STAT
);
985 PUT_SDB_TYPE (plain_type (type
));
989 #ifdef SDB_ALLOW_FORWARD_REFERENCES
991 /* Machinery to record and output anonymous types. */
994 sdbout_queue_anonymous_type (type
)
997 anonymous_types
= tree_cons (NULL_TREE
, type
, anonymous_types
);
1001 sdbout_dequeue_anonymous_types ()
1005 while (anonymous_types
)
1007 types
= nreverse (anonymous_types
);
1008 anonymous_types
= NULL_TREE
;
1010 for (link
= types
; link
; link
= TREE_CHAIN (link
))
1012 tree type
= TREE_VALUE (link
);
1014 if (type
&& ! TREE_ASM_WRITTEN (type
))
1015 sdbout_one_type (type
);
1022 /* Given a chain of ..._TYPE nodes, all of which have names,
1023 output definitions of those names, as typedefs. */
1026 sdbout_types (types
)
1031 for (link
= types
; link
; link
= TREE_CHAIN (link
))
1032 sdbout_one_type (link
);
1034 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1035 sdbout_dequeue_anonymous_types ();
1043 if (type
== error_mark_node
)
1044 type
= integer_type_node
;
1045 PUT_SDB_TYPE (plain_type (type
));
1048 /* Output types of the fields of type TYPE, if they are structs.
1050 Formerly did not chase through pointer types, since that could be circular.
1051 They must come before TYPE, since forward refs are not allowed.
1052 Now james@bigtex.cactus.org says to try them. */
1055 sdbout_field_types (type
)
1060 for (tail
= TYPE_FIELDS (type
); tail
; tail
= TREE_CHAIN (tail
))
1061 /* This condition should match the one for emitting the actual
1063 if (TREE_CODE (tail
) == FIELD_DECL
1066 && host_integerp (DECL_SIZE (tail
), 1)
1067 && host_integerp (bit_position (tail
), 0))
1069 if (POINTER_TYPE_P (TREE_TYPE (tail
)))
1070 sdbout_one_type (TREE_TYPE (TREE_TYPE (tail
)));
1072 sdbout_one_type (TREE_TYPE (tail
));
1076 /* Use this to put out the top level defined record and union types
1077 for later reference. If this is a struct with a name, then put that
1078 name out. Other unnamed structs will have .xxfake labels generated so
1079 that they may be referred to later.
1080 The label will be stored in the KNOWN_TYPE_TAG slot of a type.
1081 It may NOT be called recursively. */
1084 sdbout_one_type (type
)
1087 if (current_function_decl
!= NULL_TREE
1088 && DECL_SECTION_NAME (current_function_decl
) != NULL_TREE
)
1089 ; /* Don't change section amid function. */
1093 switch (TREE_CODE (type
))
1097 case QUAL_UNION_TYPE
:
1099 type
= TYPE_MAIN_VARIANT (type
);
1100 /* Don't output a type twice. */
1101 if (TREE_ASM_WRITTEN (type
))
1102 /* James said test TREE_ASM_BEING_WRITTEN here. */
1105 /* Output nothing if type is not yet defined. */
1106 if (!COMPLETE_TYPE_P (type
))
1109 TREE_ASM_WRITTEN (type
) = 1;
1111 /* This is reputed to cause trouble with the following case,
1112 but perhaps checking TYPE_SIZE above will fix it. */
1114 /* Here is a test case:
1120 typedef struct intermediate {
1124 typedef struct badstr {
1129 TREE_ASM_BEING_WRITTEN (type
) = 1;
1131 /* This change, which ought to make better output,
1132 used to make the COFF assembler unhappy.
1133 Changes involving KNOWN_TYPE_TAG may fix the problem. */
1134 /* Before really doing anything, output types we want to refer to. */
1135 /* Note that in version 1 the following two lines
1136 are not used if forward references are in use. */
1137 if (TREE_CODE (type
) != ENUMERAL_TYPE
)
1138 sdbout_field_types (type
);
1140 TREE_ASM_WRITTEN (type
) = 1;
1144 /* Output a structure type. */
1146 int size
= int_size_in_bytes (type
);
1149 int i
, n_baseclasses
= 0;
1151 /* Record the type tag, but not in its permanent place just yet. */
1152 sdbout_record_type_name (type
);
1154 PUT_SDB_DEF (KNOWN_TYPE_TAG (type
));
1156 switch (TREE_CODE (type
))
1159 case QUAL_UNION_TYPE
:
1160 PUT_SDB_SCL (C_UNTAG
);
1161 PUT_SDB_TYPE (T_UNION
);
1166 PUT_SDB_SCL (C_STRTAG
);
1167 PUT_SDB_TYPE (T_STRUCT
);
1172 PUT_SDB_SCL (C_ENTAG
);
1173 PUT_SDB_TYPE (T_ENUM
);
1181 PUT_SDB_SIZE (size
);
1184 /* Print out the base class information with fields
1185 named after the types they hold. */
1186 /* This is only relevant to aggregate types. TYPE_BINFO is used
1187 for other purposes in an ENUMERAL_TYPE, so we must exclude that
1189 if (TREE_CODE (type
) != ENUMERAL_TYPE
)
1191 if (TYPE_BINFO (type
)
1192 && TYPE_BINFO_BASETYPES (type
))
1193 n_baseclasses
= TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
));
1194 for (i
= 0; i
< n_baseclasses
; i
++)
1196 tree child
= TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type
)),
1198 tree child_type
= BINFO_TYPE (child
);
1199 tree child_type_name
;
1200 if (TYPE_NAME (child_type
) == 0)
1202 if (TREE_CODE (TYPE_NAME (child_type
)) == IDENTIFIER_NODE
)
1203 child_type_name
= TYPE_NAME (child_type
);
1204 else if (TREE_CODE (TYPE_NAME (child_type
)) == TYPE_DECL
)
1206 child_type_name
= DECL_NAME (TYPE_NAME (child_type
));
1207 if (child_type_name
&& template_name_p (child_type_name
))
1209 = DECL_ASSEMBLER_NAME (TYPE_NAME (child_type
));
1215 PUT_SDB_DEF (IDENTIFIER_POINTER (child_type_name
));
1216 PUT_SDB_INT_VAL (tree_low_cst (BINFO_OFFSET (child
), 0));
1217 PUT_SDB_SCL (member_scl
);
1218 sdbout_type (BINFO_TYPE (child
));
1223 /* output the individual fields */
1225 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
1227 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
1228 if (host_integerp (TREE_VALUE (tem
), 0))
1230 PUT_SDB_DEF (IDENTIFIER_POINTER (TREE_PURPOSE (tem
)));
1231 PUT_SDB_INT_VAL (tree_low_cst (TREE_VALUE (tem
), 0));
1232 PUT_SDB_SCL (C_MOE
);
1233 PUT_SDB_TYPE (T_MOE
);
1237 else /* record or union type */
1238 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
1239 /* Output the name, type, position (in bits), size (in bits)
1242 /* Omit here the nameless fields that are used to skip bits.
1243 Also omit fields with variable size or position.
1244 Also omit non FIELD_DECL nodes that GNU C++ may put here. */
1245 if (TREE_CODE (tem
) == FIELD_DECL
1248 && host_integerp (DECL_SIZE (tem
), 1)
1249 && host_integerp (bit_position (tem
), 0))
1254 name
= IDENTIFIER_POINTER (DECL_NAME (tem
));
1256 if (DECL_BIT_FIELD_TYPE (tem
))
1258 PUT_SDB_INT_VAL (int_bit_position (tem
));
1259 PUT_SDB_SCL (C_FIELD
);
1260 sdbout_type (DECL_BIT_FIELD_TYPE (tem
));
1261 PUT_SDB_SIZE (tree_low_cst (DECL_SIZE (tem
), 1));
1265 PUT_SDB_INT_VAL (int_bit_position (tem
) / BITS_PER_UNIT
);
1266 PUT_SDB_SCL (member_scl
);
1267 sdbout_type (TREE_TYPE (tem
));
1271 /* output end of a structure,union, or enumeral definition */
1273 PUT_SDB_PLAIN_DEF ("eos");
1274 PUT_SDB_INT_VAL (size
);
1275 PUT_SDB_SCL (C_EOS
);
1276 PUT_SDB_TAG (KNOWN_TYPE_TAG (type
));
1277 PUT_SDB_SIZE (size
);
1287 /* The following two functions output definitions of function parameters.
1288 Each parameter gets a definition locating it in the parameter list.
1289 Each parameter that is a register variable gets a second definition
1290 locating it in the register.
1292 Printing or argument lists in gdb uses the definitions that
1293 locate in the parameter list. But reference to the variable in
1294 expressions uses preferentially the definition as a register. */
1296 /* Output definitions, referring to storage in the parmlist,
1297 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
1300 sdbout_parms (parms
)
1303 for (; parms
; parms
= TREE_CHAIN (parms
))
1304 if (DECL_NAME (parms
))
1306 int current_sym_value
= 0;
1307 const char *name
= IDENTIFIER_POINTER (DECL_NAME (parms
));
1309 if (name
== 0 || *name
== 0)
1310 name
= gen_fake_label ();
1312 /* Perform any necessary register eliminations on the parameter's rtl,
1313 so that the debugging output will be accurate. */
1314 DECL_INCOMING_RTL (parms
)
1315 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
1316 SET_DECL_RTL (parms
,
1317 eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
));
1319 if (PARM_PASSED_IN_MEMORY (parms
))
1321 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
1324 /* ??? Here we assume that the parm address is indexed
1325 off the frame pointer or arg pointer.
1326 If that is not true, we produce meaningless results,
1327 but do not crash. */
1328 if (GET_CODE (addr
) == PLUS
1329 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
1330 current_sym_value
= INTVAL (XEXP (addr
, 1));
1332 current_sym_value
= 0;
1334 if (GET_CODE (DECL_RTL (parms
)) == REG
1335 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
1336 type
= DECL_ARG_TYPE (parms
);
1339 int original_sym_value
= current_sym_value
;
1341 /* This is the case where the parm is passed as an int or
1342 double and it is converted to a char, short or float
1343 and stored back in the parmlist. In this case, describe
1344 the parm with the variable's declared type, and adjust
1345 the address if the least significant bytes (which we are
1346 using) are not the first ones. */
1347 if (BYTES_BIG_ENDIAN
1348 && TREE_TYPE (parms
) != DECL_ARG_TYPE (parms
))
1349 current_sym_value
+=
1350 (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms
)))
1351 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
))));
1353 if (GET_CODE (DECL_RTL (parms
)) == MEM
1354 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == PLUS
1355 && (GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 1))
1357 && (INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1))
1358 == current_sym_value
))
1359 type
= TREE_TYPE (parms
);
1362 current_sym_value
= original_sym_value
;
1363 type
= DECL_ARG_TYPE (parms
);
1368 PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value
, addr
));
1369 PUT_SDB_SCL (C_ARG
);
1370 PUT_SDB_TYPE (plain_type (type
));
1373 else if (GET_CODE (DECL_RTL (parms
)) == REG
)
1376 /* Parm passed in registers and lives in registers or nowhere. */
1378 /* If parm lives in a register, use that register;
1379 pretend the parm was passed there. It would be more consistent
1380 to describe the register where the parm was passed,
1381 but in practice that register usually holds something else. */
1382 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
1383 best_rtl
= DECL_RTL (parms
);
1384 /* If the parm lives nowhere,
1385 use the register where it was passed. */
1387 best_rtl
= DECL_INCOMING_RTL (parms
);
1390 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (best_rtl
)));
1391 PUT_SDB_SCL (C_REGPARM
);
1392 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms
)));
1395 else if (GET_CODE (DECL_RTL (parms
)) == MEM
1396 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
)
1398 /* Parm was passed in registers but lives on the stack. */
1400 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
1401 in which case we want the value of that CONST_INT,
1402 or (MEM (REG ...)) or (MEM (MEM ...)),
1403 in which case we use a value of zero. */
1404 if (GET_CODE (XEXP (DECL_RTL (parms
), 0)) == REG
1405 || GET_CODE (XEXP (DECL_RTL (parms
), 0)) == MEM
)
1406 current_sym_value
= 0;
1408 current_sym_value
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
1410 /* Again, this assumes the offset is based on the arg pointer. */
1412 PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value
,
1413 XEXP (DECL_RTL (parms
), 0)));
1414 PUT_SDB_SCL (C_ARG
);
1415 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms
)));
1421 /* Output definitions for the places where parms live during the function,
1422 when different from where they were passed, when the parms were passed
1425 It is not useful to do this for parms passed in registers
1426 that live during the function in different registers, because it is
1427 impossible to look in the passed register for the passed value,
1428 so we use the within-the-function register to begin with.
1430 PARMS is a chain of PARM_DECL nodes. */
1433 sdbout_reg_parms (parms
)
1436 for (; parms
; parms
= TREE_CHAIN (parms
))
1437 if (DECL_NAME (parms
))
1439 const char *name
= IDENTIFIER_POINTER (DECL_NAME (parms
));
1441 /* Report parms that live in registers during the function
1442 but were passed in memory. */
1443 if (GET_CODE (DECL_RTL (parms
)) == REG
1444 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
1445 && PARM_PASSED_IN_MEMORY (parms
))
1447 if (name
== 0 || *name
== 0)
1448 name
= gen_fake_label ();
1450 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms
))));
1451 PUT_SDB_SCL (C_REG
);
1452 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms
)));
1455 /* Report parms that live in memory but not where they were passed. */
1456 else if (GET_CODE (DECL_RTL (parms
)) == MEM
1457 && GET_CODE (XEXP (DECL_RTL (parms
), 0)) == PLUS
1458 && GET_CODE (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) == CONST_INT
1459 && PARM_PASSED_IN_MEMORY (parms
)
1460 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
1462 #if 0 /* ??? It is not clear yet what should replace this. */
1463 int offset
= DECL_OFFSET (parms
) / BITS_PER_UNIT
;
1464 /* A parm declared char is really passed as an int,
1465 so it occupies the least significant bytes.
1466 On a big-endian machine those are not the low-numbered ones. */
1467 if (BYTES_BIG_ENDIAN
1469 && TREE_TYPE (parms
) != DECL_ARG_TYPE (parms
))
1470 offset
+= (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms
)))
1471 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
))));
1472 if (INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1)) != offset
) {...}
1475 if (name
== 0 || *name
== 0)
1476 name
= gen_fake_label ();
1478 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
1479 (XEXP (DECL_RTL (parms
), 0)));
1480 PUT_SDB_SCL (C_AUTO
);
1481 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms
)));
1488 /* Output debug information for a global DECL. Called from toplev.c
1489 after compilation proper has finished. */
1492 sdbout_global_decl (decl
)
1495 if (TREE_CODE (decl
) == VAR_DECL
1496 && !DECL_EXTERNAL (decl
)
1497 && DECL_RTL_SET_P (decl
))
1499 /* The COFF linker can move initialized global vars to the end.
1500 And that can screw up the symbol ordering. Defer those for
1501 sdbout_finish (). */
1502 if (!DECL_INITIAL (decl
) || !TREE_PUBLIC (decl
))
1503 sdbout_symbol (decl
, 0);
1505 /* Output COFF information for non-global file-scope initialized
1507 if (DECL_INITIAL (decl
) && GET_CODE (DECL_RTL (decl
)) == MEM
)
1508 sdbout_toplevel_data (decl
);
1512 /* Output initialized global vars at the end, in the order of
1513 definition. See comment in sdbout_global_decl. */
1516 sdbout_finish (main_filename
)
1517 const char *main_filename ATTRIBUTE_UNUSED
;
1519 tree decl
= (*lang_hooks
.decls
.getdecls
) ();
1520 unsigned int len
= list_length (decl
);
1521 tree
*vec
= (tree
*) xmalloc (sizeof (tree
) * len
);
1524 /* Process the decls in reverse order--earliest first. Put them
1525 into VEC from back to front, then take out from front. */
1527 for (i
= 0; i
< len
; i
++, decl
= TREE_CHAIN (decl
))
1528 vec
[len
- i
- 1] = decl
;
1530 for (i
= 0; i
< len
; i
++)
1533 if (TREE_CODE (decl
) == VAR_DECL
1534 && ! DECL_EXTERNAL (decl
)
1535 && DECL_INITIAL (decl
)
1536 && TREE_PUBLIC (decl
)
1537 && DECL_RTL_SET_P (decl
))
1538 sdbout_symbol (decl
, 0);
1544 /* Describe the beginning of an internal block within a function.
1545 Also output descriptions of variables defined in this block.
1547 N is the number of the block, by order of beginning, counting from 1,
1548 and not counting the outermost (function top-level) block.
1549 The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
1550 if the count starts at 0 for the outermost one. */
1553 sdbout_begin_block (line
, n
)
1557 tree decl
= current_function_decl
;
1558 MAKE_LINE_SAFE (line
);
1560 /* The SCO compiler does not emit a separate block for the function level
1561 scope, so we avoid it here also. However, mips ECOFF compilers do emit
1562 a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined. */
1563 #ifndef MIPS_DEBUGGING_INFO
1566 PUT_SDB_BLOCK_START (line
- sdb_begin_function_line
);
1570 /* Include the outermost BLOCK's variables in block 1. */
1571 do_block
= BLOCK_NUMBER (DECL_INITIAL (decl
));
1572 sdbout_block (DECL_INITIAL (decl
));
1574 /* If -g1, suppress all the internal symbols of functions
1575 except for arguments. */
1576 if (debug_info_level
!= DINFO_LEVEL_TERSE
)
1579 sdbout_block (DECL_INITIAL (decl
));
1582 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1583 sdbout_dequeue_anonymous_types ();
1587 /* Describe the end line-number of an internal block within a function. */
1590 sdbout_end_block (line
, n
)
1592 unsigned int n ATTRIBUTE_UNUSED
;
1594 MAKE_LINE_SAFE (line
);
1596 /* The SCO compiler does not emit a separate block for the function level
1597 scope, so we avoid it here also. However, mips ECOFF compilers do emit
1598 a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined. */
1599 #ifndef MIPS_DEBUGGING_INFO
1602 PUT_SDB_BLOCK_END (line
- sdb_begin_function_line
);
1606 sdbout_source_line (line
, filename
)
1608 const char *filename ATTRIBUTE_UNUSED
;
1610 /* COFF relative line numbers must be positive. */
1611 if ((int) line
> sdb_begin_function_line
)
1613 #ifdef ASM_OUTPUT_SOURCE_LINE
1614 ASM_OUTPUT_SOURCE_LINE (asm_out_file
, line
);
1616 fprintf (asm_out_file
, "\t.ln\t%d\n",
1617 ((sdb_begin_function_line
> -1)
1618 ? line
- sdb_begin_function_line
: 1));
1623 /* Output sdb info for the current function name.
1624 Called from assemble_start_function. */
1627 sdbout_begin_function (decl
)
1628 tree decl ATTRIBUTE_UNUSED
;
1630 sdbout_symbol (current_function_decl
, 0);
1633 /* Called at beginning of function body (before or after prologue,
1634 depending on MIPS_DEBUGGING_INFO). Record the function's starting
1635 line number, so we can output relative line numbers for the other
1636 lines. Describe beginning of outermost block. Also describe the
1639 #ifndef MIPS_DEBUGGING_INFO
1641 sdbout_begin_prologue (line
, file
)
1643 const char *file ATTRIBUTE_UNUSED
;
1645 sdbout_end_prologue (line
);
1650 sdbout_end_prologue (line
)
1653 sdb_begin_function_line
= line
- 1;
1654 PUT_SDB_FUNCTION_START (line
);
1655 sdbout_parms (DECL_ARGUMENTS (current_function_decl
));
1656 sdbout_reg_parms (DECL_ARGUMENTS (current_function_decl
));
1659 /* Called at end of function (before epilogue).
1660 Describe end of outermost block. */
1663 sdbout_end_function (line
)
1666 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1667 sdbout_dequeue_anonymous_types ();
1670 MAKE_LINE_SAFE (line
);
1671 PUT_SDB_FUNCTION_END (line
- sdb_begin_function_line
);
1673 /* Indicate we are between functions, for line-number output. */
1674 sdb_begin_function_line
= -1;
1677 /* Output sdb info for the absolute end of a function.
1678 Called after the epilogue is output. */
1681 sdbout_end_epilogue ()
1683 const char *const name ATTRIBUTE_UNUSED
1684 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
));
1686 #ifdef PUT_SDB_EPILOGUE_END
1687 PUT_SDB_EPILOGUE_END (name
);
1689 fprintf (asm_out_file
, "\t.def\t");
1690 assemble_name (asm_out_file
, name
);
1691 fprintf (asm_out_file
, "%s\t.val\t.%s\t.scl\t-1%s\t.endef\n",
1692 SDB_DELIM
, SDB_DELIM
, SDB_DELIM
);
1696 /* Output sdb info for the given label. Called only if LABEL_NAME (insn)
1703 PUT_SDB_DEF (LABEL_NAME (insn
));
1705 PUT_SDB_SCL (C_LABEL
);
1706 PUT_SDB_TYPE (T_NULL
);
1710 /* Change to reading from a new source file. */
1713 sdbout_start_source_file (line
, filename
)
1714 unsigned int line ATTRIBUTE_UNUSED
;
1715 const char *filename ATTRIBUTE_UNUSED
;
1717 #ifdef MIPS_DEBUGGING_INFO
1718 struct sdb_file
*n
= (struct sdb_file
*) xmalloc (sizeof *n
);
1720 n
->next
= current_file
;
1723 PUT_SDB_SRC_FILE (filename
);
1727 /* Revert to reading a previous source file. */
1730 sdbout_end_source_file (line
)
1731 unsigned int line ATTRIBUTE_UNUSED
;
1733 #ifdef MIPS_DEBUGGING_INFO
1734 struct sdb_file
*next
;
1736 next
= current_file
->next
;
1737 free (current_file
);
1738 current_file
= next
;
1739 PUT_SDB_SRC_FILE (current_file
->name
);
1743 /* Set up for SDB output at the start of compilation. */
1746 sdbout_init (input_file_name
)
1747 const char *input_file_name ATTRIBUTE_UNUSED
;
1749 #ifdef MIPS_DEBUGGING_INFO
1750 current_file
= (struct sdb_file
*) xmalloc (sizeof *current_file
);
1751 current_file
->next
= NULL
;
1752 current_file
->name
= input_file_name
;
1755 #ifdef RMS_QUICK_HACK_1
1757 for (t
= (*lang_hooks
.decls
.getdecls
) (); t
; t
= TREE_CHAIN (t
))
1758 if (DECL_NAME (t
) && IDENTIFIER_POINTER (DECL_NAME (t
)) != 0
1759 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (t
)), "__vtbl_ptr_type"))
1760 sdbout_symbol (t
, 0);
1764 #else /* SDB_DEBUGGING_INFO */
1766 /* This should never be used, but its address is needed for comparisons. */
1767 const struct gcc_debug_hooks sdb_debug_hooks
;
1769 #endif /* SDB_DEBUGGING_INFO */
1771 #include "gt-sdbout.h"