Daily bump.
[official-gcc.git] / gcc / sdbout.c
blob91a7a2cc256e5516b30b0fbefc2ca12b12174a09
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
10 version.
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
15 for more details.
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
20 02111-1307, USA. */
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
28 function.
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.
44 #include "config.h"
45 #include "system.h"
46 #include "coretypes.h"
47 #include "tm.h"
48 #include "debug.h"
49 #include "tree.h"
50 #include "ggc.h"
51 #include "varray.h"
53 static GTY(()) tree anonymous_types;
55 /* Counter to generate unique "names" for nameless struct members. */
57 static GTY(()) int unnamed_struct_number;
59 /* Declarations whose debug info was deferred till end of compilation. */
61 static GTY(()) varray_type deferred_global_decls;
63 /* The C front end may call sdbout_symbol before sdbout_init runs.
64 We save all such decls in this list and output them when we get
65 to sdbout_init. */
67 static GTY(()) tree preinit_symbols;
68 static GTY(()) bool sdbout_initialized;
70 #ifdef SDB_DEBUGGING_INFO
72 #include "rtl.h"
73 #include "regs.h"
74 #include "flags.h"
75 #include "insn-config.h"
76 #include "reload.h"
77 #include "output.h"
78 #include "toplev.h"
79 #include "tm_p.h"
80 #include "gsyms.h"
81 #include "langhooks.h"
82 #include "target.h"
84 /* 1 if PARM is passed to this function in memory. */
86 #define PARM_PASSED_IN_MEMORY(PARM) \
87 (MEM_P (DECL_INCOMING_RTL (PARM)))
89 /* A C expression for the integer offset value of an automatic variable
90 (C_AUTO) having address X (an RTX). */
91 #ifndef DEBUGGER_AUTO_OFFSET
92 #define DEBUGGER_AUTO_OFFSET(X) \
93 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
94 #endif
96 /* A C expression for the integer offset value of an argument (C_ARG)
97 having address X (an RTX). The nominal offset is OFFSET. */
98 #ifndef DEBUGGER_ARG_OFFSET
99 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
100 #endif
102 /* Line number of beginning of current function, minus one.
103 Negative means not in a function or not using sdb. */
105 int sdb_begin_function_line = -1;
108 extern FILE *asm_out_file;
110 extern tree current_function_decl;
112 #include "sdbout.h"
114 static void sdbout_init (const char *);
115 static void sdbout_finish (const char *);
116 static void sdbout_start_source_file (unsigned int, const char *);
117 static void sdbout_end_source_file (unsigned int);
118 static void sdbout_begin_block (unsigned int, unsigned int);
119 static void sdbout_end_block (unsigned int, unsigned int);
120 static void sdbout_source_line (unsigned int, const char *);
121 static void sdbout_end_epilogue (unsigned int, const char *);
122 static void sdbout_global_decl (tree);
123 #ifndef MIPS_DEBUGGING_INFO
124 static void sdbout_begin_prologue (unsigned int, const char *);
125 #endif
126 static void sdbout_end_prologue (unsigned int, const char *);
127 static void sdbout_begin_function (tree);
128 static void sdbout_end_function (unsigned int);
129 static void sdbout_toplevel_data (tree);
130 static void sdbout_label (rtx);
131 static char *gen_fake_label (void);
132 static int plain_type (tree);
133 static int template_name_p (tree);
134 static void sdbout_record_type_name (tree);
135 static int plain_type_1 (tree, int);
136 static void sdbout_block (tree);
137 static void sdbout_syms (tree);
138 #ifdef SDB_ALLOW_FORWARD_REFERENCES
139 static void sdbout_queue_anonymous_type (tree);
140 static void sdbout_dequeue_anonymous_types (void);
141 #endif
142 static void sdbout_type (tree);
143 static void sdbout_field_types (tree);
144 static void sdbout_one_type (tree);
145 static void sdbout_parms (tree);
146 static void sdbout_reg_parms (tree);
147 static void sdbout_global_decl (tree);
149 /* Random macros describing parts of SDB data. */
151 /* Default value of delimiter is ";". */
152 #ifndef SDB_DELIM
153 #define SDB_DELIM ";"
154 #endif
156 /* Maximum number of dimensions the assembler will allow. */
157 #ifndef SDB_MAX_DIM
158 #define SDB_MAX_DIM 4
159 #endif
161 #ifndef PUT_SDB_SCL
162 #define PUT_SDB_SCL(a) fprintf(asm_out_file, "\t.scl\t%d%s", (a), SDB_DELIM)
163 #endif
165 #ifndef PUT_SDB_INT_VAL
166 #define PUT_SDB_INT_VAL(a) \
167 do { \
168 fprintf (asm_out_file, "\t.val\t" HOST_WIDE_INT_PRINT_DEC "%s", \
169 (HOST_WIDE_INT) (a), SDB_DELIM); \
170 } while (0)
172 #endif
174 #ifndef PUT_SDB_VAL
175 #define PUT_SDB_VAL(a) \
176 ( fputs ("\t.val\t", asm_out_file), \
177 output_addr_const (asm_out_file, (a)), \
178 fprintf (asm_out_file, SDB_DELIM))
179 #endif
181 #ifndef PUT_SDB_DEF
182 #define PUT_SDB_DEF(a) \
183 do { fprintf (asm_out_file, "\t.def\t"); \
184 assemble_name (asm_out_file, a); \
185 fprintf (asm_out_file, SDB_DELIM); } while (0)
186 #endif
188 #ifndef PUT_SDB_PLAIN_DEF
189 #define PUT_SDB_PLAIN_DEF(a) fprintf(asm_out_file,"\t.def\t.%s%s",a, SDB_DELIM)
190 #endif
192 #ifndef PUT_SDB_ENDEF
193 #define PUT_SDB_ENDEF fputs("\t.endef\n", asm_out_file)
194 #endif
196 #ifndef PUT_SDB_TYPE
197 #define PUT_SDB_TYPE(a) fprintf(asm_out_file, "\t.type\t0%o%s", a, SDB_DELIM)
198 #endif
200 #ifndef PUT_SDB_SIZE
201 #define PUT_SDB_SIZE(a) \
202 do { \
203 fprintf (asm_out_file, "\t.size\t" HOST_WIDE_INT_PRINT_DEC "%s", \
204 (HOST_WIDE_INT) (a), SDB_DELIM); \
205 } while(0)
206 #endif
208 #ifndef PUT_SDB_START_DIM
209 #define PUT_SDB_START_DIM fprintf(asm_out_file, "\t.dim\t")
210 #endif
212 #ifndef PUT_SDB_NEXT_DIM
213 #define PUT_SDB_NEXT_DIM(a) fprintf(asm_out_file, "%d,", a)
214 #endif
216 #ifndef PUT_SDB_LAST_DIM
217 #define PUT_SDB_LAST_DIM(a) fprintf(asm_out_file, "%d%s", a, SDB_DELIM)
218 #endif
220 #ifndef PUT_SDB_TAG
221 #define PUT_SDB_TAG(a) \
222 do { fprintf (asm_out_file, "\t.tag\t"); \
223 assemble_name (asm_out_file, a); \
224 fprintf (asm_out_file, SDB_DELIM); } while (0)
225 #endif
227 #ifndef PUT_SDB_BLOCK_START
228 #define PUT_SDB_BLOCK_START(LINE) \
229 fprintf (asm_out_file, \
230 "\t.def\t.bb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n", \
231 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
232 #endif
234 #ifndef PUT_SDB_BLOCK_END
235 #define PUT_SDB_BLOCK_END(LINE) \
236 fprintf (asm_out_file, \
237 "\t.def\t.eb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n", \
238 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
239 #endif
241 #ifndef PUT_SDB_FUNCTION_START
242 #define PUT_SDB_FUNCTION_START(LINE) \
243 fprintf (asm_out_file, \
244 "\t.def\t.bf%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \
245 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
246 #endif
248 #ifndef PUT_SDB_FUNCTION_END
249 #define PUT_SDB_FUNCTION_END(LINE) \
250 fprintf (asm_out_file, \
251 "\t.def\t.ef%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \
252 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
253 #endif
255 /* Return the sdb tag identifier string for TYPE
256 if TYPE has already been defined; otherwise return a null pointer. */
258 #define KNOWN_TYPE_TAG(type) TYPE_SYMTAB_POINTER (type)
260 /* Set the sdb tag identifier string for TYPE to NAME. */
262 #define SET_KNOWN_TYPE_TAG(TYPE, NAME) \
263 TYPE_SYMTAB_POINTER (TYPE) = (char *)(NAME)
265 /* Return the name (a string) of the struct, union or enum tag
266 described by the TREE_LIST node LINK. This is 0 for an anonymous one. */
268 #define TAG_NAME(link) \
269 (((link) && TREE_PURPOSE ((link)) \
270 && IDENTIFIER_POINTER (TREE_PURPOSE ((link)))) \
271 ? IDENTIFIER_POINTER (TREE_PURPOSE ((link))) : (char *) 0)
273 /* Ensure we don't output a negative line number. */
274 #define MAKE_LINE_SAFE(line) \
275 if ((int) line <= sdb_begin_function_line) \
276 line = sdb_begin_function_line + 1
278 /* Perform linker optimization of merging header file definitions together
279 for targets with MIPS_DEBUGGING_INFO defined. This won't work without a
280 post 960826 version of GAS. Nothing breaks with earlier versions of GAS,
281 the optimization just won't be done. The native assembler already has the
282 necessary support. */
284 #ifdef MIPS_DEBUGGING_INFO
286 /* ECOFF linkers have an optimization that does the same kind of thing as
287 N_BINCL/E_INCL in stabs: eliminate duplicate debug information in the
288 executable. To achieve this, GCC must output a .file for each file
289 name change. */
291 /* This is a stack of input files. */
293 struct sdb_file
295 struct sdb_file *next;
296 const char *name;
299 /* This is the top of the stack. */
301 static struct sdb_file *current_file;
303 #endif /* MIPS_DEBUGGING_INFO */
305 /* The debug hooks structure. */
306 const struct gcc_debug_hooks sdb_debug_hooks =
308 sdbout_init, /* init */
309 sdbout_finish, /* finish */
310 debug_nothing_int_charstar, /* define */
311 debug_nothing_int_charstar, /* undef */
312 sdbout_start_source_file, /* start_source_file */
313 sdbout_end_source_file, /* end_source_file */
314 sdbout_begin_block, /* begin_block */
315 sdbout_end_block, /* end_block */
316 debug_true_tree, /* ignore_block */
317 sdbout_source_line, /* source_line */
318 #ifdef MIPS_DEBUGGING_INFO
319 /* Defer on MIPS systems so that parameter descriptions follow
320 function entry. */
321 debug_nothing_int_charstar, /* begin_prologue */
322 sdbout_end_prologue, /* end_prologue */
323 #else
324 sdbout_begin_prologue, /* begin_prologue */
325 debug_nothing_int_charstar, /* end_prologue */
326 #endif
327 sdbout_end_epilogue, /* end_epilogue */
328 sdbout_begin_function, /* begin_function */
329 sdbout_end_function, /* end_function */
330 debug_nothing_tree, /* function_decl */
331 sdbout_global_decl, /* global_decl */
332 sdbout_symbol, /* type_decl */
333 debug_nothing_tree_tree, /* imported_module_or_decl */
334 debug_nothing_tree, /* deferred_inline_function */
335 debug_nothing_tree, /* outlining_inline_function */
336 sdbout_label, /* label */
337 debug_nothing_int, /* handle_pch */
338 debug_nothing_rtx /* var_location */
341 /* Return a unique string to name an anonymous type. */
343 static char *
344 gen_fake_label (void)
346 char label[10];
347 char *labelstr;
348 sprintf (label, ".%dfake", unnamed_struct_number);
349 unnamed_struct_number++;
350 labelstr = xstrdup (label);
351 return labelstr;
354 /* Return the number which describes TYPE for SDB.
355 For pointers, etc., this function is recursive.
356 Each record, union or enumeral type must already have had a
357 tag number output. */
359 /* The number is given by d6d5d4d3d2d1bbbb
360 where bbbb is 4 bit basic type, and di indicate one of notype,ptr,fn,array.
361 Thus, char *foo () has bbbb=T_CHAR
362 d1=D_FCN
363 d2=D_PTR
364 N_BTMASK= 017 1111 basic type field.
365 N_TSHIFT= 2 derived type shift
366 N_BTSHFT= 4 Basic type shift */
368 /* Produce the number that describes a pointer, function or array type.
369 PREV is the number describing the target, value or element type.
370 DT_type describes how to transform that type. */
371 #define PUSH_DERIVED_LEVEL(DT_type,PREV) \
372 ((((PREV) & ~(int) N_BTMASK) << (int) N_TSHIFT) \
373 | ((int) DT_type << (int) N_BTSHFT) \
374 | ((PREV) & (int) N_BTMASK))
376 /* Number of elements used in sdb_dims. */
377 static int sdb_n_dims = 0;
379 /* Table of array dimensions of current type. */
380 static int sdb_dims[SDB_MAX_DIM];
382 /* Size of outermost array currently being processed. */
383 static int sdb_type_size = -1;
385 static int
386 plain_type (tree type)
388 int val = plain_type_1 (type, 0);
390 /* If we have already saved up some array dimensions, print them now. */
391 if (sdb_n_dims > 0)
393 int i;
394 PUT_SDB_START_DIM;
395 for (i = sdb_n_dims - 1; i > 0; i--)
396 PUT_SDB_NEXT_DIM (sdb_dims[i]);
397 PUT_SDB_LAST_DIM (sdb_dims[0]);
398 sdb_n_dims = 0;
400 sdb_type_size = int_size_in_bytes (type);
401 /* Don't kill sdb if type is not laid out or has variable size. */
402 if (sdb_type_size < 0)
403 sdb_type_size = 0;
405 /* If we have computed the size of an array containing this type,
406 print it now. */
407 if (sdb_type_size >= 0)
409 PUT_SDB_SIZE (sdb_type_size);
410 sdb_type_size = -1;
412 return val;
415 static int
416 template_name_p (tree name)
418 const char *ptr = IDENTIFIER_POINTER (name);
419 while (*ptr && *ptr != '<')
420 ptr++;
422 return *ptr != '\0';
425 static void
426 sdbout_record_type_name (tree type)
428 const char *name = 0;
429 int no_name;
431 if (KNOWN_TYPE_TAG (type))
432 return;
434 if (TYPE_NAME (type) != 0)
436 tree t = 0;
438 /* Find the IDENTIFIER_NODE for the type name. */
439 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
440 t = TYPE_NAME (type);
441 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
443 t = DECL_NAME (TYPE_NAME (type));
444 /* The DECL_NAME for templates includes "<>", which breaks
445 most assemblers. Use its assembler name instead, which
446 has been mangled into being safe. */
447 if (t && template_name_p (t))
448 t = DECL_ASSEMBLER_NAME (TYPE_NAME (type));
451 /* Now get the name as a string, or invent one. */
452 if (t != NULL_TREE)
453 name = IDENTIFIER_POINTER (t);
456 no_name = (name == 0 || *name == 0);
457 if (no_name)
458 name = gen_fake_label ();
460 SET_KNOWN_TYPE_TAG (type, name);
461 #ifdef SDB_ALLOW_FORWARD_REFERENCES
462 if (no_name)
463 sdbout_queue_anonymous_type (type);
464 #endif
467 /* Return the .type value for type TYPE.
469 LEVEL indicates how many levels deep we have recursed into the type.
470 The SDB debug format can only represent 6 derived levels of types.
471 After that, we must output inaccurate debug info. We deliberately
472 stop before the 7th level, so that ADA recursive types will not give an
473 infinite loop. */
475 static int
476 plain_type_1 (tree type, int level)
478 if (type == 0)
479 type = void_type_node;
480 else if (type == error_mark_node)
481 type = integer_type_node;
482 else
483 type = TYPE_MAIN_VARIANT (type);
485 switch (TREE_CODE (type))
487 case VOID_TYPE:
488 return T_VOID;
489 case BOOLEAN_TYPE:
490 case INTEGER_TYPE:
492 int size = int_size_in_bytes (type) * BITS_PER_UNIT;
494 /* Carefully distinguish all the standard types of C,
495 without messing up if the language is not C.
496 Note that we check only for the names that contain spaces;
497 other names might occur by coincidence in other languages. */
498 if (TYPE_NAME (type) != 0
499 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
500 && DECL_NAME (TYPE_NAME (type)) != 0
501 && TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE)
503 const char *const name
504 = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
506 if (!strcmp (name, "char"))
507 return T_CHAR;
508 if (!strcmp (name, "unsigned char"))
509 return T_UCHAR;
510 if (!strcmp (name, "signed char"))
511 return T_CHAR;
512 if (!strcmp (name, "int"))
513 return T_INT;
514 if (!strcmp (name, "unsigned int"))
515 return T_UINT;
516 if (!strcmp (name, "short int"))
517 return T_SHORT;
518 if (!strcmp (name, "short unsigned int"))
519 return T_USHORT;
520 if (!strcmp (name, "long int"))
521 return T_LONG;
522 if (!strcmp (name, "long unsigned int"))
523 return T_ULONG;
526 if (size == INT_TYPE_SIZE)
527 return (TYPE_UNSIGNED (type) ? T_UINT : T_INT);
528 if (size == CHAR_TYPE_SIZE)
529 return (TYPE_UNSIGNED (type) ? T_UCHAR : T_CHAR);
530 if (size == SHORT_TYPE_SIZE)
531 return (TYPE_UNSIGNED (type) ? T_USHORT : T_SHORT);
532 if (size == LONG_TYPE_SIZE)
533 return (TYPE_UNSIGNED (type) ? T_ULONG : T_LONG);
534 if (size == LONG_LONG_TYPE_SIZE) /* better than nothing */
535 return (TYPE_UNSIGNED (type) ? T_ULONG : T_LONG);
536 return 0;
539 case REAL_TYPE:
541 int precision = TYPE_PRECISION (type);
542 if (precision == FLOAT_TYPE_SIZE)
543 return T_FLOAT;
544 if (precision == DOUBLE_TYPE_SIZE)
545 return T_DOUBLE;
546 #ifdef EXTENDED_SDB_BASIC_TYPES
547 if (precision == LONG_DOUBLE_TYPE_SIZE)
548 return T_LNGDBL;
549 #else
550 if (precision == LONG_DOUBLE_TYPE_SIZE)
551 return T_DOUBLE; /* better than nothing */
552 #endif
553 return 0;
556 case ARRAY_TYPE:
558 int m;
559 if (level >= 6)
560 return T_VOID;
561 else
562 m = plain_type_1 (TREE_TYPE (type), level+1);
563 if (sdb_n_dims < SDB_MAX_DIM)
564 sdb_dims[sdb_n_dims++]
565 = (TYPE_DOMAIN (type)
566 && TYPE_MIN_VALUE (TYPE_DOMAIN (type)) != 0
567 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != 0
568 && host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0)
569 && host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0)
570 ? (tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0)
571 - tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0) + 1)
572 : 0);
574 return PUSH_DERIVED_LEVEL (DT_ARY, m);
577 case RECORD_TYPE:
578 case UNION_TYPE:
579 case QUAL_UNION_TYPE:
580 case ENUMERAL_TYPE:
582 char *tag;
583 #ifdef SDB_ALLOW_FORWARD_REFERENCES
584 sdbout_record_type_name (type);
585 #endif
586 #ifndef SDB_ALLOW_UNKNOWN_REFERENCES
587 if ((TREE_ASM_WRITTEN (type) && KNOWN_TYPE_TAG (type) != 0)
588 #ifdef SDB_ALLOW_FORWARD_REFERENCES
589 || TYPE_MODE (type) != VOIDmode
590 #endif
592 #endif
594 /* Output the referenced structure tag name
595 only if the .def has already been finished.
596 At least on 386, the Unix assembler
597 cannot handle forward references to tags. */
598 /* But the 88100, it requires them, sigh... */
599 /* And the MIPS requires unknown refs as well... */
600 tag = KNOWN_TYPE_TAG (type);
601 PUT_SDB_TAG (tag);
602 /* These 3 lines used to follow the close brace.
603 However, a size of 0 without a tag implies a tag of 0,
604 so if we don't know a tag, we can't mention the size. */
605 sdb_type_size = int_size_in_bytes (type);
606 if (sdb_type_size < 0)
607 sdb_type_size = 0;
609 return ((TREE_CODE (type) == RECORD_TYPE) ? T_STRUCT
610 : (TREE_CODE (type) == UNION_TYPE) ? T_UNION
611 : (TREE_CODE (type) == QUAL_UNION_TYPE) ? T_UNION
612 : T_ENUM);
614 case POINTER_TYPE:
615 case REFERENCE_TYPE:
617 int m;
618 if (level >= 6)
619 return T_VOID;
620 else
621 m = plain_type_1 (TREE_TYPE (type), level+1);
622 return PUSH_DERIVED_LEVEL (DT_PTR, m);
624 case FUNCTION_TYPE:
625 case METHOD_TYPE:
627 int m;
628 if (level >= 6)
629 return T_VOID;
630 else
631 m = plain_type_1 (TREE_TYPE (type), level+1);
632 return PUSH_DERIVED_LEVEL (DT_FCN, m);
634 default:
635 return 0;
639 /* Output the symbols defined in block number DO_BLOCK.
641 This function works by walking the tree structure of blocks,
642 counting blocks until it finds the desired block. */
644 static int do_block = 0;
646 static void
647 sdbout_block (tree block)
649 while (block)
651 /* Ignore blocks never expanded or otherwise marked as real. */
652 if (TREE_USED (block))
654 /* When we reach the specified block, output its symbols. */
655 if (BLOCK_NUMBER (block) == do_block)
656 sdbout_syms (BLOCK_VARS (block));
658 /* If we are past the specified block, stop the scan. */
659 if (BLOCK_NUMBER (block) > do_block)
660 return;
662 /* Scan the blocks within this block. */
663 sdbout_block (BLOCK_SUBBLOCKS (block));
666 block = BLOCK_CHAIN (block);
670 /* Call sdbout_symbol on each decl in the chain SYMS. */
672 static void
673 sdbout_syms (tree syms)
675 while (syms)
677 if (TREE_CODE (syms) != LABEL_DECL)
678 sdbout_symbol (syms, 1);
679 syms = TREE_CHAIN (syms);
683 /* Output SDB information for a symbol described by DECL.
684 LOCAL is nonzero if the symbol is not file-scope. */
686 void
687 sdbout_symbol (tree decl, int local)
689 tree type = TREE_TYPE (decl);
690 tree context = NULL_TREE;
691 rtx value;
692 int regno = -1;
693 const char *name;
695 /* If we are called before sdbout_init is run, just save the symbol
696 for later. */
697 if (!sdbout_initialized)
699 preinit_symbols = tree_cons (0, decl, preinit_symbols);
700 return;
703 sdbout_one_type (type);
705 switch (TREE_CODE (decl))
707 case CONST_DECL:
708 /* Enum values are defined by defining the enum type. */
709 return;
711 case FUNCTION_DECL:
712 /* Don't mention a nested function under its parent. */
713 context = decl_function_context (decl);
714 if (context == current_function_decl)
715 return;
716 /* Check DECL_INITIAL to distinguish declarations from definitions.
717 Don't output debug info here for declarations; they will have
718 a DECL_INITIAL value of 0. */
719 if (! DECL_INITIAL (decl))
720 return;
721 if (!MEM_P (DECL_RTL (decl))
722 || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
723 return;
724 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
725 PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
726 PUT_SDB_SCL (TREE_PUBLIC (decl) ? C_EXT : C_STAT);
727 break;
729 case TYPE_DECL:
730 /* Done with tagged types. */
731 if (DECL_NAME (decl) == 0)
732 return;
733 if (DECL_IGNORED_P (decl))
734 return;
735 /* Don't output intrinsic types. GAS chokes on SDB .def
736 statements that contain identifiers with embedded spaces
737 (eg "unsigned long"). */
738 if (DECL_IS_BUILTIN (decl))
739 return;
741 /* Output typedef name. */
742 if (template_name_p (DECL_NAME (decl)))
743 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
744 else
745 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_NAME (decl)));
746 PUT_SDB_SCL (C_TPDEF);
747 break;
749 case PARM_DECL:
750 /* Parm decls go in their own separate chains
751 and are output by sdbout_reg_parms and sdbout_parms. */
752 gcc_unreachable ();
754 case VAR_DECL:
755 /* Don't mention a variable that is external.
756 Let the file that defines it describe it. */
757 if (DECL_EXTERNAL (decl))
758 return;
760 /* Ignore __FUNCTION__, etc. */
761 if (DECL_IGNORED_P (decl))
762 return;
764 /* If there was an error in the declaration, don't dump core
765 if there is no RTL associated with the variable doesn't
766 exist. */
767 if (!DECL_RTL_SET_P (decl))
768 return;
770 SET_DECL_RTL (decl,
771 eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
772 #ifdef LEAF_REG_REMAP
773 if (current_function_uses_only_leaf_regs)
774 leaf_renumber_regs_insn (DECL_RTL (decl));
775 #endif
776 value = DECL_RTL (decl);
778 /* Don't mention a variable at all
779 if it was completely optimized into nothingness.
781 If DECL was from an inline function, then its rtl
782 is not identically the rtl that was used in this
783 particular compilation. */
784 if (REG_P (value))
786 regno = REGNO (value);
787 if (regno >= FIRST_PSEUDO_REGISTER)
788 return;
790 else if (GET_CODE (value) == SUBREG)
792 while (GET_CODE (value) == SUBREG)
793 value = SUBREG_REG (value);
794 if (REG_P (value))
796 if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
797 return;
799 regno = REGNO (alter_subreg (&value));
800 SET_DECL_RTL (decl, value);
802 /* Don't output anything if an auto variable
803 gets RTL that is static.
804 GAS version 2.2 can't handle such output. */
805 else if (MEM_P (value) && CONSTANT_P (XEXP (value, 0))
806 && ! TREE_STATIC (decl))
807 return;
809 /* Emit any structure, union, or enum type that has not been output.
810 This occurs for tag-less structs (et al) used to declare variables
811 within functions. */
812 if (TREE_CODE (type) == ENUMERAL_TYPE
813 || TREE_CODE (type) == RECORD_TYPE
814 || TREE_CODE (type) == UNION_TYPE
815 || TREE_CODE (type) == QUAL_UNION_TYPE)
817 if (COMPLETE_TYPE_P (type) /* not a forward reference */
818 && KNOWN_TYPE_TAG (type) == 0) /* not yet declared */
819 sdbout_one_type (type);
822 /* Defer SDB information for top-level initialized variables! */
823 if (! local
824 && MEM_P (value)
825 && DECL_INITIAL (decl))
826 return;
828 /* C++ in 2.3 makes nameless symbols. That will be fixed later.
829 For now, avoid crashing. */
830 if (DECL_NAME (decl) == NULL_TREE)
831 return;
833 /* Record the name for, starting a symtab entry. */
834 if (local)
835 name = IDENTIFIER_POINTER (DECL_NAME (decl));
836 else
837 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
839 if (MEM_P (value)
840 && GET_CODE (XEXP (value, 0)) == SYMBOL_REF)
842 PUT_SDB_DEF (name);
843 if (TREE_PUBLIC (decl))
845 PUT_SDB_VAL (XEXP (value, 0));
846 PUT_SDB_SCL (C_EXT);
848 else
850 PUT_SDB_VAL (XEXP (value, 0));
851 PUT_SDB_SCL (C_STAT);
854 else if (regno >= 0)
856 PUT_SDB_DEF (name);
857 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (regno));
858 PUT_SDB_SCL (C_REG);
860 else if (MEM_P (value)
861 && (MEM_P (XEXP (value, 0))
862 || (REG_P (XEXP (value, 0))
863 && REGNO (XEXP (value, 0)) != HARD_FRAME_POINTER_REGNUM
864 && REGNO (XEXP (value, 0)) != STACK_POINTER_REGNUM)))
865 /* If the value is indirect by memory or by a register
866 that isn't the frame pointer
867 then it means the object is variable-sized and address through
868 that register or stack slot. COFF has no way to represent this
869 so all we can do is output the variable as a pointer. */
871 PUT_SDB_DEF (name);
872 if (REG_P (XEXP (value, 0)))
874 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (XEXP (value, 0))));
875 PUT_SDB_SCL (C_REG);
877 else
879 /* DECL_RTL looks like (MEM (MEM (PLUS (REG...)
880 (CONST_INT...)))).
881 We want the value of that CONST_INT. */
882 /* Encore compiler hates a newline in a macro arg, it seems. */
883 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
884 (XEXP (XEXP (value, 0), 0)));
885 PUT_SDB_SCL (C_AUTO);
888 /* Effectively do build_pointer_type, but don't cache this type,
889 since it might be temporary whereas the type it points to
890 might have been saved for inlining. */
891 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
892 type = make_node (POINTER_TYPE);
893 TREE_TYPE (type) = TREE_TYPE (decl);
895 else if (MEM_P (value)
896 && ((GET_CODE (XEXP (value, 0)) == PLUS
897 && REG_P (XEXP (XEXP (value, 0), 0))
898 && GET_CODE (XEXP (XEXP (value, 0), 1)) == CONST_INT)
899 /* This is for variables which are at offset zero from
900 the frame pointer. This happens on the Alpha.
901 Non-frame pointer registers are excluded above. */
902 || (REG_P (XEXP (value, 0)))))
904 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
905 or (MEM (REG...)). We want the value of that CONST_INT
906 or zero. */
907 PUT_SDB_DEF (name);
908 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET (XEXP (value, 0)));
909 PUT_SDB_SCL (C_AUTO);
911 else
913 /* It is something we don't know how to represent for SDB. */
914 return;
916 break;
918 default:
919 break;
921 PUT_SDB_TYPE (plain_type (type));
922 PUT_SDB_ENDEF;
925 /* Output SDB information for a top-level initialized variable
926 that has been delayed. */
928 static void
929 sdbout_toplevel_data (tree decl)
931 tree type = TREE_TYPE (decl);
933 if (DECL_IGNORED_P (decl))
934 return;
936 gcc_assert (TREE_CODE (decl) == VAR_DECL);
937 gcc_assert (MEM_P (DECL_RTL (decl)));
938 gcc_assert (DECL_INITIAL (decl));
940 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
941 PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
942 if (TREE_PUBLIC (decl))
944 PUT_SDB_SCL (C_EXT);
946 else
948 PUT_SDB_SCL (C_STAT);
950 PUT_SDB_TYPE (plain_type (type));
951 PUT_SDB_ENDEF;
954 #ifdef SDB_ALLOW_FORWARD_REFERENCES
956 /* Machinery to record and output anonymous types. */
958 static void
959 sdbout_queue_anonymous_type (tree type)
961 anonymous_types = tree_cons (NULL_TREE, type, anonymous_types);
964 static void
965 sdbout_dequeue_anonymous_types (void)
967 tree types, link;
969 while (anonymous_types)
971 types = nreverse (anonymous_types);
972 anonymous_types = NULL_TREE;
974 for (link = types; link; link = TREE_CHAIN (link))
976 tree type = TREE_VALUE (link);
978 if (type && ! TREE_ASM_WRITTEN (type))
979 sdbout_one_type (type);
984 #endif
986 /* Given a chain of ..._TYPE nodes, all of which have names,
987 output definitions of those names, as typedefs. */
989 void
990 sdbout_types (tree types)
992 tree link;
994 for (link = types; link; link = TREE_CHAIN (link))
995 sdbout_one_type (link);
997 #ifdef SDB_ALLOW_FORWARD_REFERENCES
998 sdbout_dequeue_anonymous_types ();
999 #endif
1002 static void
1003 sdbout_type (tree type)
1005 if (type == error_mark_node)
1006 type = integer_type_node;
1007 PUT_SDB_TYPE (plain_type (type));
1010 /* Output types of the fields of type TYPE, if they are structs.
1012 Formerly did not chase through pointer types, since that could be circular.
1013 They must come before TYPE, since forward refs are not allowed.
1014 Now james@bigtex.cactus.org says to try them. */
1016 static void
1017 sdbout_field_types (tree type)
1019 tree tail;
1021 for (tail = TYPE_FIELDS (type); tail; tail = TREE_CHAIN (tail))
1022 /* This condition should match the one for emitting the actual
1023 members below. */
1024 if (TREE_CODE (tail) == FIELD_DECL
1025 && DECL_NAME (tail)
1026 && DECL_SIZE (tail)
1027 && host_integerp (DECL_SIZE (tail), 1)
1028 && host_integerp (bit_position (tail), 0))
1030 if (POINTER_TYPE_P (TREE_TYPE (tail)))
1031 sdbout_one_type (TREE_TYPE (TREE_TYPE (tail)));
1032 else
1033 sdbout_one_type (TREE_TYPE (tail));
1037 /* Use this to put out the top level defined record and union types
1038 for later reference. If this is a struct with a name, then put that
1039 name out. Other unnamed structs will have .xxfake labels generated so
1040 that they may be referred to later.
1041 The label will be stored in the KNOWN_TYPE_TAG slot of a type.
1042 It may NOT be called recursively. */
1044 static void
1045 sdbout_one_type (tree type)
1047 if (current_function_decl != NULL_TREE
1048 && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
1049 ; /* Don't change section amid function. */
1050 else
1051 text_section ();
1053 switch (TREE_CODE (type))
1055 case RECORD_TYPE:
1056 case UNION_TYPE:
1057 case QUAL_UNION_TYPE:
1058 case ENUMERAL_TYPE:
1059 type = TYPE_MAIN_VARIANT (type);
1060 /* Don't output a type twice. */
1061 if (TREE_ASM_WRITTEN (type))
1062 /* James said test TREE_ASM_BEING_WRITTEN here. */
1063 return;
1065 /* Output nothing if type is not yet defined. */
1066 if (!COMPLETE_TYPE_P (type))
1067 return;
1069 TREE_ASM_WRITTEN (type) = 1;
1071 /* This is reputed to cause trouble with the following case,
1072 but perhaps checking TYPE_SIZE above will fix it. */
1074 /* Here is a testcase:
1076 struct foo {
1077 struct badstr *bbb;
1078 } forwardref;
1080 typedef struct intermediate {
1081 int aaaa;
1082 } intermediate_ref;
1084 typedef struct badstr {
1085 int ccccc;
1086 } badtype; */
1088 /* This change, which ought to make better output,
1089 used to make the COFF assembler unhappy.
1090 Changes involving KNOWN_TYPE_TAG may fix the problem. */
1091 /* Before really doing anything, output types we want to refer to. */
1092 /* Note that in version 1 the following two lines
1093 are not used if forward references are in use. */
1094 if (TREE_CODE (type) != ENUMERAL_TYPE)
1095 sdbout_field_types (type);
1097 /* Output a structure type. */
1099 int size = int_size_in_bytes (type);
1100 int member_scl = 0;
1101 tree tem;
1103 /* Record the type tag, but not in its permanent place just yet. */
1104 sdbout_record_type_name (type);
1106 PUT_SDB_DEF (KNOWN_TYPE_TAG (type));
1108 switch (TREE_CODE (type))
1110 case UNION_TYPE:
1111 case QUAL_UNION_TYPE:
1112 PUT_SDB_SCL (C_UNTAG);
1113 PUT_SDB_TYPE (T_UNION);
1114 member_scl = C_MOU;
1115 break;
1117 case RECORD_TYPE:
1118 PUT_SDB_SCL (C_STRTAG);
1119 PUT_SDB_TYPE (T_STRUCT);
1120 member_scl = C_MOS;
1121 break;
1123 case ENUMERAL_TYPE:
1124 PUT_SDB_SCL (C_ENTAG);
1125 PUT_SDB_TYPE (T_ENUM);
1126 member_scl = C_MOE;
1127 break;
1129 default:
1130 break;
1133 PUT_SDB_SIZE (size);
1134 PUT_SDB_ENDEF;
1136 /* Print out the base class information with fields
1137 named after the types they hold. */
1138 /* This is only relevant to aggregate types. TYPE_BINFO is used
1139 for other purposes in an ENUMERAL_TYPE, so we must exclude that
1140 case. */
1141 if (TREE_CODE (type) != ENUMERAL_TYPE && TYPE_BINFO (type))
1143 int i;
1144 tree binfo, child;
1146 for (binfo = TYPE_BINFO (type), i = 0;
1147 BINFO_BASE_ITERATE (binfo, i, child); i++)
1149 tree child_type = BINFO_TYPE (child);
1150 tree child_type_name;
1152 if (TYPE_NAME (child_type) == 0)
1153 continue;
1154 if (TREE_CODE (TYPE_NAME (child_type)) == IDENTIFIER_NODE)
1155 child_type_name = TYPE_NAME (child_type);
1156 else if (TREE_CODE (TYPE_NAME (child_type)) == TYPE_DECL)
1158 child_type_name = DECL_NAME (TYPE_NAME (child_type));
1159 if (child_type_name && template_name_p (child_type_name))
1160 child_type_name
1161 = DECL_ASSEMBLER_NAME (TYPE_NAME (child_type));
1163 else
1164 continue;
1166 PUT_SDB_DEF (IDENTIFIER_POINTER (child_type_name));
1167 PUT_SDB_INT_VAL (tree_low_cst (BINFO_OFFSET (child), 0));
1168 PUT_SDB_SCL (member_scl);
1169 sdbout_type (BINFO_TYPE (child));
1170 PUT_SDB_ENDEF;
1174 /* Output the individual fields. */
1176 if (TREE_CODE (type) == ENUMERAL_TYPE)
1178 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
1179 if (host_integerp (TREE_VALUE (tem), 0))
1181 PUT_SDB_DEF (IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1182 PUT_SDB_INT_VAL (tree_low_cst (TREE_VALUE (tem), 0));
1183 PUT_SDB_SCL (C_MOE);
1184 PUT_SDB_TYPE (T_MOE);
1185 PUT_SDB_ENDEF;
1188 else /* record or union type */
1189 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1190 /* Output the name, type, position (in bits), size (in bits)
1191 of each field. */
1193 /* Omit here the nameless fields that are used to skip bits.
1194 Also omit fields with variable size or position.
1195 Also omit non FIELD_DECL nodes that GNU C++ may put here. */
1196 if (TREE_CODE (tem) == FIELD_DECL
1197 && DECL_NAME (tem)
1198 && DECL_SIZE (tem)
1199 && host_integerp (DECL_SIZE (tem), 1)
1200 && host_integerp (bit_position (tem), 0))
1202 const char *name;
1204 name = IDENTIFIER_POINTER (DECL_NAME (tem));
1205 PUT_SDB_DEF (name);
1206 if (DECL_BIT_FIELD_TYPE (tem))
1208 PUT_SDB_INT_VAL (int_bit_position (tem));
1209 PUT_SDB_SCL (C_FIELD);
1210 sdbout_type (DECL_BIT_FIELD_TYPE (tem));
1211 PUT_SDB_SIZE (tree_low_cst (DECL_SIZE (tem), 1));
1213 else
1215 PUT_SDB_INT_VAL (int_bit_position (tem) / BITS_PER_UNIT);
1216 PUT_SDB_SCL (member_scl);
1217 sdbout_type (TREE_TYPE (tem));
1219 PUT_SDB_ENDEF;
1221 /* Output end of a structure,union, or enumeral definition. */
1223 PUT_SDB_PLAIN_DEF ("eos");
1224 PUT_SDB_INT_VAL (size);
1225 PUT_SDB_SCL (C_EOS);
1226 PUT_SDB_TAG (KNOWN_TYPE_TAG (type));
1227 PUT_SDB_SIZE (size);
1228 PUT_SDB_ENDEF;
1229 break;
1231 default:
1232 break;
1237 /* The following two functions output definitions of function parameters.
1238 Each parameter gets a definition locating it in the parameter list.
1239 Each parameter that is a register variable gets a second definition
1240 locating it in the register.
1242 Printing or argument lists in gdb uses the definitions that
1243 locate in the parameter list. But reference to the variable in
1244 expressions uses preferentially the definition as a register. */
1246 /* Output definitions, referring to storage in the parmlist,
1247 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
1249 static void
1250 sdbout_parms (tree parms)
1252 for (; parms; parms = TREE_CHAIN (parms))
1253 if (DECL_NAME (parms))
1255 int current_sym_value = 0;
1256 const char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
1258 if (name == 0 || *name == 0)
1259 name = gen_fake_label ();
1261 /* Perform any necessary register eliminations on the parameter's rtl,
1262 so that the debugging output will be accurate. */
1263 DECL_INCOMING_RTL (parms)
1264 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
1265 SET_DECL_RTL (parms,
1266 eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
1268 if (PARM_PASSED_IN_MEMORY (parms))
1270 rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
1271 tree type;
1273 /* ??? Here we assume that the parm address is indexed
1274 off the frame pointer or arg pointer.
1275 If that is not true, we produce meaningless results,
1276 but do not crash. */
1277 if (GET_CODE (addr) == PLUS
1278 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
1279 current_sym_value = INTVAL (XEXP (addr, 1));
1280 else
1281 current_sym_value = 0;
1283 if (REG_P (DECL_RTL (parms))
1284 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1285 type = DECL_ARG_TYPE (parms);
1286 else
1288 int original_sym_value = current_sym_value;
1290 /* This is the case where the parm is passed as an int or
1291 double and it is converted to a char, short or float
1292 and stored back in the parmlist. In this case, describe
1293 the parm with the variable's declared type, and adjust
1294 the address if the least significant bytes (which we are
1295 using) are not the first ones. */
1296 if (BYTES_BIG_ENDIAN
1297 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1298 current_sym_value +=
1299 (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1300 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1302 if (MEM_P (DECL_RTL (parms))
1303 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1304 && (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1))
1305 == CONST_INT)
1306 && (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1))
1307 == current_sym_value))
1308 type = TREE_TYPE (parms);
1309 else
1311 current_sym_value = original_sym_value;
1312 type = DECL_ARG_TYPE (parms);
1316 PUT_SDB_DEF (name);
1317 PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value, addr));
1318 PUT_SDB_SCL (C_ARG);
1319 PUT_SDB_TYPE (plain_type (type));
1320 PUT_SDB_ENDEF;
1322 else if (REG_P (DECL_RTL (parms)))
1324 rtx best_rtl;
1325 /* Parm passed in registers and lives in registers or nowhere. */
1327 /* If parm lives in a register, use that register;
1328 pretend the parm was passed there. It would be more consistent
1329 to describe the register where the parm was passed,
1330 but in practice that register usually holds something else. */
1331 if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1332 best_rtl = DECL_RTL (parms);
1333 /* If the parm lives nowhere,
1334 use the register where it was passed. */
1335 else
1336 best_rtl = DECL_INCOMING_RTL (parms);
1338 PUT_SDB_DEF (name);
1339 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (best_rtl)));
1340 PUT_SDB_SCL (C_REGPARM);
1341 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1342 PUT_SDB_ENDEF;
1344 else if (MEM_P (DECL_RTL (parms))
1345 && XEXP (DECL_RTL (parms), 0) != const0_rtx)
1347 /* Parm was passed in registers but lives on the stack. */
1349 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
1350 in which case we want the value of that CONST_INT,
1351 or (MEM (REG ...)) or (MEM (MEM ...)),
1352 in which case we use a value of zero. */
1353 if (REG_P (XEXP (DECL_RTL (parms), 0))
1354 || MEM_P (XEXP (DECL_RTL (parms), 0)))
1355 current_sym_value = 0;
1356 else
1357 current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
1359 /* Again, this assumes the offset is based on the arg pointer. */
1360 PUT_SDB_DEF (name);
1361 PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value,
1362 XEXP (DECL_RTL (parms), 0)));
1363 PUT_SDB_SCL (C_ARG);
1364 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1365 PUT_SDB_ENDEF;
1370 /* Output definitions for the places where parms live during the function,
1371 when different from where they were passed, when the parms were passed
1372 in memory.
1374 It is not useful to do this for parms passed in registers
1375 that live during the function in different registers, because it is
1376 impossible to look in the passed register for the passed value,
1377 so we use the within-the-function register to begin with.
1379 PARMS is a chain of PARM_DECL nodes. */
1381 static void
1382 sdbout_reg_parms (tree parms)
1384 for (; parms; parms = TREE_CHAIN (parms))
1385 if (DECL_NAME (parms))
1387 const char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
1389 /* Report parms that live in registers during the function
1390 but were passed in memory. */
1391 if (REG_P (DECL_RTL (parms))
1392 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER
1393 && PARM_PASSED_IN_MEMORY (parms))
1395 if (name == 0 || *name == 0)
1396 name = gen_fake_label ();
1397 PUT_SDB_DEF (name);
1398 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms))));
1399 PUT_SDB_SCL (C_REG);
1400 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1401 PUT_SDB_ENDEF;
1403 /* Report parms that live in memory but not where they were passed. */
1404 else if (MEM_P (DECL_RTL (parms))
1405 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1406 && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
1407 && PARM_PASSED_IN_MEMORY (parms)
1408 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
1410 #if 0 /* ??? It is not clear yet what should replace this. */
1411 int offset = DECL_OFFSET (parms) / BITS_PER_UNIT;
1412 /* A parm declared char is really passed as an int,
1413 so it occupies the least significant bytes.
1414 On a big-endian machine those are not the low-numbered ones. */
1415 if (BYTES_BIG_ENDIAN
1416 && offset != -1
1417 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1418 offset += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1419 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1420 if (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) != offset) {...}
1421 #endif
1423 if (name == 0 || *name == 0)
1424 name = gen_fake_label ();
1425 PUT_SDB_DEF (name);
1426 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
1427 (XEXP (DECL_RTL (parms), 0)));
1428 PUT_SDB_SCL (C_AUTO);
1429 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1430 PUT_SDB_ENDEF;
1436 /* Output debug information for a global DECL. Called from toplev.c
1437 after compilation proper has finished. */
1439 static void
1440 sdbout_global_decl (tree decl)
1442 if (TREE_CODE (decl) == VAR_DECL
1443 && !DECL_EXTERNAL (decl)
1444 && DECL_RTL_SET_P (decl))
1446 /* The COFF linker can move initialized global vars to the end.
1447 And that can screw up the symbol ordering. Defer those for
1448 sdbout_finish (). */
1449 if (!DECL_INITIAL (decl) || !TREE_PUBLIC (decl))
1450 sdbout_symbol (decl, 0);
1451 else
1452 VARRAY_PUSH_TREE (deferred_global_decls, decl);
1454 /* Output COFF information for non-global file-scope initialized
1455 variables. */
1456 if (DECL_INITIAL (decl) && MEM_P (DECL_RTL (decl)))
1457 sdbout_toplevel_data (decl);
1461 /* Output initialized global vars at the end, in the order of
1462 definition. See comment in sdbout_global_decl. */
1464 static void
1465 sdbout_finish (const char *main_filename ATTRIBUTE_UNUSED)
1467 size_t i;
1469 for (i = 0; i < VARRAY_ACTIVE_SIZE (deferred_global_decls); i++)
1470 sdbout_symbol (VARRAY_TREE (deferred_global_decls, i), 0);
1473 /* Describe the beginning of an internal block within a function.
1474 Also output descriptions of variables defined in this block.
1476 N is the number of the block, by order of beginning, counting from 1,
1477 and not counting the outermost (function top-level) block.
1478 The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
1479 if the count starts at 0 for the outermost one. */
1481 static void
1482 sdbout_begin_block (unsigned int line, unsigned int n)
1484 tree decl = current_function_decl;
1485 MAKE_LINE_SAFE (line);
1487 /* The SCO compiler does not emit a separate block for the function level
1488 scope, so we avoid it here also. However, mips ECOFF compilers do emit
1489 a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined. */
1490 #ifndef MIPS_DEBUGGING_INFO
1491 if (n != 1)
1492 #endif
1493 PUT_SDB_BLOCK_START (line - sdb_begin_function_line);
1495 if (n == 1)
1497 /* Include the outermost BLOCK's variables in block 1. */
1498 do_block = BLOCK_NUMBER (DECL_INITIAL (decl));
1499 sdbout_block (DECL_INITIAL (decl));
1501 /* If -g1, suppress all the internal symbols of functions
1502 except for arguments. */
1503 if (debug_info_level != DINFO_LEVEL_TERSE)
1505 do_block = n;
1506 sdbout_block (DECL_INITIAL (decl));
1509 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1510 sdbout_dequeue_anonymous_types ();
1511 #endif
1514 /* Describe the end line-number of an internal block within a function. */
1516 static void
1517 sdbout_end_block (unsigned int line, unsigned int n ATTRIBUTE_UNUSED)
1519 MAKE_LINE_SAFE (line);
1521 /* The SCO compiler does not emit a separate block for the function level
1522 scope, so we avoid it here also. However, mips ECOFF compilers do emit
1523 a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined. */
1524 #ifndef MIPS_DEBUGGING_INFO
1525 if (n != 1)
1526 #endif
1527 PUT_SDB_BLOCK_END (line - sdb_begin_function_line);
1530 /* Output a line number symbol entry for source file FILENAME and line
1531 number LINE. */
1533 static void
1534 sdbout_source_line (unsigned int line, const char *filename ATTRIBUTE_UNUSED)
1536 /* COFF relative line numbers must be positive. */
1537 if ((int) line > sdb_begin_function_line)
1539 #ifdef SDB_OUTPUT_SOURCE_LINE
1540 SDB_OUTPUT_SOURCE_LINE (asm_out_file, line);
1541 #else
1542 fprintf (asm_out_file, "\t.ln\t%d\n",
1543 ((sdb_begin_function_line > -1)
1544 ? line - sdb_begin_function_line : 1));
1545 #endif
1549 /* Output sdb info for the current function name.
1550 Called from assemble_start_function. */
1552 static void
1553 sdbout_begin_function (tree decl ATTRIBUTE_UNUSED)
1555 sdbout_symbol (current_function_decl, 0);
1558 /* Called at beginning of function body (before or after prologue,
1559 depending on MIPS_DEBUGGING_INFO). Record the function's starting
1560 line number, so we can output relative line numbers for the other
1561 lines. Describe beginning of outermost block. Also describe the
1562 parameter list. */
1564 #ifndef MIPS_DEBUGGING_INFO
1565 static void
1566 sdbout_begin_prologue (unsigned int line, const char *file ATTRIBUTE_UNUSED)
1568 sdbout_end_prologue (line, file);
1570 #endif
1572 static void
1573 sdbout_end_prologue (unsigned int line, const char *file ATTRIBUTE_UNUSED)
1575 sdb_begin_function_line = line - 1;
1576 PUT_SDB_FUNCTION_START (line);
1577 sdbout_parms (DECL_ARGUMENTS (current_function_decl));
1578 sdbout_reg_parms (DECL_ARGUMENTS (current_function_decl));
1581 /* Called at end of function (before epilogue).
1582 Describe end of outermost block. */
1584 static void
1585 sdbout_end_function (unsigned int line)
1587 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1588 sdbout_dequeue_anonymous_types ();
1589 #endif
1591 MAKE_LINE_SAFE (line);
1592 PUT_SDB_FUNCTION_END (line - sdb_begin_function_line);
1594 /* Indicate we are between functions, for line-number output. */
1595 sdb_begin_function_line = -1;
1598 /* Output sdb info for the absolute end of a function.
1599 Called after the epilogue is output. */
1601 static void
1602 sdbout_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
1603 const char *file ATTRIBUTE_UNUSED)
1605 const char *const name ATTRIBUTE_UNUSED
1606 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
1608 #ifdef PUT_SDB_EPILOGUE_END
1609 PUT_SDB_EPILOGUE_END (name);
1610 #else
1611 fprintf (asm_out_file, "\t.def\t");
1612 assemble_name (asm_out_file, name);
1613 fprintf (asm_out_file, "%s\t.val\t.%s\t.scl\t-1%s\t.endef\n",
1614 SDB_DELIM, SDB_DELIM, SDB_DELIM);
1615 #endif
1618 /* Output sdb info for the given label. Called only if LABEL_NAME (insn)
1619 is present. */
1621 static void
1622 sdbout_label (rtx insn)
1624 PUT_SDB_DEF (LABEL_NAME (insn));
1625 PUT_SDB_VAL (insn);
1626 PUT_SDB_SCL (C_LABEL);
1627 PUT_SDB_TYPE (T_NULL);
1628 PUT_SDB_ENDEF;
1631 /* Change to reading from a new source file. */
1633 static void
1634 sdbout_start_source_file (unsigned int line ATTRIBUTE_UNUSED,
1635 const char *filename ATTRIBUTE_UNUSED)
1637 #ifdef MIPS_DEBUGGING_INFO
1638 struct sdb_file *n = xmalloc (sizeof *n);
1640 n->next = current_file;
1641 n->name = filename;
1642 current_file = n;
1643 output_file_directive (asm_out_file, filename);
1644 #endif
1647 /* Revert to reading a previous source file. */
1649 static void
1650 sdbout_end_source_file (unsigned int line ATTRIBUTE_UNUSED)
1652 #ifdef MIPS_DEBUGGING_INFO
1653 struct sdb_file *next;
1655 next = current_file->next;
1656 free (current_file);
1657 current_file = next;
1658 output_file_directive (asm_out_file, current_file->name);
1659 #endif
1662 /* Set up for SDB output at the start of compilation. */
1664 static void
1665 sdbout_init (const char *input_file_name ATTRIBUTE_UNUSED)
1667 tree t;
1669 #ifdef MIPS_DEBUGGING_INFO
1670 current_file = xmalloc (sizeof *current_file);
1671 current_file->next = NULL;
1672 current_file->name = input_file_name;
1673 #endif
1675 VARRAY_TREE_INIT (deferred_global_decls, 12, "deferred_global_decls");
1677 /* Emit debug information which was queued by sdbout_symbol before
1678 we got here. */
1679 sdbout_initialized = true;
1681 for (t = nreverse (preinit_symbols); t; t = TREE_CHAIN (t))
1682 sdbout_symbol (TREE_VALUE (t), 0);
1683 preinit_symbols = 0;
1686 #else /* SDB_DEBUGGING_INFO */
1688 /* This should never be used, but its address is needed for comparisons. */
1689 const struct gcc_debug_hooks sdb_debug_hooks;
1691 #endif /* SDB_DEBUGGING_INFO */
1693 #include "gt-sdbout.h"