sourcebuild.texi: Add libcpp, now that CPP has its own directory.
[official-gcc.git] / gcc / sdbout.c
blob0398a5ad32bb2ef8b5fdb30aae1fb568aa69bf20
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 for sdbout_source_line. */
57 static GTY(()) int sdbout_source_line_counter;
59 /* Counter to generate unique "names" for nameless struct members. */
61 static GTY(()) int unnamed_struct_number;
63 /* Declarations whose debug info was deferred till end of compilation. */
65 static GTY(()) varray_type deferred_global_decls;
67 /* The C front end may call sdbout_symbol before sdbout_init runs.
68 We save all such decls in this list and output them when we get
69 to sdbout_init. */
71 static GTY(()) tree preinit_symbols;
72 static GTY(()) bool sdbout_initialized;
74 #ifdef SDB_DEBUGGING_INFO
76 #include "rtl.h"
77 #include "regs.h"
78 #include "flags.h"
79 #include "insn-config.h"
80 #include "reload.h"
81 #include "output.h"
82 #include "toplev.h"
83 #include "tm_p.h"
84 #include "gsyms.h"
85 #include "langhooks.h"
86 #include "target.h"
88 /* 1 if PARM is passed to this function in memory. */
90 #define PARM_PASSED_IN_MEMORY(PARM) \
91 (MEM_P (DECL_INCOMING_RTL (PARM)))
93 /* A C expression for the integer offset value of an automatic variable
94 (C_AUTO) having address X (an RTX). */
95 #ifndef DEBUGGER_AUTO_OFFSET
96 #define DEBUGGER_AUTO_OFFSET(X) \
97 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
98 #endif
100 /* A C expression for the integer offset value of an argument (C_ARG)
101 having address X (an RTX). The nominal offset is OFFSET. */
102 #ifndef DEBUGGER_ARG_OFFSET
103 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
104 #endif
106 /* Line number of beginning of current function, minus one.
107 Negative means not in a function or not using sdb. */
109 int sdb_begin_function_line = -1;
112 extern FILE *asm_out_file;
114 extern tree current_function_decl;
116 #include "sdbout.h"
118 static void sdbout_init (const char *);
119 static void sdbout_finish (const char *);
120 static void sdbout_start_source_file (unsigned int, const char *);
121 static void sdbout_end_source_file (unsigned int);
122 static void sdbout_begin_block (unsigned int, unsigned int);
123 static void sdbout_end_block (unsigned int, unsigned int);
124 static void sdbout_source_line (unsigned int, const char *);
125 static void sdbout_end_epilogue (unsigned int, const char *);
126 static void sdbout_global_decl (tree);
127 #ifndef MIPS_DEBUGGING_INFO
128 static void sdbout_begin_prologue (unsigned int, const char *);
129 #endif
130 static void sdbout_end_prologue (unsigned int, const char *);
131 static void sdbout_begin_function (tree);
132 static void sdbout_end_function (unsigned int);
133 static void sdbout_toplevel_data (tree);
134 static void sdbout_label (rtx);
135 static char *gen_fake_label (void);
136 static int plain_type (tree);
137 static int template_name_p (tree);
138 static void sdbout_record_type_name (tree);
139 static int plain_type_1 (tree, int);
140 static void sdbout_block (tree);
141 static void sdbout_syms (tree);
142 #ifdef SDB_ALLOW_FORWARD_REFERENCES
143 static void sdbout_queue_anonymous_type (tree);
144 static void sdbout_dequeue_anonymous_types (void);
145 #endif
146 static void sdbout_type (tree);
147 static void sdbout_field_types (tree);
148 static void sdbout_one_type (tree);
149 static void sdbout_parms (tree);
150 static void sdbout_reg_parms (tree);
151 static void sdbout_global_decl (tree);
153 /* Random macros describing parts of SDB data. */
155 /* Default value of delimiter is ";". */
156 #ifndef SDB_DELIM
157 #define SDB_DELIM ";"
158 #endif
160 /* Maximum number of dimensions the assembler will allow. */
161 #ifndef SDB_MAX_DIM
162 #define SDB_MAX_DIM 4
163 #endif
165 #ifndef PUT_SDB_SCL
166 #define PUT_SDB_SCL(a) fprintf(asm_out_file, "\t.scl\t%d%s", (a), SDB_DELIM)
167 #endif
169 #ifndef PUT_SDB_INT_VAL
170 #define PUT_SDB_INT_VAL(a) \
171 do { \
172 fprintf (asm_out_file, "\t.val\t" HOST_WIDE_INT_PRINT_DEC "%s", \
173 (HOST_WIDE_INT) (a), SDB_DELIM); \
174 } while (0)
176 #endif
178 #ifndef PUT_SDB_VAL
179 #define PUT_SDB_VAL(a) \
180 ( fputs ("\t.val\t", asm_out_file), \
181 output_addr_const (asm_out_file, (a)), \
182 fprintf (asm_out_file, SDB_DELIM))
183 #endif
185 #ifndef PUT_SDB_DEF
186 #define PUT_SDB_DEF(a) \
187 do { fprintf (asm_out_file, "\t.def\t"); \
188 assemble_name (asm_out_file, a); \
189 fprintf (asm_out_file, SDB_DELIM); } while (0)
190 #endif
192 #ifndef PUT_SDB_PLAIN_DEF
193 #define PUT_SDB_PLAIN_DEF(a) fprintf(asm_out_file,"\t.def\t.%s%s",a, SDB_DELIM)
194 #endif
196 #ifndef PUT_SDB_ENDEF
197 #define PUT_SDB_ENDEF fputs("\t.endef\n", asm_out_file)
198 #endif
200 #ifndef PUT_SDB_TYPE
201 #define PUT_SDB_TYPE(a) fprintf(asm_out_file, "\t.type\t0%o%s", a, SDB_DELIM)
202 #endif
204 #ifndef PUT_SDB_SIZE
205 #define PUT_SDB_SIZE(a) \
206 do { \
207 fprintf (asm_out_file, "\t.size\t" HOST_WIDE_INT_PRINT_DEC "%s", \
208 (HOST_WIDE_INT) (a), SDB_DELIM); \
209 } while(0)
210 #endif
212 #ifndef PUT_SDB_START_DIM
213 #define PUT_SDB_START_DIM fprintf(asm_out_file, "\t.dim\t")
214 #endif
216 #ifndef PUT_SDB_NEXT_DIM
217 #define PUT_SDB_NEXT_DIM(a) fprintf(asm_out_file, "%d,", a)
218 #endif
220 #ifndef PUT_SDB_LAST_DIM
221 #define PUT_SDB_LAST_DIM(a) fprintf(asm_out_file, "%d%s", a, SDB_DELIM)
222 #endif
224 #ifndef PUT_SDB_TAG
225 #define PUT_SDB_TAG(a) \
226 do { fprintf (asm_out_file, "\t.tag\t"); \
227 assemble_name (asm_out_file, a); \
228 fprintf (asm_out_file, SDB_DELIM); } while (0)
229 #endif
231 #ifndef PUT_SDB_BLOCK_START
232 #define PUT_SDB_BLOCK_START(LINE) \
233 fprintf (asm_out_file, \
234 "\t.def\t.bb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n", \
235 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
236 #endif
238 #ifndef PUT_SDB_BLOCK_END
239 #define PUT_SDB_BLOCK_END(LINE) \
240 fprintf (asm_out_file, \
241 "\t.def\t.eb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n", \
242 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
243 #endif
245 #ifndef PUT_SDB_FUNCTION_START
246 #define PUT_SDB_FUNCTION_START(LINE) \
247 fprintf (asm_out_file, \
248 "\t.def\t.bf%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \
249 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
250 #endif
252 #ifndef PUT_SDB_FUNCTION_END
253 #define PUT_SDB_FUNCTION_END(LINE) \
254 fprintf (asm_out_file, \
255 "\t.def\t.ef%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \
256 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
257 #endif
259 #ifndef SDB_GENERATE_FAKE
260 #define SDB_GENERATE_FAKE(BUFFER, NUMBER) \
261 sprintf ((BUFFER), ".%dfake", (NUMBER));
262 #endif
264 /* Return the sdb tag identifier string for TYPE
265 if TYPE has already been defined; otherwise return a null pointer. */
267 #define KNOWN_TYPE_TAG(type) TYPE_SYMTAB_POINTER (type)
269 /* Set the sdb tag identifier string for TYPE to NAME. */
271 #define SET_KNOWN_TYPE_TAG(TYPE, NAME) \
272 TYPE_SYMTAB_POINTER (TYPE) = (char *)(NAME)
274 /* Return the name (a string) of the struct, union or enum tag
275 described by the TREE_LIST node LINK. This is 0 for an anonymous one. */
277 #define TAG_NAME(link) \
278 (((link) && TREE_PURPOSE ((link)) \
279 && IDENTIFIER_POINTER (TREE_PURPOSE ((link)))) \
280 ? IDENTIFIER_POINTER (TREE_PURPOSE ((link))) : (char *) 0)
282 /* Ensure we don't output a negative line number. */
283 #define MAKE_LINE_SAFE(line) \
284 if ((int) line <= sdb_begin_function_line) \
285 line = sdb_begin_function_line + 1
287 /* Perform linker optimization of merging header file definitions together
288 for targets with MIPS_DEBUGGING_INFO defined. This won't work without a
289 post 960826 version of GAS. Nothing breaks with earlier versions of GAS,
290 the optimization just won't be done. The native assembler already has the
291 necessary support. */
293 #ifdef MIPS_DEBUGGING_INFO
295 #ifndef PUT_SDB_SRC_FILE
296 #define PUT_SDB_SRC_FILE(FILENAME) \
297 output_file_directive (asm_out_file, (FILENAME))
298 #endif
300 /* ECOFF linkers have an optimization that does the same kind of thing as
301 N_BINCL/E_INCL in stabs: eliminate duplicate debug information in the
302 executable. To achieve this, GCC must output a .file for each file
303 name change. */
305 /* This is a stack of input files. */
307 struct sdb_file
309 struct sdb_file *next;
310 const char *name;
313 /* This is the top of the stack. */
315 static struct sdb_file *current_file;
317 #endif /* MIPS_DEBUGGING_INFO */
319 /* The debug hooks structure. */
320 const struct gcc_debug_hooks sdb_debug_hooks =
322 sdbout_init, /* init */
323 sdbout_finish, /* finish */
324 debug_nothing_int_charstar, /* define */
325 debug_nothing_int_charstar, /* undef */
326 sdbout_start_source_file, /* start_source_file */
327 sdbout_end_source_file, /* end_source_file */
328 sdbout_begin_block, /* begin_block */
329 sdbout_end_block, /* end_block */
330 debug_true_tree, /* ignore_block */
331 sdbout_source_line, /* source_line */
332 #ifdef MIPS_DEBUGGING_INFO
333 /* Defer on MIPS systems so that parameter descriptions follow
334 function entry. */
335 debug_nothing_int_charstar, /* begin_prologue */
336 sdbout_end_prologue, /* end_prologue */
337 #else
338 sdbout_begin_prologue, /* begin_prologue */
339 debug_nothing_int_charstar, /* end_prologue */
340 #endif
341 sdbout_end_epilogue, /* end_epilogue */
342 sdbout_begin_function, /* begin_function */
343 sdbout_end_function, /* end_function */
344 debug_nothing_tree, /* function_decl */
345 sdbout_global_decl, /* global_decl */
346 sdbout_symbol, /* type_decl */
347 debug_nothing_tree_tree, /* imported_module_or_decl */
348 debug_nothing_tree, /* deferred_inline_function */
349 debug_nothing_tree, /* outlining_inline_function */
350 sdbout_label, /* label */
351 debug_nothing_int, /* handle_pch */
352 debug_nothing_rtx /* var_location */
355 /* Return a unique string to name an anonymous type. */
357 static char *
358 gen_fake_label (void)
360 char label[10];
361 char *labelstr;
362 SDB_GENERATE_FAKE (label, unnamed_struct_number);
363 unnamed_struct_number++;
364 labelstr = xstrdup (label);
365 return labelstr;
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
376 d1=D_FCN
377 d2=D_PTR
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;
399 static int
400 plain_type (tree type)
402 int val = plain_type_1 (type, 0);
404 /* If we have already saved up some array dimensions, print them now. */
405 if (sdb_n_dims > 0)
407 int i;
408 PUT_SDB_START_DIM;
409 for (i = sdb_n_dims - 1; i > 0; i--)
410 PUT_SDB_NEXT_DIM (sdb_dims[i]);
411 PUT_SDB_LAST_DIM (sdb_dims[0]);
412 sdb_n_dims = 0;
414 sdb_type_size = int_size_in_bytes (type);
415 /* Don't kill sdb if type is not laid out or has variable size. */
416 if (sdb_type_size < 0)
417 sdb_type_size = 0;
419 /* If we have computed the size of an array containing this type,
420 print it now. */
421 if (sdb_type_size >= 0)
423 PUT_SDB_SIZE (sdb_type_size);
424 sdb_type_size = -1;
426 return val;
429 static int
430 template_name_p (tree name)
432 const char *ptr = IDENTIFIER_POINTER (name);
433 while (*ptr && *ptr != '<')
434 ptr++;
436 return *ptr != '\0';
439 static void
440 sdbout_record_type_name (tree type)
442 const char *name = 0;
443 int no_name;
445 if (KNOWN_TYPE_TAG (type))
446 return;
448 if (TYPE_NAME (type) != 0)
450 tree t = 0;
452 /* Find the IDENTIFIER_NODE for the type name. */
453 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
454 t = TYPE_NAME (type);
455 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
457 t = DECL_NAME (TYPE_NAME (type));
458 /* The DECL_NAME for templates includes "<>", which breaks
459 most assemblers. Use its assembler name instead, which
460 has been mangled into being safe. */
461 if (t && template_name_p (t))
462 t = DECL_ASSEMBLER_NAME (TYPE_NAME (type));
465 /* Now get the name as a string, or invent one. */
466 if (t != NULL_TREE)
467 name = IDENTIFIER_POINTER (t);
470 no_name = (name == 0 || *name == 0);
471 if (no_name)
472 name = gen_fake_label ();
474 SET_KNOWN_TYPE_TAG (type, name);
475 #ifdef SDB_ALLOW_FORWARD_REFERENCES
476 if (no_name)
477 sdbout_queue_anonymous_type (type);
478 #endif
481 /* Return the .type value for type TYPE.
483 LEVEL indicates how many levels deep we have recursed into the type.
484 The SDB debug format can only represent 6 derived levels of types.
485 After that, we must output inaccurate debug info. We deliberately
486 stop before the 7th level, so that ADA recursive types will not give an
487 infinite loop. */
489 static int
490 plain_type_1 (tree type, int level)
492 if (type == 0)
493 type = void_type_node;
494 else if (type == error_mark_node)
495 type = integer_type_node;
496 else
497 type = TYPE_MAIN_VARIANT (type);
499 switch (TREE_CODE (type))
501 case VOID_TYPE:
502 return T_VOID;
503 case BOOLEAN_TYPE:
504 case INTEGER_TYPE:
506 int size = int_size_in_bytes (type) * BITS_PER_UNIT;
508 /* Carefully distinguish all the standard types of C,
509 without messing up if the language is not C.
510 Note that we check only for the names that contain spaces;
511 other names might occur by coincidence in other languages. */
512 if (TYPE_NAME (type) != 0
513 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
514 && DECL_NAME (TYPE_NAME (type)) != 0
515 && TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE)
517 const char *const name
518 = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
520 if (!strcmp (name, "char"))
521 return T_CHAR;
522 if (!strcmp (name, "unsigned char"))
523 return T_UCHAR;
524 if (!strcmp (name, "signed char"))
525 return T_CHAR;
526 if (!strcmp (name, "int"))
527 return T_INT;
528 if (!strcmp (name, "unsigned int"))
529 return T_UINT;
530 if (!strcmp (name, "short int"))
531 return T_SHORT;
532 if (!strcmp (name, "short unsigned int"))
533 return T_USHORT;
534 if (!strcmp (name, "long int"))
535 return T_LONG;
536 if (!strcmp (name, "long unsigned int"))
537 return T_ULONG;
540 if (size == INT_TYPE_SIZE)
541 return (TYPE_UNSIGNED (type) ? T_UINT : T_INT);
542 if (size == CHAR_TYPE_SIZE)
543 return (TYPE_UNSIGNED (type) ? T_UCHAR : T_CHAR);
544 if (size == SHORT_TYPE_SIZE)
545 return (TYPE_UNSIGNED (type) ? T_USHORT : T_SHORT);
546 if (size == LONG_TYPE_SIZE)
547 return (TYPE_UNSIGNED (type) ? T_ULONG : T_LONG);
548 if (size == LONG_LONG_TYPE_SIZE) /* better than nothing */
549 return (TYPE_UNSIGNED (type) ? T_ULONG : T_LONG);
550 return 0;
553 case REAL_TYPE:
555 int precision = TYPE_PRECISION (type);
556 if (precision == FLOAT_TYPE_SIZE)
557 return T_FLOAT;
558 if (precision == DOUBLE_TYPE_SIZE)
559 return T_DOUBLE;
560 #ifdef EXTENDED_SDB_BASIC_TYPES
561 if (precision == LONG_DOUBLE_TYPE_SIZE)
562 return T_LNGDBL;
563 #else
564 if (precision == LONG_DOUBLE_TYPE_SIZE)
565 return T_DOUBLE; /* better than nothing */
566 #endif
567 return 0;
570 case ARRAY_TYPE:
572 int m;
573 if (level >= 6)
574 return T_VOID;
575 else
576 m = plain_type_1 (TREE_TYPE (type), level+1);
577 if (sdb_n_dims < SDB_MAX_DIM)
578 sdb_dims[sdb_n_dims++]
579 = (TYPE_DOMAIN (type)
580 && TYPE_MIN_VALUE (TYPE_DOMAIN (type)) != 0
581 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != 0
582 && host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0)
583 && host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0)
584 ? (tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0)
585 - tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0) + 1)
586 : 0);
588 return PUSH_DERIVED_LEVEL (DT_ARY, m);
591 case RECORD_TYPE:
592 case UNION_TYPE:
593 case QUAL_UNION_TYPE:
594 case ENUMERAL_TYPE:
596 char *tag;
597 #ifdef SDB_ALLOW_FORWARD_REFERENCES
598 sdbout_record_type_name (type);
599 #endif
600 #ifndef SDB_ALLOW_UNKNOWN_REFERENCES
601 if ((TREE_ASM_WRITTEN (type) && KNOWN_TYPE_TAG (type) != 0)
602 #ifdef SDB_ALLOW_FORWARD_REFERENCES
603 || TYPE_MODE (type) != VOIDmode
604 #endif
606 #endif
608 /* Output the referenced structure tag name
609 only if the .def has already been finished.
610 At least on 386, the Unix assembler
611 cannot handle forward references to tags. */
612 /* But the 88100, it requires them, sigh... */
613 /* And the MIPS requires unknown refs as well... */
614 tag = KNOWN_TYPE_TAG (type);
615 PUT_SDB_TAG (tag);
616 /* These 3 lines used to follow the close brace.
617 However, a size of 0 without a tag implies a tag of 0,
618 so if we don't know a tag, we can't mention the size. */
619 sdb_type_size = int_size_in_bytes (type);
620 if (sdb_type_size < 0)
621 sdb_type_size = 0;
623 return ((TREE_CODE (type) == RECORD_TYPE) ? T_STRUCT
624 : (TREE_CODE (type) == UNION_TYPE) ? T_UNION
625 : (TREE_CODE (type) == QUAL_UNION_TYPE) ? T_UNION
626 : T_ENUM);
628 case POINTER_TYPE:
629 case REFERENCE_TYPE:
631 int m;
632 if (level >= 6)
633 return T_VOID;
634 else
635 m = plain_type_1 (TREE_TYPE (type), level+1);
636 return PUSH_DERIVED_LEVEL (DT_PTR, m);
638 case FUNCTION_TYPE:
639 case METHOD_TYPE:
641 int m;
642 if (level >= 6)
643 return T_VOID;
644 else
645 m = plain_type_1 (TREE_TYPE (type), level+1);
646 return PUSH_DERIVED_LEVEL (DT_FCN, m);
648 default:
649 return 0;
653 /* Output the symbols defined in block number DO_BLOCK.
655 This function works by walking the tree structure of blocks,
656 counting blocks until it finds the desired block. */
658 static int do_block = 0;
660 static void
661 sdbout_block (tree block)
663 while (block)
665 /* Ignore blocks never expanded or otherwise marked as real. */
666 if (TREE_USED (block))
668 /* When we reach the specified block, output its symbols. */
669 if (BLOCK_NUMBER (block) == do_block)
670 sdbout_syms (BLOCK_VARS (block));
672 /* If we are past the specified block, stop the scan. */
673 if (BLOCK_NUMBER (block) > do_block)
674 return;
676 /* Scan the blocks within this block. */
677 sdbout_block (BLOCK_SUBBLOCKS (block));
680 block = BLOCK_CHAIN (block);
684 /* Call sdbout_symbol on each decl in the chain SYMS. */
686 static void
687 sdbout_syms (tree syms)
689 while (syms)
691 if (TREE_CODE (syms) != LABEL_DECL)
692 sdbout_symbol (syms, 1);
693 syms = TREE_CHAIN (syms);
697 /* Output SDB information for a symbol described by DECL.
698 LOCAL is nonzero if the symbol is not file-scope. */
700 void
701 sdbout_symbol (tree decl, int local)
703 tree type = TREE_TYPE (decl);
704 tree context = NULL_TREE;
705 rtx value;
706 int regno = -1;
707 const char *name;
709 /* If we are called before sdbout_init is run, just save the symbol
710 for later. */
711 if (!sdbout_initialized)
713 preinit_symbols = tree_cons (0, decl, preinit_symbols);
714 return;
717 sdbout_one_type (type);
719 switch (TREE_CODE (decl))
721 case CONST_DECL:
722 /* Enum values are defined by defining the enum type. */
723 return;
725 case FUNCTION_DECL:
726 /* Don't mention a nested function under its parent. */
727 context = decl_function_context (decl);
728 if (context == current_function_decl)
729 return;
730 /* Check DECL_INITIAL to distinguish declarations from definitions.
731 Don't output debug info here for declarations; they will have
732 a DECL_INITIAL value of 0. */
733 if (! DECL_INITIAL (decl))
734 return;
735 if (!MEM_P (DECL_RTL (decl))
736 || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
737 return;
738 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
739 PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
740 PUT_SDB_SCL (TREE_PUBLIC (decl) ? C_EXT : C_STAT);
741 break;
743 case TYPE_DECL:
744 /* Done with tagged types. */
745 if (DECL_NAME (decl) == 0)
746 return;
747 if (DECL_IGNORED_P (decl))
748 return;
750 /* Output typedef name. */
751 if (template_name_p (DECL_NAME (decl)))
752 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
753 else
754 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_NAME (decl)));
755 PUT_SDB_SCL (C_TPDEF);
756 break;
758 case PARM_DECL:
759 /* Parm decls go in their own separate chains
760 and are output by sdbout_reg_parms and sdbout_parms. */
761 abort ();
763 case VAR_DECL:
764 /* Don't mention a variable that is external.
765 Let the file that defines it describe it. */
766 if (DECL_EXTERNAL (decl))
767 return;
769 /* Ignore __FUNCTION__, etc. */
770 if (DECL_IGNORED_P (decl))
771 return;
773 /* If there was an error in the declaration, don't dump core
774 if there is no RTL associated with the variable doesn't
775 exist. */
776 if (!DECL_RTL_SET_P (decl))
777 return;
779 SET_DECL_RTL (decl,
780 eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
781 #ifdef LEAF_REG_REMAP
782 if (current_function_uses_only_leaf_regs)
783 leaf_renumber_regs_insn (DECL_RTL (decl));
784 #endif
785 value = DECL_RTL (decl);
787 /* Don't mention a variable at all
788 if it was completely optimized into nothingness.
790 If DECL was from an inline function, then its rtl
791 is not identically the rtl that was used in this
792 particular compilation. */
793 if (REG_P (value))
795 regno = REGNO (value);
796 if (regno >= FIRST_PSEUDO_REGISTER)
797 return;
799 else if (GET_CODE (value) == SUBREG)
801 while (GET_CODE (value) == SUBREG)
802 value = SUBREG_REG (value);
803 if (REG_P (value))
805 if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
806 return;
808 regno = REGNO (alter_subreg (&value));
809 SET_DECL_RTL (decl, value);
811 /* Don't output anything if an auto variable
812 gets RTL that is static.
813 GAS version 2.2 can't handle such output. */
814 else if (MEM_P (value) && CONSTANT_P (XEXP (value, 0))
815 && ! TREE_STATIC (decl))
816 return;
818 /* Emit any structure, union, or enum type that has not been output.
819 This occurs for tag-less structs (et al) used to declare variables
820 within functions. */
821 if (TREE_CODE (type) == ENUMERAL_TYPE
822 || TREE_CODE (type) == RECORD_TYPE
823 || TREE_CODE (type) == UNION_TYPE
824 || TREE_CODE (type) == QUAL_UNION_TYPE)
826 if (COMPLETE_TYPE_P (type) /* not a forward reference */
827 && KNOWN_TYPE_TAG (type) == 0) /* not yet declared */
828 sdbout_one_type (type);
831 /* Defer SDB information for top-level initialized variables! */
832 if (! local
833 && MEM_P (value)
834 && DECL_INITIAL (decl))
835 return;
837 /* C++ in 2.3 makes nameless symbols. That will be fixed later.
838 For now, avoid crashing. */
839 if (DECL_NAME (decl) == NULL_TREE)
840 return;
842 /* Record the name for, starting a symtab entry. */
843 if (local)
844 name = IDENTIFIER_POINTER (DECL_NAME (decl));
845 else
846 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
848 if (MEM_P (value)
849 && GET_CODE (XEXP (value, 0)) == SYMBOL_REF)
851 PUT_SDB_DEF (name);
852 if (TREE_PUBLIC (decl))
854 PUT_SDB_VAL (XEXP (value, 0));
855 PUT_SDB_SCL (C_EXT);
857 else
859 PUT_SDB_VAL (XEXP (value, 0));
860 PUT_SDB_SCL (C_STAT);
863 else if (regno >= 0)
865 PUT_SDB_DEF (name);
866 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (regno));
867 PUT_SDB_SCL (C_REG);
869 else if (MEM_P (value)
870 && (MEM_P (XEXP (value, 0))
871 || (REG_P (XEXP (value, 0))
872 && REGNO (XEXP (value, 0)) != HARD_FRAME_POINTER_REGNUM
873 && REGNO (XEXP (value, 0)) != STACK_POINTER_REGNUM)))
874 /* If the value is indirect by memory or by a register
875 that isn't the frame pointer
876 then it means the object is variable-sized and address through
877 that register or stack slot. COFF has no way to represent this
878 so all we can do is output the variable as a pointer. */
880 PUT_SDB_DEF (name);
881 if (REG_P (XEXP (value, 0)))
883 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (XEXP (value, 0))));
884 PUT_SDB_SCL (C_REG);
886 else
888 /* DECL_RTL looks like (MEM (MEM (PLUS (REG...)
889 (CONST_INT...)))).
890 We want the value of that CONST_INT. */
891 /* Encore compiler hates a newline in a macro arg, it seems. */
892 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
893 (XEXP (XEXP (value, 0), 0)));
894 PUT_SDB_SCL (C_AUTO);
897 /* Effectively do build_pointer_type, but don't cache this type,
898 since it might be temporary whereas the type it points to
899 might have been saved for inlining. */
900 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
901 type = make_node (POINTER_TYPE);
902 TREE_TYPE (type) = TREE_TYPE (decl);
904 else if (MEM_P (value)
905 && ((GET_CODE (XEXP (value, 0)) == PLUS
906 && REG_P (XEXP (XEXP (value, 0), 0))
907 && GET_CODE (XEXP (XEXP (value, 0), 1)) == CONST_INT)
908 /* This is for variables which are at offset zero from
909 the frame pointer. This happens on the Alpha.
910 Non-frame pointer registers are excluded above. */
911 || (REG_P (XEXP (value, 0)))))
913 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
914 or (MEM (REG...)). We want the value of that CONST_INT
915 or zero. */
916 PUT_SDB_DEF (name);
917 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET (XEXP (value, 0)));
918 PUT_SDB_SCL (C_AUTO);
920 else
922 /* It is something we don't know how to represent for SDB. */
923 return;
925 break;
927 default:
928 break;
930 PUT_SDB_TYPE (plain_type (type));
931 PUT_SDB_ENDEF;
934 /* Output SDB information for a top-level initialized variable
935 that has been delayed. */
937 static void
938 sdbout_toplevel_data (tree decl)
940 tree type = TREE_TYPE (decl);
942 if (DECL_IGNORED_P (decl))
943 return;
945 if (! (TREE_CODE (decl) == VAR_DECL
946 && MEM_P (DECL_RTL (decl))
947 && DECL_INITIAL (decl)))
948 abort ();
950 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
951 PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
952 if (TREE_PUBLIC (decl))
954 PUT_SDB_SCL (C_EXT);
956 else
958 PUT_SDB_SCL (C_STAT);
960 PUT_SDB_TYPE (plain_type (type));
961 PUT_SDB_ENDEF;
964 #ifdef SDB_ALLOW_FORWARD_REFERENCES
966 /* Machinery to record and output anonymous types. */
968 static void
969 sdbout_queue_anonymous_type (tree type)
971 anonymous_types = tree_cons (NULL_TREE, type, anonymous_types);
974 static void
975 sdbout_dequeue_anonymous_types (void)
977 tree types, link;
979 while (anonymous_types)
981 types = nreverse (anonymous_types);
982 anonymous_types = NULL_TREE;
984 for (link = types; link; link = TREE_CHAIN (link))
986 tree type = TREE_VALUE (link);
988 if (type && ! TREE_ASM_WRITTEN (type))
989 sdbout_one_type (type);
994 #endif
996 /* Given a chain of ..._TYPE nodes, all of which have names,
997 output definitions of those names, as typedefs. */
999 void
1000 sdbout_types (tree types)
1002 tree link;
1004 for (link = types; link; link = TREE_CHAIN (link))
1005 sdbout_one_type (link);
1007 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1008 sdbout_dequeue_anonymous_types ();
1009 #endif
1012 static void
1013 sdbout_type (tree type)
1015 if (type == error_mark_node)
1016 type = integer_type_node;
1017 PUT_SDB_TYPE (plain_type (type));
1020 /* Output types of the fields of type TYPE, if they are structs.
1022 Formerly did not chase through pointer types, since that could be circular.
1023 They must come before TYPE, since forward refs are not allowed.
1024 Now james@bigtex.cactus.org says to try them. */
1026 static void
1027 sdbout_field_types (tree type)
1029 tree tail;
1031 for (tail = TYPE_FIELDS (type); tail; tail = TREE_CHAIN (tail))
1032 /* This condition should match the one for emitting the actual
1033 members below. */
1034 if (TREE_CODE (tail) == FIELD_DECL
1035 && DECL_NAME (tail)
1036 && DECL_SIZE (tail)
1037 && host_integerp (DECL_SIZE (tail), 1)
1038 && host_integerp (bit_position (tail), 0))
1040 if (POINTER_TYPE_P (TREE_TYPE (tail)))
1041 sdbout_one_type (TREE_TYPE (TREE_TYPE (tail)));
1042 else
1043 sdbout_one_type (TREE_TYPE (tail));
1047 /* Use this to put out the top level defined record and union types
1048 for later reference. If this is a struct with a name, then put that
1049 name out. Other unnamed structs will have .xxfake labels generated so
1050 that they may be referred to later.
1051 The label will be stored in the KNOWN_TYPE_TAG slot of a type.
1052 It may NOT be called recursively. */
1054 static void
1055 sdbout_one_type (tree type)
1057 if (current_function_decl != NULL_TREE
1058 && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
1059 ; /* Don't change section amid function. */
1060 else
1061 text_section ();
1063 switch (TREE_CODE (type))
1065 case RECORD_TYPE:
1066 case UNION_TYPE:
1067 case QUAL_UNION_TYPE:
1068 case ENUMERAL_TYPE:
1069 type = TYPE_MAIN_VARIANT (type);
1070 /* Don't output a type twice. */
1071 if (TREE_ASM_WRITTEN (type))
1072 /* James said test TREE_ASM_BEING_WRITTEN here. */
1073 return;
1075 /* Output nothing if type is not yet defined. */
1076 if (!COMPLETE_TYPE_P (type))
1077 return;
1079 TREE_ASM_WRITTEN (type) = 1;
1081 /* This is reputed to cause trouble with the following case,
1082 but perhaps checking TYPE_SIZE above will fix it. */
1084 /* Here is a testcase:
1086 struct foo {
1087 struct badstr *bbb;
1088 } forwardref;
1090 typedef struct intermediate {
1091 int aaaa;
1092 } intermediate_ref;
1094 typedef struct badstr {
1095 int ccccc;
1096 } badtype; */
1098 /* This change, which ought to make better output,
1099 used to make the COFF assembler unhappy.
1100 Changes involving KNOWN_TYPE_TAG may fix the problem. */
1101 /* Before really doing anything, output types we want to refer to. */
1102 /* Note that in version 1 the following two lines
1103 are not used if forward references are in use. */
1104 if (TREE_CODE (type) != ENUMERAL_TYPE)
1105 sdbout_field_types (type);
1107 /* Output a structure type. */
1109 int size = int_size_in_bytes (type);
1110 int member_scl = 0;
1111 tree tem;
1112 int i, n_baseclasses = 0;
1114 /* Record the type tag, but not in its permanent place just yet. */
1115 sdbout_record_type_name (type);
1117 PUT_SDB_DEF (KNOWN_TYPE_TAG (type));
1119 switch (TREE_CODE (type))
1121 case UNION_TYPE:
1122 case QUAL_UNION_TYPE:
1123 PUT_SDB_SCL (C_UNTAG);
1124 PUT_SDB_TYPE (T_UNION);
1125 member_scl = C_MOU;
1126 break;
1128 case RECORD_TYPE:
1129 PUT_SDB_SCL (C_STRTAG);
1130 PUT_SDB_TYPE (T_STRUCT);
1131 member_scl = C_MOS;
1132 break;
1134 case ENUMERAL_TYPE:
1135 PUT_SDB_SCL (C_ENTAG);
1136 PUT_SDB_TYPE (T_ENUM);
1137 member_scl = C_MOE;
1138 break;
1140 default:
1141 break;
1144 PUT_SDB_SIZE (size);
1145 PUT_SDB_ENDEF;
1147 /* Print out the base class information with fields
1148 named after the types they hold. */
1149 /* This is only relevant to aggregate types. TYPE_BINFO is used
1150 for other purposes in an ENUMERAL_TYPE, so we must exclude that
1151 case. */
1152 if (TREE_CODE (type) != ENUMERAL_TYPE)
1154 if (TYPE_BINFO (type) && BINFO_BASE_BINFOS (TYPE_BINFO (type)))
1155 n_baseclasses = BINFO_N_BASE_BINFOS (TYPE_BINFO (type));
1157 for (i = 0; i < n_baseclasses; i++)
1159 tree child = BINFO_BASE_BINFO (TYPE_BINFO (type), i);
1160 tree child_type = BINFO_TYPE (child);
1161 tree child_type_name;
1162 if (TYPE_NAME (child_type) == 0)
1163 continue;
1164 if (TREE_CODE (TYPE_NAME (child_type)) == IDENTIFIER_NODE)
1165 child_type_name = TYPE_NAME (child_type);
1166 else if (TREE_CODE (TYPE_NAME (child_type)) == TYPE_DECL)
1168 child_type_name = DECL_NAME (TYPE_NAME (child_type));
1169 if (child_type_name && template_name_p (child_type_name))
1170 child_type_name
1171 = DECL_ASSEMBLER_NAME (TYPE_NAME (child_type));
1173 else
1174 continue;
1176 PUT_SDB_DEF (IDENTIFIER_POINTER (child_type_name));
1177 PUT_SDB_INT_VAL (tree_low_cst (BINFO_OFFSET (child), 0));
1178 PUT_SDB_SCL (member_scl);
1179 sdbout_type (BINFO_TYPE (child));
1180 PUT_SDB_ENDEF;
1184 /* Output the individual fields. */
1186 if (TREE_CODE (type) == ENUMERAL_TYPE)
1188 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
1189 if (host_integerp (TREE_VALUE (tem), 0))
1191 PUT_SDB_DEF (IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1192 PUT_SDB_INT_VAL (tree_low_cst (TREE_VALUE (tem), 0));
1193 PUT_SDB_SCL (C_MOE);
1194 PUT_SDB_TYPE (T_MOE);
1195 PUT_SDB_ENDEF;
1198 else /* record or union type */
1199 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1200 /* Output the name, type, position (in bits), size (in bits)
1201 of each field. */
1203 /* Omit here the nameless fields that are used to skip bits.
1204 Also omit fields with variable size or position.
1205 Also omit non FIELD_DECL nodes that GNU C++ may put here. */
1206 if (TREE_CODE (tem) == FIELD_DECL
1207 && DECL_NAME (tem)
1208 && DECL_SIZE (tem)
1209 && host_integerp (DECL_SIZE (tem), 1)
1210 && host_integerp (bit_position (tem), 0))
1212 const char *name;
1214 name = IDENTIFIER_POINTER (DECL_NAME (tem));
1215 PUT_SDB_DEF (name);
1216 if (DECL_BIT_FIELD_TYPE (tem))
1218 PUT_SDB_INT_VAL (int_bit_position (tem));
1219 PUT_SDB_SCL (C_FIELD);
1220 sdbout_type (DECL_BIT_FIELD_TYPE (tem));
1221 PUT_SDB_SIZE (tree_low_cst (DECL_SIZE (tem), 1));
1223 else
1225 PUT_SDB_INT_VAL (int_bit_position (tem) / BITS_PER_UNIT);
1226 PUT_SDB_SCL (member_scl);
1227 sdbout_type (TREE_TYPE (tem));
1229 PUT_SDB_ENDEF;
1231 /* Output end of a structure,union, or enumeral definition. */
1233 PUT_SDB_PLAIN_DEF ("eos");
1234 PUT_SDB_INT_VAL (size);
1235 PUT_SDB_SCL (C_EOS);
1236 PUT_SDB_TAG (KNOWN_TYPE_TAG (type));
1237 PUT_SDB_SIZE (size);
1238 PUT_SDB_ENDEF;
1239 break;
1241 default:
1242 break;
1247 /* The following two functions output definitions of function parameters.
1248 Each parameter gets a definition locating it in the parameter list.
1249 Each parameter that is a register variable gets a second definition
1250 locating it in the register.
1252 Printing or argument lists in gdb uses the definitions that
1253 locate in the parameter list. But reference to the variable in
1254 expressions uses preferentially the definition as a register. */
1256 /* Output definitions, referring to storage in the parmlist,
1257 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
1259 static void
1260 sdbout_parms (tree parms)
1262 for (; parms; parms = TREE_CHAIN (parms))
1263 if (DECL_NAME (parms))
1265 int current_sym_value = 0;
1266 const char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
1268 if (name == 0 || *name == 0)
1269 name = gen_fake_label ();
1271 /* Perform any necessary register eliminations on the parameter's rtl,
1272 so that the debugging output will be accurate. */
1273 DECL_INCOMING_RTL (parms)
1274 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
1275 SET_DECL_RTL (parms,
1276 eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
1278 if (PARM_PASSED_IN_MEMORY (parms))
1280 rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
1281 tree type;
1283 /* ??? Here we assume that the parm address is indexed
1284 off the frame pointer or arg pointer.
1285 If that is not true, we produce meaningless results,
1286 but do not crash. */
1287 if (GET_CODE (addr) == PLUS
1288 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
1289 current_sym_value = INTVAL (XEXP (addr, 1));
1290 else
1291 current_sym_value = 0;
1293 if (REG_P (DECL_RTL (parms))
1294 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1295 type = DECL_ARG_TYPE (parms);
1296 else
1298 int original_sym_value = current_sym_value;
1300 /* This is the case where the parm is passed as an int or
1301 double and it is converted to a char, short or float
1302 and stored back in the parmlist. In this case, describe
1303 the parm with the variable's declared type, and adjust
1304 the address if the least significant bytes (which we are
1305 using) are not the first ones. */
1306 if (BYTES_BIG_ENDIAN
1307 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1308 current_sym_value +=
1309 (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1310 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1312 if (MEM_P (DECL_RTL (parms))
1313 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1314 && (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1))
1315 == CONST_INT)
1316 && (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1))
1317 == current_sym_value))
1318 type = TREE_TYPE (parms);
1319 else
1321 current_sym_value = original_sym_value;
1322 type = DECL_ARG_TYPE (parms);
1326 PUT_SDB_DEF (name);
1327 PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value, addr));
1328 PUT_SDB_SCL (C_ARG);
1329 PUT_SDB_TYPE (plain_type (type));
1330 PUT_SDB_ENDEF;
1332 else if (REG_P (DECL_RTL (parms)))
1334 rtx best_rtl;
1335 /* Parm passed in registers and lives in registers or nowhere. */
1337 /* If parm lives in a register, use that register;
1338 pretend the parm was passed there. It would be more consistent
1339 to describe the register where the parm was passed,
1340 but in practice that register usually holds something else. */
1341 if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1342 best_rtl = DECL_RTL (parms);
1343 /* If the parm lives nowhere,
1344 use the register where it was passed. */
1345 else
1346 best_rtl = DECL_INCOMING_RTL (parms);
1348 PUT_SDB_DEF (name);
1349 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (best_rtl)));
1350 PUT_SDB_SCL (C_REGPARM);
1351 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1352 PUT_SDB_ENDEF;
1354 else if (MEM_P (DECL_RTL (parms))
1355 && XEXP (DECL_RTL (parms), 0) != const0_rtx)
1357 /* Parm was passed in registers but lives on the stack. */
1359 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
1360 in which case we want the value of that CONST_INT,
1361 or (MEM (REG ...)) or (MEM (MEM ...)),
1362 in which case we use a value of zero. */
1363 if (REG_P (XEXP (DECL_RTL (parms), 0))
1364 || MEM_P (XEXP (DECL_RTL (parms), 0)))
1365 current_sym_value = 0;
1366 else
1367 current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
1369 /* Again, this assumes the offset is based on the arg pointer. */
1370 PUT_SDB_DEF (name);
1371 PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value,
1372 XEXP (DECL_RTL (parms), 0)));
1373 PUT_SDB_SCL (C_ARG);
1374 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1375 PUT_SDB_ENDEF;
1380 /* Output definitions for the places where parms live during the function,
1381 when different from where they were passed, when the parms were passed
1382 in memory.
1384 It is not useful to do this for parms passed in registers
1385 that live during the function in different registers, because it is
1386 impossible to look in the passed register for the passed value,
1387 so we use the within-the-function register to begin with.
1389 PARMS is a chain of PARM_DECL nodes. */
1391 static void
1392 sdbout_reg_parms (tree parms)
1394 for (; parms; parms = TREE_CHAIN (parms))
1395 if (DECL_NAME (parms))
1397 const char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
1399 /* Report parms that live in registers during the function
1400 but were passed in memory. */
1401 if (REG_P (DECL_RTL (parms))
1402 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER
1403 && PARM_PASSED_IN_MEMORY (parms))
1405 if (name == 0 || *name == 0)
1406 name = gen_fake_label ();
1407 PUT_SDB_DEF (name);
1408 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms))));
1409 PUT_SDB_SCL (C_REG);
1410 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1411 PUT_SDB_ENDEF;
1413 /* Report parms that live in memory but not where they were passed. */
1414 else if (MEM_P (DECL_RTL (parms))
1415 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1416 && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
1417 && PARM_PASSED_IN_MEMORY (parms)
1418 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
1420 #if 0 /* ??? It is not clear yet what should replace this. */
1421 int offset = DECL_OFFSET (parms) / BITS_PER_UNIT;
1422 /* A parm declared char is really passed as an int,
1423 so it occupies the least significant bytes.
1424 On a big-endian machine those are not the low-numbered ones. */
1425 if (BYTES_BIG_ENDIAN
1426 && offset != -1
1427 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1428 offset += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1429 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1430 if (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) != offset) {...}
1431 #endif
1433 if (name == 0 || *name == 0)
1434 name = gen_fake_label ();
1435 PUT_SDB_DEF (name);
1436 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
1437 (XEXP (DECL_RTL (parms), 0)));
1438 PUT_SDB_SCL (C_AUTO);
1439 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1440 PUT_SDB_ENDEF;
1446 /* Output debug information for a global DECL. Called from toplev.c
1447 after compilation proper has finished. */
1449 static void
1450 sdbout_global_decl (tree decl)
1452 if (TREE_CODE (decl) == VAR_DECL
1453 && !DECL_EXTERNAL (decl)
1454 && DECL_RTL_SET_P (decl))
1456 /* The COFF linker can move initialized global vars to the end.
1457 And that can screw up the symbol ordering. Defer those for
1458 sdbout_finish (). */
1459 if (!DECL_INITIAL (decl) || !TREE_PUBLIC (decl))
1460 sdbout_symbol (decl, 0);
1461 else
1462 VARRAY_PUSH_TREE (deferred_global_decls, decl);
1464 /* Output COFF information for non-global file-scope initialized
1465 variables. */
1466 if (DECL_INITIAL (decl) && MEM_P (DECL_RTL (decl)))
1467 sdbout_toplevel_data (decl);
1471 /* Output initialized global vars at the end, in the order of
1472 definition. See comment in sdbout_global_decl. */
1474 static void
1475 sdbout_finish (const char *main_filename ATTRIBUTE_UNUSED)
1477 size_t i;
1479 for (i = 0; i < VARRAY_ACTIVE_SIZE (deferred_global_decls); i++)
1480 sdbout_symbol (VARRAY_TREE (deferred_global_decls, i), 0);
1483 /* Describe the beginning of an internal block within a function.
1484 Also output descriptions of variables defined in this block.
1486 N is the number of the block, by order of beginning, counting from 1,
1487 and not counting the outermost (function top-level) block.
1488 The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
1489 if the count starts at 0 for the outermost one. */
1491 static void
1492 sdbout_begin_block (unsigned int line, unsigned int n)
1494 tree decl = current_function_decl;
1495 MAKE_LINE_SAFE (line);
1497 /* The SCO compiler does not emit a separate block for the function level
1498 scope, so we avoid it here also. However, mips ECOFF compilers do emit
1499 a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined. */
1500 #ifndef MIPS_DEBUGGING_INFO
1501 if (n != 1)
1502 #endif
1503 PUT_SDB_BLOCK_START (line - sdb_begin_function_line);
1505 if (n == 1)
1507 /* Include the outermost BLOCK's variables in block 1. */
1508 do_block = BLOCK_NUMBER (DECL_INITIAL (decl));
1509 sdbout_block (DECL_INITIAL (decl));
1511 /* If -g1, suppress all the internal symbols of functions
1512 except for arguments. */
1513 if (debug_info_level != DINFO_LEVEL_TERSE)
1515 do_block = n;
1516 sdbout_block (DECL_INITIAL (decl));
1519 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1520 sdbout_dequeue_anonymous_types ();
1521 #endif
1524 /* Describe the end line-number of an internal block within a function. */
1526 static void
1527 sdbout_end_block (unsigned int line, unsigned int n ATTRIBUTE_UNUSED)
1529 MAKE_LINE_SAFE (line);
1531 /* The SCO compiler does not emit a separate block for the function level
1532 scope, so we avoid it here also. However, mips ECOFF compilers do emit
1533 a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined. */
1534 #ifndef MIPS_DEBUGGING_INFO
1535 if (n != 1)
1536 #endif
1537 PUT_SDB_BLOCK_END (line - sdb_begin_function_line);
1540 /* Output a line number symbol entry for source file FILENAME and line
1541 number LINE. */
1543 static void
1544 sdbout_source_line (unsigned int line, const char *filename ATTRIBUTE_UNUSED)
1546 /* COFF relative line numbers must be positive. */
1547 if ((int) line > sdb_begin_function_line)
1549 #ifdef ASM_OUTPUT_SOURCE_LINE
1550 sdbout_source_line_counter += 1;
1551 ASM_OUTPUT_SOURCE_LINE (asm_out_file, line, sdbout_source_line_counter);
1552 #else
1553 fprintf (asm_out_file, "\t.ln\t%d\n",
1554 ((sdb_begin_function_line > -1)
1555 ? line - sdb_begin_function_line : 1));
1556 #endif
1560 /* Output sdb info for the current function name.
1561 Called from assemble_start_function. */
1563 static void
1564 sdbout_begin_function (tree decl ATTRIBUTE_UNUSED)
1566 sdbout_symbol (current_function_decl, 0);
1569 /* Called at beginning of function body (before or after prologue,
1570 depending on MIPS_DEBUGGING_INFO). Record the function's starting
1571 line number, so we can output relative line numbers for the other
1572 lines. Describe beginning of outermost block. Also describe the
1573 parameter list. */
1575 #ifndef MIPS_DEBUGGING_INFO
1576 static void
1577 sdbout_begin_prologue (unsigned int line, const char *file ATTRIBUTE_UNUSED)
1579 sdbout_end_prologue (line, file);
1581 #endif
1583 static void
1584 sdbout_end_prologue (unsigned int line, const char *file ATTRIBUTE_UNUSED)
1586 sdb_begin_function_line = line - 1;
1587 PUT_SDB_FUNCTION_START (line);
1588 sdbout_parms (DECL_ARGUMENTS (current_function_decl));
1589 sdbout_reg_parms (DECL_ARGUMENTS (current_function_decl));
1592 /* Called at end of function (before epilogue).
1593 Describe end of outermost block. */
1595 static void
1596 sdbout_end_function (unsigned int line)
1598 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1599 sdbout_dequeue_anonymous_types ();
1600 #endif
1602 MAKE_LINE_SAFE (line);
1603 PUT_SDB_FUNCTION_END (line - sdb_begin_function_line);
1605 /* Indicate we are between functions, for line-number output. */
1606 sdb_begin_function_line = -1;
1609 /* Output sdb info for the absolute end of a function.
1610 Called after the epilogue is output. */
1612 static void
1613 sdbout_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
1614 const char *file ATTRIBUTE_UNUSED)
1616 const char *const name ATTRIBUTE_UNUSED
1617 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
1619 #ifdef PUT_SDB_EPILOGUE_END
1620 PUT_SDB_EPILOGUE_END (name);
1621 #else
1622 fprintf (asm_out_file, "\t.def\t");
1623 assemble_name (asm_out_file, name);
1624 fprintf (asm_out_file, "%s\t.val\t.%s\t.scl\t-1%s\t.endef\n",
1625 SDB_DELIM, SDB_DELIM, SDB_DELIM);
1626 #endif
1629 /* Output sdb info for the given label. Called only if LABEL_NAME (insn)
1630 is present. */
1632 static void
1633 sdbout_label (rtx insn)
1635 PUT_SDB_DEF (LABEL_NAME (insn));
1636 PUT_SDB_VAL (insn);
1637 PUT_SDB_SCL (C_LABEL);
1638 PUT_SDB_TYPE (T_NULL);
1639 PUT_SDB_ENDEF;
1642 /* Change to reading from a new source file. */
1644 static void
1645 sdbout_start_source_file (unsigned int line ATTRIBUTE_UNUSED,
1646 const char *filename ATTRIBUTE_UNUSED)
1648 #ifdef MIPS_DEBUGGING_INFO
1649 struct sdb_file *n = xmalloc (sizeof *n);
1651 n->next = current_file;
1652 n->name = filename;
1653 current_file = n;
1654 PUT_SDB_SRC_FILE (filename);
1655 #endif
1658 /* Revert to reading a previous source file. */
1660 static void
1661 sdbout_end_source_file (unsigned int line ATTRIBUTE_UNUSED)
1663 #ifdef MIPS_DEBUGGING_INFO
1664 struct sdb_file *next;
1666 next = current_file->next;
1667 free (current_file);
1668 current_file = next;
1669 PUT_SDB_SRC_FILE (current_file->name);
1670 #endif
1673 /* Set up for SDB output at the start of compilation. */
1675 static void
1676 sdbout_init (const char *input_file_name ATTRIBUTE_UNUSED)
1678 tree t;
1680 #ifdef MIPS_DEBUGGING_INFO
1681 current_file = xmalloc (sizeof *current_file);
1682 current_file->next = NULL;
1683 current_file->name = input_file_name;
1684 #endif
1686 VARRAY_TREE_INIT (deferred_global_decls, 12, "deferred_global_decls");
1688 /* Emit debug information which was queued by sdbout_symbol before
1689 we got here. */
1690 sdbout_initialized = true;
1692 for (t = nreverse (preinit_symbols); t; t = TREE_CHAIN (t))
1693 sdbout_symbol (TREE_VALUE (t), 0);
1694 preinit_symbols = 0;
1697 #else /* SDB_DEBUGGING_INFO */
1699 /* This should never be used, but its address is needed for comparisons. */
1700 const struct gcc_debug_hooks sdb_debug_hooks;
1702 #endif /* SDB_DEBUGGING_INFO */
1704 #include "gt-sdbout.h"