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, 2005 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
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.
11
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.
16
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, 51 Franklin Street, Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
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:
25
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.
29
30 2. All functions and their locals (including statics) are emitted as scanned.
31
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.
35
36 4. All structure .defs are emitted before the typedefs that refer to them.
37
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.
40
41 6. All undefined references are at the end of the file.
42 */
43
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"
52
53 static GTY(()) tree anonymous_types;
54
55 /* Counter to generate unique "names" for nameless struct members. */
56
57 static GTY(()) int unnamed_struct_number;
58
59 /* Declarations whose debug info was deferred till end of compilation. */
60
61 static GTY(()) varray_type deferred_global_decls;
62
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. */
66
67 static GTY(()) tree preinit_symbols;
68 static GTY(()) bool sdbout_initialized;
69
70 #ifdef SDB_DEBUGGING_INFO
71
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"
83
84 /* 1 if PARM is passed to this function in memory. */
85
86 #define PARM_PASSED_IN_MEMORY(PARM) \
87 (MEM_P (DECL_INCOMING_RTL (PARM)))
88
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
95
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
101
102 /* Line number of beginning of current function, minus one.
103 Negative means not in a function or not using sdb. */
104
105 int sdb_begin_function_line = -1;
106
107
108 extern FILE *asm_out_file;
109
110 extern tree current_function_decl;
111
112 #include "sdbout.h"
113
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);
148
149 /* Random macros describing parts of SDB data. */
150
151 /* Default value of delimiter is ";". */
152 #ifndef SDB_DELIM
153 #define SDB_DELIM ";"
154 #endif
155
156 /* Maximum number of dimensions the assembler will allow. */
157 #ifndef SDB_MAX_DIM
158 #define SDB_MAX_DIM 4
159 #endif
160
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
164
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)
171
172 #endif
173
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
180
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
187
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
191
192 #ifndef PUT_SDB_ENDEF
193 #define PUT_SDB_ENDEF fputs("\t.endef\n", asm_out_file)
194 #endif
195
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
199
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
207
208 #ifndef PUT_SDB_START_DIM
209 #define PUT_SDB_START_DIM fprintf(asm_out_file, "\t.dim\t")
210 #endif
211
212 #ifndef PUT_SDB_NEXT_DIM
213 #define PUT_SDB_NEXT_DIM(a) fprintf(asm_out_file, "%d,", a)
214 #endif
215
216 #ifndef PUT_SDB_LAST_DIM
217 #define PUT_SDB_LAST_DIM(a) fprintf(asm_out_file, "%d%s", a, SDB_DELIM)
218 #endif
219
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
226
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
233
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
240
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
247
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
254
255 /* Return the sdb tag identifier string for TYPE
256 if TYPE has already been defined; otherwise return a null pointer. */
257
258 #define KNOWN_TYPE_TAG(type) TYPE_SYMTAB_POINTER (type)
259
260 /* Set the sdb tag identifier string for TYPE to NAME. */
261
262 #define SET_KNOWN_TYPE_TAG(TYPE, NAME) \
263 TYPE_SYMTAB_POINTER (TYPE) = (char *)(NAME)
264
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. */
267
268 #define TAG_NAME(link) \
269 (((link) && TREE_PURPOSE ((link)) \
270 && IDENTIFIER_POINTER (TREE_PURPOSE ((link)))) \
271 ? IDENTIFIER_POINTER (TREE_PURPOSE ((link))) : (char *) 0)
272
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
277
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. */
283
284 #ifdef MIPS_DEBUGGING_INFO
285
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. */
290
291 /* This is a stack of input files. */
292
293 struct sdb_file
294 {
295 struct sdb_file *next;
296 const char *name;
297 };
298
299 /* This is the top of the stack. */
300
301 static struct sdb_file *current_file;
302
303 #endif /* MIPS_DEBUGGING_INFO */
304
305 /* The debug hooks structure. */
306 const struct gcc_debug_hooks sdb_debug_hooks =
307 {
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 */
339 debug_nothing_void, /* switch_text_section */
340 0 /* start_end_main_source_file */
341 };
342
343 /* Return a unique string to name an anonymous type. */
344
345 static char *
gen_fake_label(void)346 gen_fake_label (void)
347 {
348 char label[10];
349 char *labelstr;
350 sprintf (label, ".%dfake", unnamed_struct_number);
351 unnamed_struct_number++;
352 labelstr = xstrdup (label);
353 return labelstr;
354 }
355
356 /* Return the number which describes TYPE for SDB.
357 For pointers, etc., this function is recursive.
358 Each record, union or enumeral type must already have had a
359 tag number output. */
360
361 /* The number is given by d6d5d4d3d2d1bbbb
362 where bbbb is 4 bit basic type, and di indicate one of notype,ptr,fn,array.
363 Thus, char *foo () has bbbb=T_CHAR
364 d1=D_FCN
365 d2=D_PTR
366 N_BTMASK= 017 1111 basic type field.
367 N_TSHIFT= 2 derived type shift
368 N_BTSHFT= 4 Basic type shift */
369
370 /* Produce the number that describes a pointer, function or array type.
371 PREV is the number describing the target, value or element type.
372 DT_type describes how to transform that type. */
373 #define PUSH_DERIVED_LEVEL(DT_type,PREV) \
374 ((((PREV) & ~(int) N_BTMASK) << (int) N_TSHIFT) \
375 | ((int) DT_type << (int) N_BTSHFT) \
376 | ((PREV) & (int) N_BTMASK))
377
378 /* Number of elements used in sdb_dims. */
379 static int sdb_n_dims = 0;
380
381 /* Table of array dimensions of current type. */
382 static int sdb_dims[SDB_MAX_DIM];
383
384 /* Size of outermost array currently being processed. */
385 static int sdb_type_size = -1;
386
387 static int
plain_type(tree type)388 plain_type (tree type)
389 {
390 int val = plain_type_1 (type, 0);
391
392 /* If we have already saved up some array dimensions, print them now. */
393 if (sdb_n_dims > 0)
394 {
395 int i;
396 PUT_SDB_START_DIM;
397 for (i = sdb_n_dims - 1; i > 0; i--)
398 PUT_SDB_NEXT_DIM (sdb_dims[i]);
399 PUT_SDB_LAST_DIM (sdb_dims[0]);
400 sdb_n_dims = 0;
401
402 sdb_type_size = int_size_in_bytes (type);
403 /* Don't kill sdb if type is not laid out or has variable size. */
404 if (sdb_type_size < 0)
405 sdb_type_size = 0;
406 }
407 /* If we have computed the size of an array containing this type,
408 print it now. */
409 if (sdb_type_size >= 0)
410 {
411 PUT_SDB_SIZE (sdb_type_size);
412 sdb_type_size = -1;
413 }
414 return val;
415 }
416
417 static int
template_name_p(tree name)418 template_name_p (tree name)
419 {
420 const char *ptr = IDENTIFIER_POINTER (name);
421 while (*ptr && *ptr != '<')
422 ptr++;
423
424 return *ptr != '\0';
425 }
426
427 static void
sdbout_record_type_name(tree type)428 sdbout_record_type_name (tree type)
429 {
430 const char *name = 0;
431 int no_name;
432
433 if (KNOWN_TYPE_TAG (type))
434 return;
435
436 if (TYPE_NAME (type) != 0)
437 {
438 tree t = 0;
439
440 /* Find the IDENTIFIER_NODE for the type name. */
441 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
442 t = TYPE_NAME (type);
443 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
444 {
445 t = DECL_NAME (TYPE_NAME (type));
446 /* The DECL_NAME for templates includes "<>", which breaks
447 most assemblers. Use its assembler name instead, which
448 has been mangled into being safe. */
449 if (t && template_name_p (t))
450 t = DECL_ASSEMBLER_NAME (TYPE_NAME (type));
451 }
452
453 /* Now get the name as a string, or invent one. */
454 if (t != NULL_TREE)
455 name = IDENTIFIER_POINTER (t);
456 }
457
458 no_name = (name == 0 || *name == 0);
459 if (no_name)
460 name = gen_fake_label ();
461
462 SET_KNOWN_TYPE_TAG (type, name);
463 #ifdef SDB_ALLOW_FORWARD_REFERENCES
464 if (no_name)
465 sdbout_queue_anonymous_type (type);
466 #endif
467 }
468
469 /* Return the .type value for type TYPE.
470
471 LEVEL indicates how many levels deep we have recursed into the type.
472 The SDB debug format can only represent 6 derived levels of types.
473 After that, we must output inaccurate debug info. We deliberately
474 stop before the 7th level, so that ADA recursive types will not give an
475 infinite loop. */
476
477 static int
plain_type_1(tree type,int level)478 plain_type_1 (tree type, int level)
479 {
480 if (type == 0)
481 type = void_type_node;
482 else if (type == error_mark_node)
483 type = integer_type_node;
484 else
485 type = TYPE_MAIN_VARIANT (type);
486
487 switch (TREE_CODE (type))
488 {
489 case VOID_TYPE:
490 return T_VOID;
491 case BOOLEAN_TYPE:
492 case INTEGER_TYPE:
493 {
494 int size = int_size_in_bytes (type) * BITS_PER_UNIT;
495
496 /* Carefully distinguish all the standard types of C,
497 without messing up if the language is not C.
498 Note that we check only for the names that contain spaces;
499 other names might occur by coincidence in other languages. */
500 if (TYPE_NAME (type) != 0
501 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
502 && DECL_NAME (TYPE_NAME (type)) != 0
503 && TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE)
504 {
505 const char *const name
506 = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
507
508 if (!strcmp (name, "char"))
509 return T_CHAR;
510 if (!strcmp (name, "unsigned char"))
511 return T_UCHAR;
512 if (!strcmp (name, "signed char"))
513 return T_CHAR;
514 if (!strcmp (name, "int"))
515 return T_INT;
516 if (!strcmp (name, "unsigned int"))
517 return T_UINT;
518 if (!strcmp (name, "short int"))
519 return T_SHORT;
520 if (!strcmp (name, "short unsigned int"))
521 return T_USHORT;
522 if (!strcmp (name, "long int"))
523 return T_LONG;
524 if (!strcmp (name, "long unsigned int"))
525 return T_ULONG;
526 }
527
528 if (size == INT_TYPE_SIZE)
529 return (TYPE_UNSIGNED (type) ? T_UINT : T_INT);
530 if (size == CHAR_TYPE_SIZE)
531 return (TYPE_UNSIGNED (type) ? T_UCHAR : T_CHAR);
532 if (size == SHORT_TYPE_SIZE)
533 return (TYPE_UNSIGNED (type) ? T_USHORT : T_SHORT);
534 if (size == LONG_TYPE_SIZE)
535 return (TYPE_UNSIGNED (type) ? T_ULONG : T_LONG);
536 if (size == LONG_LONG_TYPE_SIZE) /* better than nothing */
537 return (TYPE_UNSIGNED (type) ? T_ULONG : T_LONG);
538 return 0;
539 }
540
541 case REAL_TYPE:
542 {
543 int precision = TYPE_PRECISION (type);
544 if (precision == FLOAT_TYPE_SIZE)
545 return T_FLOAT;
546 if (precision == DOUBLE_TYPE_SIZE)
547 return T_DOUBLE;
548 #ifdef EXTENDED_SDB_BASIC_TYPES
549 if (precision == LONG_DOUBLE_TYPE_SIZE)
550 return T_LNGDBL;
551 #else
552 if (precision == LONG_DOUBLE_TYPE_SIZE)
553 return T_DOUBLE; /* better than nothing */
554 #endif
555 return 0;
556 }
557
558 case ARRAY_TYPE:
559 {
560 int m;
561 if (level >= 6)
562 return T_VOID;
563 else
564 m = plain_type_1 (TREE_TYPE (type), level+1);
565 if (sdb_n_dims < SDB_MAX_DIM)
566 sdb_dims[sdb_n_dims++]
567 = (TYPE_DOMAIN (type)
568 && TYPE_MIN_VALUE (TYPE_DOMAIN (type)) != 0
569 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != 0
570 && host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0)
571 && host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0)
572 ? (tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0)
573 - tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0) + 1)
574 : 0);
575
576 return PUSH_DERIVED_LEVEL (DT_ARY, m);
577 }
578
579 case RECORD_TYPE:
580 case UNION_TYPE:
581 case QUAL_UNION_TYPE:
582 case ENUMERAL_TYPE:
583 {
584 char *tag;
585 #ifdef SDB_ALLOW_FORWARD_REFERENCES
586 sdbout_record_type_name (type);
587 #endif
588 #ifndef SDB_ALLOW_UNKNOWN_REFERENCES
589 if ((TREE_ASM_WRITTEN (type) && KNOWN_TYPE_TAG (type) != 0)
590 #ifdef SDB_ALLOW_FORWARD_REFERENCES
591 || TYPE_MODE (type) != VOIDmode
592 #endif
593 )
594 #endif
595 {
596 /* Output the referenced structure tag name
597 only if the .def has already been finished.
598 At least on 386, the Unix assembler
599 cannot handle forward references to tags. */
600 /* But the 88100, it requires them, sigh... */
601 /* And the MIPS requires unknown refs as well... */
602 tag = KNOWN_TYPE_TAG (type);
603 PUT_SDB_TAG (tag);
604 /* These 3 lines used to follow the close brace.
605 However, a size of 0 without a tag implies a tag of 0,
606 so if we don't know a tag, we can't mention the size. */
607 sdb_type_size = int_size_in_bytes (type);
608 if (sdb_type_size < 0)
609 sdb_type_size = 0;
610 }
611 return ((TREE_CODE (type) == RECORD_TYPE) ? T_STRUCT
612 : (TREE_CODE (type) == UNION_TYPE) ? T_UNION
613 : (TREE_CODE (type) == QUAL_UNION_TYPE) ? T_UNION
614 : T_ENUM);
615 }
616 case POINTER_TYPE:
617 case REFERENCE_TYPE:
618 {
619 int m;
620 if (level >= 6)
621 return T_VOID;
622 else
623 m = plain_type_1 (TREE_TYPE (type), level+1);
624 return PUSH_DERIVED_LEVEL (DT_PTR, m);
625 }
626 case FUNCTION_TYPE:
627 case METHOD_TYPE:
628 {
629 int m;
630 if (level >= 6)
631 return T_VOID;
632 else
633 m = plain_type_1 (TREE_TYPE (type), level+1);
634 return PUSH_DERIVED_LEVEL (DT_FCN, m);
635 }
636 default:
637 return 0;
638 }
639 }
640
641 /* Output the symbols defined in block number DO_BLOCK.
642
643 This function works by walking the tree structure of blocks,
644 counting blocks until it finds the desired block. */
645
646 static int do_block = 0;
647
648 static void
sdbout_block(tree block)649 sdbout_block (tree block)
650 {
651 while (block)
652 {
653 /* Ignore blocks never expanded or otherwise marked as real. */
654 if (TREE_USED (block))
655 {
656 /* When we reach the specified block, output its symbols. */
657 if (BLOCK_NUMBER (block) == do_block)
658 sdbout_syms (BLOCK_VARS (block));
659
660 /* If we are past the specified block, stop the scan. */
661 if (BLOCK_NUMBER (block) > do_block)
662 return;
663
664 /* Scan the blocks within this block. */
665 sdbout_block (BLOCK_SUBBLOCKS (block));
666 }
667
668 block = BLOCK_CHAIN (block);
669 }
670 }
671
672 /* Call sdbout_symbol on each decl in the chain SYMS. */
673
674 static void
sdbout_syms(tree syms)675 sdbout_syms (tree syms)
676 {
677 while (syms)
678 {
679 if (TREE_CODE (syms) != LABEL_DECL)
680 sdbout_symbol (syms, 1);
681 syms = TREE_CHAIN (syms);
682 }
683 }
684
685 /* Output SDB information for a symbol described by DECL.
686 LOCAL is nonzero if the symbol is not file-scope. */
687
688 void
sdbout_symbol(tree decl,int local)689 sdbout_symbol (tree decl, int local)
690 {
691 tree type = TREE_TYPE (decl);
692 tree context = NULL_TREE;
693 rtx value;
694 int regno = -1;
695 const char *name;
696
697 /* If we are called before sdbout_init is run, just save the symbol
698 for later. */
699 if (!sdbout_initialized)
700 {
701 preinit_symbols = tree_cons (0, decl, preinit_symbols);
702 return;
703 }
704
705 sdbout_one_type (type);
706
707 switch (TREE_CODE (decl))
708 {
709 case CONST_DECL:
710 /* Enum values are defined by defining the enum type. */
711 return;
712
713 case FUNCTION_DECL:
714 /* Don't mention a nested function under its parent. */
715 context = decl_function_context (decl);
716 if (context == current_function_decl)
717 return;
718 /* Check DECL_INITIAL to distinguish declarations from definitions.
719 Don't output debug info here for declarations; they will have
720 a DECL_INITIAL value of 0. */
721 if (! DECL_INITIAL (decl))
722 return;
723 if (!MEM_P (DECL_RTL (decl))
724 || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
725 return;
726 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
727 PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
728 PUT_SDB_SCL (TREE_PUBLIC (decl) ? C_EXT : C_STAT);
729 break;
730
731 case TYPE_DECL:
732 /* Done with tagged types. */
733 if (DECL_NAME (decl) == 0)
734 return;
735 if (DECL_IGNORED_P (decl))
736 return;
737 /* Don't output intrinsic types. GAS chokes on SDB .def
738 statements that contain identifiers with embedded spaces
739 (eg "unsigned long"). */
740 if (DECL_IS_BUILTIN (decl))
741 return;
742
743 /* Output typedef name. */
744 if (template_name_p (DECL_NAME (decl)))
745 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
746 else
747 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_NAME (decl)));
748 PUT_SDB_SCL (C_TPDEF);
749 break;
750
751 case PARM_DECL:
752 /* Parm decls go in their own separate chains
753 and are output by sdbout_reg_parms and sdbout_parms. */
754 gcc_unreachable ();
755
756 case VAR_DECL:
757 /* Don't mention a variable that is external.
758 Let the file that defines it describe it. */
759 if (DECL_EXTERNAL (decl))
760 return;
761
762 /* Ignore __FUNCTION__, etc. */
763 if (DECL_IGNORED_P (decl))
764 return;
765
766 /* If there was an error in the declaration, don't dump core
767 if there is no RTL associated with the variable doesn't
768 exist. */
769 if (!DECL_RTL_SET_P (decl))
770 return;
771
772 SET_DECL_RTL (decl,
773 eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
774 #ifdef LEAF_REG_REMAP
775 if (current_function_uses_only_leaf_regs)
776 leaf_renumber_regs_insn (DECL_RTL (decl));
777 #endif
778 value = DECL_RTL (decl);
779
780 /* Don't mention a variable at all
781 if it was completely optimized into nothingness.
782
783 If DECL was from an inline function, then its rtl
784 is not identically the rtl that was used in this
785 particular compilation. */
786 if (REG_P (value))
787 {
788 regno = REGNO (value);
789 if (regno >= FIRST_PSEUDO_REGISTER)
790 return;
791 }
792 else if (GET_CODE (value) == SUBREG)
793 {
794 while (GET_CODE (value) == SUBREG)
795 value = SUBREG_REG (value);
796 if (REG_P (value))
797 {
798 if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
799 return;
800 }
801 regno = REGNO (alter_subreg (&value));
802 SET_DECL_RTL (decl, value);
803 }
804 /* Don't output anything if an auto variable
805 gets RTL that is static.
806 GAS version 2.2 can't handle such output. */
807 else if (MEM_P (value) && CONSTANT_P (XEXP (value, 0))
808 && ! TREE_STATIC (decl))
809 return;
810
811 /* Emit any structure, union, or enum type that has not been output.
812 This occurs for tag-less structs (et al) used to declare variables
813 within functions. */
814 if (TREE_CODE (type) == ENUMERAL_TYPE
815 || TREE_CODE (type) == RECORD_TYPE
816 || TREE_CODE (type) == UNION_TYPE
817 || TREE_CODE (type) == QUAL_UNION_TYPE)
818 {
819 if (COMPLETE_TYPE_P (type) /* not a forward reference */
820 && KNOWN_TYPE_TAG (type) == 0) /* not yet declared */
821 sdbout_one_type (type);
822 }
823
824 /* Defer SDB information for top-level initialized variables! */
825 if (! local
826 && MEM_P (value)
827 && DECL_INITIAL (decl))
828 return;
829
830 /* C++ in 2.3 makes nameless symbols. That will be fixed later.
831 For now, avoid crashing. */
832 if (DECL_NAME (decl) == NULL_TREE)
833 return;
834
835 /* Record the name for, starting a symtab entry. */
836 if (local)
837 name = IDENTIFIER_POINTER (DECL_NAME (decl));
838 else
839 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
840
841 if (MEM_P (value)
842 && GET_CODE (XEXP (value, 0)) == SYMBOL_REF)
843 {
844 PUT_SDB_DEF (name);
845 if (TREE_PUBLIC (decl))
846 {
847 PUT_SDB_VAL (XEXP (value, 0));
848 PUT_SDB_SCL (C_EXT);
849 }
850 else
851 {
852 PUT_SDB_VAL (XEXP (value, 0));
853 PUT_SDB_SCL (C_STAT);
854 }
855 }
856 else if (regno >= 0)
857 {
858 PUT_SDB_DEF (name);
859 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (regno));
860 PUT_SDB_SCL (C_REG);
861 }
862 else if (MEM_P (value)
863 && (MEM_P (XEXP (value, 0))
864 || (REG_P (XEXP (value, 0))
865 && REGNO (XEXP (value, 0)) != HARD_FRAME_POINTER_REGNUM
866 && REGNO (XEXP (value, 0)) != STACK_POINTER_REGNUM)))
867 /* If the value is indirect by memory or by a register
868 that isn't the frame pointer
869 then it means the object is variable-sized and address through
870 that register or stack slot. COFF has no way to represent this
871 so all we can do is output the variable as a pointer. */
872 {
873 PUT_SDB_DEF (name);
874 if (REG_P (XEXP (value, 0)))
875 {
876 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (XEXP (value, 0))));
877 PUT_SDB_SCL (C_REG);
878 }
879 else
880 {
881 /* DECL_RTL looks like (MEM (MEM (PLUS (REG...)
882 (CONST_INT...)))).
883 We want the value of that CONST_INT. */
884 /* Encore compiler hates a newline in a macro arg, it seems. */
885 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
886 (XEXP (XEXP (value, 0), 0)));
887 PUT_SDB_SCL (C_AUTO);
888 }
889
890 /* Effectively do build_pointer_type, but don't cache this type,
891 since it might be temporary whereas the type it points to
892 might have been saved for inlining. */
893 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
894 type = make_node (POINTER_TYPE);
895 TREE_TYPE (type) = TREE_TYPE (decl);
896 }
897 else if (MEM_P (value)
898 && ((GET_CODE (XEXP (value, 0)) == PLUS
899 && REG_P (XEXP (XEXP (value, 0), 0))
900 && GET_CODE (XEXP (XEXP (value, 0), 1)) == CONST_INT)
901 /* This is for variables which are at offset zero from
902 the frame pointer. This happens on the Alpha.
903 Non-frame pointer registers are excluded above. */
904 || (REG_P (XEXP (value, 0)))))
905 {
906 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
907 or (MEM (REG...)). We want the value of that CONST_INT
908 or zero. */
909 PUT_SDB_DEF (name);
910 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET (XEXP (value, 0)));
911 PUT_SDB_SCL (C_AUTO);
912 }
913 else
914 {
915 /* It is something we don't know how to represent for SDB. */
916 return;
917 }
918 break;
919
920 default:
921 break;
922 }
923 PUT_SDB_TYPE (plain_type (type));
924 PUT_SDB_ENDEF;
925 }
926
927 /* Output SDB information for a top-level initialized variable
928 that has been delayed. */
929
930 static void
sdbout_toplevel_data(tree decl)931 sdbout_toplevel_data (tree decl)
932 {
933 tree type = TREE_TYPE (decl);
934
935 if (DECL_IGNORED_P (decl))
936 return;
937
938 gcc_assert (TREE_CODE (decl) == VAR_DECL);
939 gcc_assert (MEM_P (DECL_RTL (decl)));
940 gcc_assert (DECL_INITIAL (decl));
941
942 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
943 PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
944 if (TREE_PUBLIC (decl))
945 {
946 PUT_SDB_SCL (C_EXT);
947 }
948 else
949 {
950 PUT_SDB_SCL (C_STAT);
951 }
952 PUT_SDB_TYPE (plain_type (type));
953 PUT_SDB_ENDEF;
954 }
955
956 #ifdef SDB_ALLOW_FORWARD_REFERENCES
957
958 /* Machinery to record and output anonymous types. */
959
960 static void
sdbout_queue_anonymous_type(tree type)961 sdbout_queue_anonymous_type (tree type)
962 {
963 anonymous_types = tree_cons (NULL_TREE, type, anonymous_types);
964 }
965
966 static void
sdbout_dequeue_anonymous_types(void)967 sdbout_dequeue_anonymous_types (void)
968 {
969 tree types, link;
970
971 while (anonymous_types)
972 {
973 types = nreverse (anonymous_types);
974 anonymous_types = NULL_TREE;
975
976 for (link = types; link; link = TREE_CHAIN (link))
977 {
978 tree type = TREE_VALUE (link);
979
980 if (type && ! TREE_ASM_WRITTEN (type))
981 sdbout_one_type (type);
982 }
983 }
984 }
985
986 #endif
987
988 /* Given a chain of ..._TYPE nodes, all of which have names,
989 output definitions of those names, as typedefs. */
990
991 void
sdbout_types(tree types)992 sdbout_types (tree types)
993 {
994 tree link;
995
996 for (link = types; link; link = TREE_CHAIN (link))
997 sdbout_one_type (link);
998
999 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1000 sdbout_dequeue_anonymous_types ();
1001 #endif
1002 }
1003
1004 static void
sdbout_type(tree type)1005 sdbout_type (tree type)
1006 {
1007 if (type == error_mark_node)
1008 type = integer_type_node;
1009 PUT_SDB_TYPE (plain_type (type));
1010 }
1011
1012 /* Output types of the fields of type TYPE, if they are structs.
1013
1014 Formerly did not chase through pointer types, since that could be circular.
1015 They must come before TYPE, since forward refs are not allowed.
1016 Now james@bigtex.cactus.org says to try them. */
1017
1018 static void
sdbout_field_types(tree type)1019 sdbout_field_types (tree type)
1020 {
1021 tree tail;
1022
1023 for (tail = TYPE_FIELDS (type); tail; tail = TREE_CHAIN (tail))
1024 /* This condition should match the one for emitting the actual
1025 members below. */
1026 if (TREE_CODE (tail) == FIELD_DECL
1027 && DECL_NAME (tail)
1028 && DECL_SIZE (tail)
1029 && host_integerp (DECL_SIZE (tail), 1)
1030 && host_integerp (bit_position (tail), 0))
1031 {
1032 if (POINTER_TYPE_P (TREE_TYPE (tail)))
1033 sdbout_one_type (TREE_TYPE (TREE_TYPE (tail)));
1034 else
1035 sdbout_one_type (TREE_TYPE (tail));
1036 }
1037 }
1038
1039 /* Use this to put out the top level defined record and union types
1040 for later reference. If this is a struct with a name, then put that
1041 name out. Other unnamed structs will have .xxfake labels generated so
1042 that they may be referred to later.
1043 The label will be stored in the KNOWN_TYPE_TAG slot of a type.
1044 It may NOT be called recursively. */
1045
1046 static void
sdbout_one_type(tree type)1047 sdbout_one_type (tree type)
1048 {
1049 if (current_function_decl != NULL_TREE
1050 && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
1051 ; /* Don't change section amid function. */
1052 else
1053 text_section ();
1054
1055 switch (TREE_CODE (type))
1056 {
1057 case RECORD_TYPE:
1058 case UNION_TYPE:
1059 case QUAL_UNION_TYPE:
1060 case ENUMERAL_TYPE:
1061 type = TYPE_MAIN_VARIANT (type);
1062 /* Don't output a type twice. */
1063 if (TREE_ASM_WRITTEN (type))
1064 /* James said test TREE_ASM_BEING_WRITTEN here. */
1065 return;
1066
1067 /* Output nothing if type is not yet defined. */
1068 if (!COMPLETE_TYPE_P (type))
1069 return;
1070
1071 TREE_ASM_WRITTEN (type) = 1;
1072
1073 /* This is reputed to cause trouble with the following case,
1074 but perhaps checking TYPE_SIZE above will fix it. */
1075
1076 /* Here is a testcase:
1077
1078 struct foo {
1079 struct badstr *bbb;
1080 } forwardref;
1081
1082 typedef struct intermediate {
1083 int aaaa;
1084 } intermediate_ref;
1085
1086 typedef struct badstr {
1087 int ccccc;
1088 } badtype; */
1089
1090 /* This change, which ought to make better output,
1091 used to make the COFF assembler unhappy.
1092 Changes involving KNOWN_TYPE_TAG may fix the problem. */
1093 /* Before really doing anything, output types we want to refer to. */
1094 /* Note that in version 1 the following two lines
1095 are not used if forward references are in use. */
1096 if (TREE_CODE (type) != ENUMERAL_TYPE)
1097 sdbout_field_types (type);
1098
1099 /* Output a structure type. */
1100 {
1101 int size = int_size_in_bytes (type);
1102 int member_scl = 0;
1103 tree tem;
1104
1105 /* Record the type tag, but not in its permanent place just yet. */
1106 sdbout_record_type_name (type);
1107
1108 PUT_SDB_DEF (KNOWN_TYPE_TAG (type));
1109
1110 switch (TREE_CODE (type))
1111 {
1112 case UNION_TYPE:
1113 case QUAL_UNION_TYPE:
1114 PUT_SDB_SCL (C_UNTAG);
1115 PUT_SDB_TYPE (T_UNION);
1116 member_scl = C_MOU;
1117 break;
1118
1119 case RECORD_TYPE:
1120 PUT_SDB_SCL (C_STRTAG);
1121 PUT_SDB_TYPE (T_STRUCT);
1122 member_scl = C_MOS;
1123 break;
1124
1125 case ENUMERAL_TYPE:
1126 PUT_SDB_SCL (C_ENTAG);
1127 PUT_SDB_TYPE (T_ENUM);
1128 member_scl = C_MOE;
1129 break;
1130
1131 default:
1132 break;
1133 }
1134
1135 PUT_SDB_SIZE (size);
1136 PUT_SDB_ENDEF;
1137
1138 /* Print out the base class information with fields
1139 named after the types they hold. */
1140 /* This is only relevant to aggregate types. TYPE_BINFO is used
1141 for other purposes in an ENUMERAL_TYPE, so we must exclude that
1142 case. */
1143 if (TREE_CODE (type) != ENUMERAL_TYPE && TYPE_BINFO (type))
1144 {
1145 int i;
1146 tree binfo, child;
1147
1148 for (binfo = TYPE_BINFO (type), i = 0;
1149 BINFO_BASE_ITERATE (binfo, i, child); i++)
1150 {
1151 tree child_type = BINFO_TYPE (child);
1152 tree child_type_name;
1153
1154 if (TYPE_NAME (child_type) == 0)
1155 continue;
1156 if (TREE_CODE (TYPE_NAME (child_type)) == IDENTIFIER_NODE)
1157 child_type_name = TYPE_NAME (child_type);
1158 else if (TREE_CODE (TYPE_NAME (child_type)) == TYPE_DECL)
1159 {
1160 child_type_name = DECL_NAME (TYPE_NAME (child_type));
1161 if (child_type_name && template_name_p (child_type_name))
1162 child_type_name
1163 = DECL_ASSEMBLER_NAME (TYPE_NAME (child_type));
1164 }
1165 else
1166 continue;
1167
1168 PUT_SDB_DEF (IDENTIFIER_POINTER (child_type_name));
1169 PUT_SDB_INT_VAL (tree_low_cst (BINFO_OFFSET (child), 0));
1170 PUT_SDB_SCL (member_scl);
1171 sdbout_type (BINFO_TYPE (child));
1172 PUT_SDB_ENDEF;
1173 }
1174 }
1175
1176 /* Output the individual fields. */
1177
1178 if (TREE_CODE (type) == ENUMERAL_TYPE)
1179 {
1180 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
1181 if (host_integerp (TREE_VALUE (tem), 0))
1182 {
1183 PUT_SDB_DEF (IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1184 PUT_SDB_INT_VAL (tree_low_cst (TREE_VALUE (tem), 0));
1185 PUT_SDB_SCL (C_MOE);
1186 PUT_SDB_TYPE (T_MOE);
1187 PUT_SDB_ENDEF;
1188 }
1189 }
1190 else /* record or union type */
1191 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1192 /* Output the name, type, position (in bits), size (in bits)
1193 of each field. */
1194
1195 /* Omit here the nameless fields that are used to skip bits.
1196 Also omit fields with variable size or position.
1197 Also omit non FIELD_DECL nodes that GNU C++ may put here. */
1198 if (TREE_CODE (tem) == FIELD_DECL
1199 && DECL_NAME (tem)
1200 && DECL_SIZE (tem)
1201 && host_integerp (DECL_SIZE (tem), 1)
1202 && host_integerp (bit_position (tem), 0))
1203 {
1204 const char *name;
1205
1206 name = IDENTIFIER_POINTER (DECL_NAME (tem));
1207 PUT_SDB_DEF (name);
1208 if (DECL_BIT_FIELD_TYPE (tem))
1209 {
1210 PUT_SDB_INT_VAL (int_bit_position (tem));
1211 PUT_SDB_SCL (C_FIELD);
1212 sdbout_type (DECL_BIT_FIELD_TYPE (tem));
1213 PUT_SDB_SIZE (tree_low_cst (DECL_SIZE (tem), 1));
1214 }
1215 else
1216 {
1217 PUT_SDB_INT_VAL (int_bit_position (tem) / BITS_PER_UNIT);
1218 PUT_SDB_SCL (member_scl);
1219 sdbout_type (TREE_TYPE (tem));
1220 }
1221 PUT_SDB_ENDEF;
1222 }
1223 /* Output end of a structure,union, or enumeral definition. */
1224
1225 PUT_SDB_PLAIN_DEF ("eos");
1226 PUT_SDB_INT_VAL (size);
1227 PUT_SDB_SCL (C_EOS);
1228 PUT_SDB_TAG (KNOWN_TYPE_TAG (type));
1229 PUT_SDB_SIZE (size);
1230 PUT_SDB_ENDEF;
1231 break;
1232
1233 default:
1234 break;
1235 }
1236 }
1237 }
1238
1239 /* The following two functions output definitions of function parameters.
1240 Each parameter gets a definition locating it in the parameter list.
1241 Each parameter that is a register variable gets a second definition
1242 locating it in the register.
1243
1244 Printing or argument lists in gdb uses the definitions that
1245 locate in the parameter list. But reference to the variable in
1246 expressions uses preferentially the definition as a register. */
1247
1248 /* Output definitions, referring to storage in the parmlist,
1249 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
1250
1251 static void
sdbout_parms(tree parms)1252 sdbout_parms (tree parms)
1253 {
1254 for (; parms; parms = TREE_CHAIN (parms))
1255 if (DECL_NAME (parms))
1256 {
1257 int current_sym_value = 0;
1258 const char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
1259
1260 if (name == 0 || *name == 0)
1261 name = gen_fake_label ();
1262
1263 /* Perform any necessary register eliminations on the parameter's rtl,
1264 so that the debugging output will be accurate. */
1265 DECL_INCOMING_RTL (parms)
1266 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
1267 SET_DECL_RTL (parms,
1268 eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
1269
1270 if (PARM_PASSED_IN_MEMORY (parms))
1271 {
1272 rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
1273 tree type;
1274
1275 /* ??? Here we assume that the parm address is indexed
1276 off the frame pointer or arg pointer.
1277 If that is not true, we produce meaningless results,
1278 but do not crash. */
1279 if (GET_CODE (addr) == PLUS
1280 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
1281 current_sym_value = INTVAL (XEXP (addr, 1));
1282 else
1283 current_sym_value = 0;
1284
1285 if (REG_P (DECL_RTL (parms))
1286 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1287 type = DECL_ARG_TYPE (parms);
1288 else
1289 {
1290 int original_sym_value = current_sym_value;
1291
1292 /* This is the case where the parm is passed as an int or
1293 double and it is converted to a char, short or float
1294 and stored back in the parmlist. In this case, describe
1295 the parm with the variable's declared type, and adjust
1296 the address if the least significant bytes (which we are
1297 using) are not the first ones. */
1298 if (BYTES_BIG_ENDIAN
1299 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1300 current_sym_value +=
1301 (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1302 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1303
1304 if (MEM_P (DECL_RTL (parms))
1305 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1306 && (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1))
1307 == CONST_INT)
1308 && (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1))
1309 == current_sym_value))
1310 type = TREE_TYPE (parms);
1311 else
1312 {
1313 current_sym_value = original_sym_value;
1314 type = DECL_ARG_TYPE (parms);
1315 }
1316 }
1317
1318 PUT_SDB_DEF (name);
1319 PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value, addr));
1320 PUT_SDB_SCL (C_ARG);
1321 PUT_SDB_TYPE (plain_type (type));
1322 PUT_SDB_ENDEF;
1323 }
1324 else if (REG_P (DECL_RTL (parms)))
1325 {
1326 rtx best_rtl;
1327 /* Parm passed in registers and lives in registers or nowhere. */
1328
1329 /* If parm lives in a register, use that register;
1330 pretend the parm was passed there. It would be more consistent
1331 to describe the register where the parm was passed,
1332 but in practice that register usually holds something else. */
1333 if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1334 best_rtl = DECL_RTL (parms);
1335 /* If the parm lives nowhere,
1336 use the register where it was passed. */
1337 else
1338 best_rtl = DECL_INCOMING_RTL (parms);
1339
1340 PUT_SDB_DEF (name);
1341 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (best_rtl)));
1342 PUT_SDB_SCL (C_REGPARM);
1343 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1344 PUT_SDB_ENDEF;
1345 }
1346 else if (MEM_P (DECL_RTL (parms))
1347 && XEXP (DECL_RTL (parms), 0) != const0_rtx)
1348 {
1349 /* Parm was passed in registers but lives on the stack. */
1350
1351 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
1352 in which case we want the value of that CONST_INT,
1353 or (MEM (REG ...)) or (MEM (MEM ...)),
1354 in which case we use a value of zero. */
1355 if (REG_P (XEXP (DECL_RTL (parms), 0))
1356 || MEM_P (XEXP (DECL_RTL (parms), 0)))
1357 current_sym_value = 0;
1358 else
1359 current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
1360
1361 /* Again, this assumes the offset is based on the arg pointer. */
1362 PUT_SDB_DEF (name);
1363 PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value,
1364 XEXP (DECL_RTL (parms), 0)));
1365 PUT_SDB_SCL (C_ARG);
1366 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1367 PUT_SDB_ENDEF;
1368 }
1369 }
1370 }
1371
1372 /* Output definitions for the places where parms live during the function,
1373 when different from where they were passed, when the parms were passed
1374 in memory.
1375
1376 It is not useful to do this for parms passed in registers
1377 that live during the function in different registers, because it is
1378 impossible to look in the passed register for the passed value,
1379 so we use the within-the-function register to begin with.
1380
1381 PARMS is a chain of PARM_DECL nodes. */
1382
1383 static void
sdbout_reg_parms(tree parms)1384 sdbout_reg_parms (tree parms)
1385 {
1386 for (; parms; parms = TREE_CHAIN (parms))
1387 if (DECL_NAME (parms))
1388 {
1389 const char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
1390
1391 /* Report parms that live in registers during the function
1392 but were passed in memory. */
1393 if (REG_P (DECL_RTL (parms))
1394 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER
1395 && PARM_PASSED_IN_MEMORY (parms))
1396 {
1397 if (name == 0 || *name == 0)
1398 name = gen_fake_label ();
1399 PUT_SDB_DEF (name);
1400 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms))));
1401 PUT_SDB_SCL (C_REG);
1402 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1403 PUT_SDB_ENDEF;
1404 }
1405 /* Report parms that live in memory but not where they were passed. */
1406 else if (MEM_P (DECL_RTL (parms))
1407 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1408 && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
1409 && PARM_PASSED_IN_MEMORY (parms)
1410 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
1411 {
1412 #if 0 /* ??? It is not clear yet what should replace this. */
1413 int offset = DECL_OFFSET (parms) / BITS_PER_UNIT;
1414 /* A parm declared char is really passed as an int,
1415 so it occupies the least significant bytes.
1416 On a big-endian machine those are not the low-numbered ones. */
1417 if (BYTES_BIG_ENDIAN
1418 && offset != -1
1419 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1420 offset += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1421 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1422 if (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) != offset) {...}
1423 #endif
1424 {
1425 if (name == 0 || *name == 0)
1426 name = gen_fake_label ();
1427 PUT_SDB_DEF (name);
1428 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
1429 (XEXP (DECL_RTL (parms), 0)));
1430 PUT_SDB_SCL (C_AUTO);
1431 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1432 PUT_SDB_ENDEF;
1433 }
1434 }
1435 }
1436 }
1437
1438 /* Output debug information for a global DECL. Called from toplev.c
1439 after compilation proper has finished. */
1440
1441 static void
sdbout_global_decl(tree decl)1442 sdbout_global_decl (tree decl)
1443 {
1444 if (TREE_CODE (decl) == VAR_DECL
1445 && !DECL_EXTERNAL (decl)
1446 && DECL_RTL_SET_P (decl))
1447 {
1448 /* The COFF linker can move initialized global vars to the end.
1449 And that can screw up the symbol ordering. Defer those for
1450 sdbout_finish (). */
1451 if (!DECL_INITIAL (decl) || !TREE_PUBLIC (decl))
1452 sdbout_symbol (decl, 0);
1453 else
1454 VARRAY_PUSH_TREE (deferred_global_decls, decl);
1455
1456 /* Output COFF information for non-global file-scope initialized
1457 variables. */
1458 if (DECL_INITIAL (decl) && MEM_P (DECL_RTL (decl)))
1459 sdbout_toplevel_data (decl);
1460 }
1461 }
1462
1463 /* Output initialized global vars at the end, in the order of
1464 definition. See comment in sdbout_global_decl. */
1465
1466 static void
sdbout_finish(const char * main_filename ATTRIBUTE_UNUSED)1467 sdbout_finish (const char *main_filename ATTRIBUTE_UNUSED)
1468 {
1469 size_t i;
1470
1471 for (i = 0; i < VARRAY_ACTIVE_SIZE (deferred_global_decls); i++)
1472 sdbout_symbol (VARRAY_TREE (deferred_global_decls, i), 0);
1473 }
1474
1475 /* Describe the beginning of an internal block within a function.
1476 Also output descriptions of variables defined in this block.
1477
1478 N is the number of the block, by order of beginning, counting from 1,
1479 and not counting the outermost (function top-level) block.
1480 The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
1481 if the count starts at 0 for the outermost one. */
1482
1483 static void
sdbout_begin_block(unsigned int line,unsigned int n)1484 sdbout_begin_block (unsigned int line, unsigned int n)
1485 {
1486 tree decl = current_function_decl;
1487 MAKE_LINE_SAFE (line);
1488
1489 /* The SCO compiler does not emit a separate block for the function level
1490 scope, so we avoid it here also. However, mips ECOFF compilers do emit
1491 a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined. */
1492 #ifndef MIPS_DEBUGGING_INFO
1493 if (n != 1)
1494 #endif
1495 PUT_SDB_BLOCK_START (line - sdb_begin_function_line);
1496
1497 if (n == 1)
1498 {
1499 /* Include the outermost BLOCK's variables in block 1. */
1500 do_block = BLOCK_NUMBER (DECL_INITIAL (decl));
1501 sdbout_block (DECL_INITIAL (decl));
1502 }
1503 /* If -g1, suppress all the internal symbols of functions
1504 except for arguments. */
1505 if (debug_info_level != DINFO_LEVEL_TERSE)
1506 {
1507 do_block = n;
1508 sdbout_block (DECL_INITIAL (decl));
1509 }
1510
1511 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1512 sdbout_dequeue_anonymous_types ();
1513 #endif
1514 }
1515
1516 /* Describe the end line-number of an internal block within a function. */
1517
1518 static void
sdbout_end_block(unsigned int line,unsigned int n ATTRIBUTE_UNUSED)1519 sdbout_end_block (unsigned int line, unsigned int n ATTRIBUTE_UNUSED)
1520 {
1521 MAKE_LINE_SAFE (line);
1522
1523 /* The SCO compiler does not emit a separate block for the function level
1524 scope, so we avoid it here also. However, mips ECOFF compilers do emit
1525 a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined. */
1526 #ifndef MIPS_DEBUGGING_INFO
1527 if (n != 1)
1528 #endif
1529 PUT_SDB_BLOCK_END (line - sdb_begin_function_line);
1530 }
1531
1532 /* Output a line number symbol entry for source file FILENAME and line
1533 number LINE. */
1534
1535 static void
sdbout_source_line(unsigned int line,const char * filename ATTRIBUTE_UNUSED)1536 sdbout_source_line (unsigned int line, const char *filename ATTRIBUTE_UNUSED)
1537 {
1538 /* COFF relative line numbers must be positive. */
1539 if ((int) line > sdb_begin_function_line)
1540 {
1541 #ifdef SDB_OUTPUT_SOURCE_LINE
1542 SDB_OUTPUT_SOURCE_LINE (asm_out_file, line);
1543 #else
1544 fprintf (asm_out_file, "\t.ln\t%d\n", line);
1545 #endif
1546 }
1547 }
1548
1549 /* Output sdb info for the current function name.
1550 Called from assemble_start_function. */
1551
1552 static void
sdbout_begin_function(tree decl ATTRIBUTE_UNUSED)1553 sdbout_begin_function (tree decl ATTRIBUTE_UNUSED)
1554 {
1555 sdbout_symbol (current_function_decl, 0);
1556 }
1557
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. */
1563
1564 #ifndef MIPS_DEBUGGING_INFO
1565 static void
sdbout_begin_prologue(unsigned int line,const char * file ATTRIBUTE_UNUSED)1566 sdbout_begin_prologue (unsigned int line, const char *file ATTRIBUTE_UNUSED)
1567 {
1568 sdbout_end_prologue (line, file);
1569 }
1570 #endif
1571
1572 static void
sdbout_end_prologue(unsigned int line,const char * file ATTRIBUTE_UNUSED)1573 sdbout_end_prologue (unsigned int line, const char *file ATTRIBUTE_UNUSED)
1574 {
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));
1579 }
1580
1581 /* Called at end of function (before epilogue).
1582 Describe end of outermost block. */
1583
1584 static void
sdbout_end_function(unsigned int line)1585 sdbout_end_function (unsigned int line)
1586 {
1587 #ifdef SDB_ALLOW_FORWARD_REFERENCES
1588 sdbout_dequeue_anonymous_types ();
1589 #endif
1590
1591 MAKE_LINE_SAFE (line);
1592 PUT_SDB_FUNCTION_END (line - sdb_begin_function_line);
1593
1594 /* Indicate we are between functions, for line-number output. */
1595 sdb_begin_function_line = -1;
1596 }
1597
1598 /* Output sdb info for the absolute end of a function.
1599 Called after the epilogue is output. */
1600
1601 static void
sdbout_end_epilogue(unsigned int line ATTRIBUTE_UNUSED,const char * file ATTRIBUTE_UNUSED)1602 sdbout_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
1603 const char *file ATTRIBUTE_UNUSED)
1604 {
1605 const char *const name ATTRIBUTE_UNUSED
1606 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
1607
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
1616 }
1617
1618 /* Output sdb info for the given label. Called only if LABEL_NAME (insn)
1619 is present. */
1620
1621 static void
sdbout_label(rtx insn)1622 sdbout_label (rtx insn)
1623 {
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;
1629 }
1630
1631 /* Change to reading from a new source file. */
1632
1633 static void
sdbout_start_source_file(unsigned int line ATTRIBUTE_UNUSED,const char * filename ATTRIBUTE_UNUSED)1634 sdbout_start_source_file (unsigned int line ATTRIBUTE_UNUSED,
1635 const char *filename ATTRIBUTE_UNUSED)
1636 {
1637 #ifdef MIPS_DEBUGGING_INFO
1638 struct sdb_file *n = xmalloc (sizeof *n);
1639
1640 n->next = current_file;
1641 n->name = filename;
1642 current_file = n;
1643 output_file_directive (asm_out_file, filename);
1644 #endif
1645 }
1646
1647 /* Revert to reading a previous source file. */
1648
1649 static void
sdbout_end_source_file(unsigned int line ATTRIBUTE_UNUSED)1650 sdbout_end_source_file (unsigned int line ATTRIBUTE_UNUSED)
1651 {
1652 #ifdef MIPS_DEBUGGING_INFO
1653 struct sdb_file *next;
1654
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
1660 }
1661
1662 /* Set up for SDB output at the start of compilation. */
1663
1664 static void
sdbout_init(const char * input_file_name ATTRIBUTE_UNUSED)1665 sdbout_init (const char *input_file_name ATTRIBUTE_UNUSED)
1666 {
1667 tree t;
1668
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
1674
1675 VARRAY_TREE_INIT (deferred_global_decls, 12, "deferred_global_decls");
1676
1677 /* Emit debug information which was queued by sdbout_symbol before
1678 we got here. */
1679 sdbout_initialized = true;
1680
1681 for (t = nreverse (preinit_symbols); t; t = TREE_CHAIN (t))
1682 sdbout_symbol (TREE_VALUE (t), 0);
1683 preinit_symbols = 0;
1684 }
1685
1686 #else /* SDB_DEBUGGING_INFO */
1687
1688 /* This should never be used, but its address is needed for comparisons. */
1689 const struct gcc_debug_hooks sdb_debug_hooks;
1690
1691 #endif /* SDB_DEBUGGING_INFO */
1692
1693 #include "gt-sdbout.h"
1694