![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sdbout.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to sdbout.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Output sdb-format symbol table information from GNU compiler.
2: Copyright (C) 1988, 1992 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 2, or (at your option)
9: any later version.
10:
11: GNU CC is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU CC; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20: /* [email protected] says:
21: I modified the struct.c example and have a nm of a .o resulting from the
22: AT&T C compiler. From the example below I would conclude the following:
23:
24: 1. All .defs from structures are emitted as scanned. The example below
25: clearly shows the symbol table entries for BoxRec2 are after the first
26: function.
27:
28: 2. All functions and their locals (including statics) are emitted as scanned.
29:
30: 3. All nested unnamed union and structure .defs must be emitted before
31: the structure in which they are nested. The AT&T assembler is a
32: one pass beast as far as symbolics are concerned.
33:
34: 4. All structure .defs are emitted before the typedefs that refer to them.
35:
36: 5. All top level static and external variable definitions are moved to the
37: end of file with all top level statics occuring first before externs.
38:
39: 6. All undefined references are at the end of the file.
40: */
41:
42: #include "config.h"
43:
44: #ifdef SDB_DEBUGGING_INFO
45:
46: #include "tree.h"
47: #include "rtl.h"
48: #include <stdio.h>
49: #include "regs.h"
50: #include "flags.h"
51: #include "insn-config.h"
52: #include "reload.h"
53:
54: /* Mips systems use the SDB functions to dump out symbols, but
55: do not supply usable syms.h include files. */
56: #if defined(USG) && !defined(MIPS)
57: #include <syms.h>
58: /* Use T_INT if we don't have T_VOID. */
59: #ifndef T_VOID
60: #define T_VOID T_INT
61: #endif
62: #else /* not USG, or MIPS */
63: #include "gsyms.h"
64: #endif /* not USG, or MIPS */
65:
66: /* #include <storclass.h> used to be this instead of syms.h. */
67:
68: /* 1 if PARM is passed to this function in memory. */
69:
70: #define PARM_PASSED_IN_MEMORY(PARM) \
71: (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
72:
73: /* A C expression for the integer offset value of an automatic variable
74: (C_AUTO) having address X (an RTX). */
75: #ifndef DEBUGGER_AUTO_OFFSET
76: #define DEBUGGER_AUTO_OFFSET(X) \
77: (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
78: #endif
79:
80: /* A C expression for the integer offset value of an argument (C_ARG)
81: having address X (an RTX). The nominal offset is OFFSET. */
82: #ifndef DEBUGGER_ARG_OFFSET
83: #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
84: #endif
85:
86: /* Line number of beginning of current function, minus one.
87: Negative means not in a function or not using sdb. */
88:
89: int sdb_begin_function_line = -1;
90:
91: /* Counter to generate unique "names" for nameless struct members. */
92:
93: static int unnamed_struct_number = 0;
94:
95: extern FILE *asm_out_file;
96:
97: extern tree current_function_decl;
98:
99: void sdbout_init ();
100: void sdbout_symbol ();
101: void sdbout_types();
102:
103: static void sdbout_typedefs ();
104: static void sdbout_syms ();
105: static void sdbout_one_type ();
106: static void sdbout_queue_anonymous_type ();
107: static void sdbout_dequeue_anonymous_type ();
108: static int plain_type_1 ();
109:
110: /* Define the default sizes for various types. */
111:
112: #ifndef CHAR_TYPE_SIZE
113: #define CHAR_TYPE_SIZE BITS_PER_UNIT
114: #endif
115:
116: #ifndef SHORT_TYPE_SIZE
117: #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2))
118: #endif
119:
120: #ifndef INT_TYPE_SIZE
121: #define INT_TYPE_SIZE BITS_PER_WORD
122: #endif
123:
124: #ifndef LONG_TYPE_SIZE
125: #define LONG_TYPE_SIZE BITS_PER_WORD
126: #endif
127:
128: #ifndef LONG_LONG_TYPE_SIZE
129: #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
130: #endif
131:
132: #ifndef FLOAT_TYPE_SIZE
133: #define FLOAT_TYPE_SIZE BITS_PER_WORD
134: #endif
135:
136: #ifndef DOUBLE_TYPE_SIZE
137: #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
138: #endif
139:
140: #ifndef LONG_DOUBLE_TYPE_SIZE
141: #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
142: #endif
143:
144: /* Random macros describing parts of SDB data. */
145:
146: /* Put something here if lines get too long */
147: #define CONTIN
148:
149: /* Default value of delimiter is ";". */
150: #ifndef SDB_DELIM
151: #define SDB_DELIM ";"
152: #endif
153:
154: /* Maximum number of dimensions the assembler will allow. */
155: #ifndef SDB_MAX_DIM
156: #define SDB_MAX_DIM 4
157: #endif
158:
159: #ifndef PUT_SDB_SCL
160: #define PUT_SDB_SCL(a) fprintf(asm_out_file, "\t.scl\t%d%s", (a), SDB_DELIM)
161: #endif
162:
163: #ifndef PUT_SDB_INT_VAL
164: #define PUT_SDB_INT_VAL(a) fprintf (asm_out_file, "\t.val\t%d%s", (a), SDB_DELIM)
165: #endif
166:
167: #ifndef PUT_SDB_VAL
168: #define PUT_SDB_VAL(a) \
169: ( fputs ("\t.val\t", asm_out_file), \
170: output_addr_const (asm_out_file, (a)), \
171: fprintf (asm_out_file, SDB_DELIM))
172: #endif
173:
174: #ifndef PUT_SDB_DEF
175: #define PUT_SDB_DEF(a) \
176: do { fprintf (asm_out_file, "\t.def\t"); \
177: ASM_OUTPUT_LABELREF (asm_out_file, a); \
178: fprintf (asm_out_file, SDB_DELIM); } while (0)
179: #endif
180:
181: #ifndef PUT_SDB_PLAIN_DEF
182: #define PUT_SDB_PLAIN_DEF(a) fprintf(asm_out_file,"\t.def\t.%s%s",a, SDB_DELIM)
183: #endif
184:
185: #ifndef PUT_SDB_ENDEF
186: #define PUT_SDB_ENDEF fputs("\t.endef\n", asm_out_file)
187: #endif
188:
189: #ifndef PUT_SDB_TYPE
190: #define PUT_SDB_TYPE(a) fprintf(asm_out_file, "\t.type\t0%o%s", a, SDB_DELIM)
191: #endif
192:
193: #ifndef PUT_SDB_SIZE
194: #define PUT_SDB_SIZE(a) fprintf(asm_out_file, "\t.size\t%d%s", a, SDB_DELIM)
195: #endif
196:
197: #ifndef PUT_SDB_START_DIM
198: #define PUT_SDB_START_DIM fprintf(asm_out_file, "\t.dim\t")
199: #endif
200:
201: #ifndef PUT_SDB_NEXT_DIM
202: #define PUT_SDB_NEXT_DIM(a) fprintf(asm_out_file, "%d,", a)
203: #endif
204:
205: #ifndef PUT_SDB_LAST_DIM
206: #define PUT_SDB_LAST_DIM(a) fprintf(asm_out_file, "%d%s", a, SDB_DELIM)
207: #endif
208:
209: #ifndef PUT_SDB_TAG
210: #define PUT_SDB_TAG(a) \
211: do { fprintf (asm_out_file, "\t.tag\t"); \
212: ASM_OUTPUT_LABELREF (asm_out_file, a); \
213: fprintf (asm_out_file, SDB_DELIM); } while (0)
214: #endif
215:
216: #ifndef PUT_SDB_BLOCK_START
217: #define PUT_SDB_BLOCK_START(LINE) \
218: fprintf (asm_out_file, \
219: "\t.def\t.bb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n", \
220: SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
221: #endif
222:
223: #ifndef PUT_SDB_BLOCK_END
224: #define PUT_SDB_BLOCK_END(LINE) \
225: fprintf (asm_out_file, \
226: "\t.def\t.eb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n", \
227: SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
228: #endif
229:
230: #ifndef PUT_SDB_FUNCTION_START
231: #define PUT_SDB_FUNCTION_START(LINE) \
232: fprintf (asm_out_file, \
233: "\t.def\t.bf%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \
234: SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
235: #endif
236:
237: #ifndef PUT_SDB_FUNCTION_END
238: #define PUT_SDB_FUNCTION_END(LINE) \
239: fprintf (asm_out_file, \
240: "\t.def\t.ef%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \
241: SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
242: #endif
243:
244: #ifndef PUT_SDB_EPILOGUE_END
245: #define PUT_SDB_EPILOGUE_END(NAME) \
246: do { fprintf (asm_out_file, "\t.def\t"); \
247: ASM_OUTPUT_LABELREF (asm_out_file, NAME); \
248: fprintf (asm_out_file, \
249: "%s\t.val\t.%s\t.scl\t-1%s\t.endef\n", \
250: SDB_DELIM, SDB_DELIM, SDB_DELIM); } while (0)
251: #endif
252:
253: #ifndef SDB_GENERATE_FAKE
254: #define SDB_GENERATE_FAKE(BUFFER, NUMBER) \
255: sprintf ((BUFFER), ".%dfake", (NUMBER));
256: #endif
257:
258: /* Return the sdb tag identifier string for TYPE
259: if TYPE has already been defined; otherwise return a null pointer. */
260:
261: #define KNOWN_TYPE_TAG(type) (char *)(TYPE_SYMTAB_ADDRESS (type))
262:
263: /* Set the sdb tag identifier string for TYPE to NAME. */
264:
265: #define SET_KNOWN_TYPE_TAG(TYPE, NAME) \
266: (TYPE_SYMTAB_ADDRESS (TYPE) = (int)(NAME))
267:
268: /* Return the name (a string) of the struct, union or enum tag
269: described by the TREE_LIST node LINK. This is 0 for an anonymous one. */
270:
271: #define TAG_NAME(link) \
272: (((link) && TREE_PURPOSE ((link)) \
273: && IDENTIFIER_POINTER (TREE_PURPOSE ((link)))) \
274: ? IDENTIFIER_POINTER (TREE_PURPOSE ((link))) : (char *) 0)
275:
276: /* Ensure we don't output a negative line number. */
277: #define MAKE_LINE_SAFE(line) \
278: if (line <= sdb_begin_function_line) line = sdb_begin_function_line + 1
279:
280: /* Set up for SDB output at the start of compilation. */
281:
282: void
283: sdbout_init (asm_file, input_file_name, syms)
284: FILE *asm_file;
285: char *input_file_name;
286: tree syms;
287: {
288: #if 0 /* Nothing need be output for the predefined types. */
289: /* Get all permanent types that have typedef names,
290: and output them all, except for those already output. */
291:
292: sdbout_typedefs (syms);
293: #endif
294: }
295:
296: #if 0
297:
298: /* return the tag identifier for type
299: */
300:
301: char *
302: tag_of_ru_type (type,link)
303: tree type,link;
304: {
305: if (TYPE_SYMTAB_ADDRESS (type))
306: return (char *)TYPE_SYMTAB_ADDRESS (type);
307: if (link && TREE_PURPOSE (link)
308: && IDENTIFIER_POINTER (TREE_PURPOSE (link)))
309: TYPE_SYMTAB_ADDRESS (type)
310: = (int)IDENTIFIER_POINTER (TREE_PURPOSE (link));
311: else
312: return (char *) TYPE_SYMTAB_ADDRESS (type);
313: }
314: #endif
315:
316: /* Return a unique string to name an anonymous type. */
317:
318: static char *
319: gen_fake_label ()
320: {
321: char label[10];
322: char *labelstr;
323: SDB_GENERATE_FAKE (label, unnamed_struct_number);
324: unnamed_struct_number++;
325: labelstr = (char *) permalloc (strlen (label) + 1);
326: strcpy (labelstr, label);
327: return labelstr;
328: }
329:
330: /* Return the number which describes TYPE for SDB.
331: For pointers, etc., this function is recursive.
332: Each record, union or enumeral type must already have had a
333: tag number output. */
334:
335: /* The number is given by d6d5d4d3d2d1bbbb
336: where bbbb is 4 bit basic type, and di indicate one of notype,ptr,fn,array.
337: Thus, char *foo () has bbbb=T_CHAR
338: d1=D_FCN
339: d2=D_PTR
340: N_BTMASK= 017 1111 basic type field.
341: N_TSHIFT= 2 derived type shift
342: N_BTSHFT= 4 Basic type shift */
343:
344: /* Produce the number that describes a pointer, function or array type.
345: PREV is the number describing the target, value or element type.
346: DT_type describes how to transform that type. */
347: #define PUSH_DERIVED_LEVEL(DT_type,PREV) \
348: ((((PREV)&~N_BTMASK)<<N_TSHIFT)|(DT_type<<N_BTSHFT)|(PREV&N_BTMASK))
349:
350: /* Number of elements used in sdb_dims. */
351: static int sdb_n_dims = 0;
352:
353: /* Table of array dimensions of current type. */
354: static int sdb_dims[SDB_MAX_DIM];
355:
356: /* Size of outermost array currently being processed. */
357: static int sdb_type_size = -1;
358:
359: static int
360: plain_type (type)
361: tree type;
362: {
363: int val = plain_type_1 (type);
364:
365: /* If we have already saved up some array dimensions, print them now. */
366: if (sdb_n_dims > 0)
367: {
368: int i;
369: PUT_SDB_START_DIM;
370: for (i = sdb_n_dims - 1; i > 0; i--)
371: PUT_SDB_NEXT_DIM (sdb_dims[i]);
372: PUT_SDB_LAST_DIM (sdb_dims[0]);
373: sdb_n_dims = 0;
374:
375: sdb_type_size = int_size_in_bytes (type);
376: /* Don't kill sdb if type is not laid out or has variable size. */
377: if (sdb_type_size < 0)
378: sdb_type_size = 0;
379: }
380: /* If we have computed the size of an array containing this type,
381: print it now. */
382: if (sdb_type_size >= 0)
383: {
384: PUT_SDB_SIZE (sdb_type_size);
385: sdb_type_size = -1;
386: }
387: return val;
388: }
389:
390: static void
391: sdbout_record_type_name (type)
392: tree type;
393: {
394: char *name = 0;
395: int no_name;
396:
397: if (KNOWN_TYPE_TAG (type))
398: return;
399:
400: if (TYPE_NAME (type) != 0)
401: {
402: tree t = 0;
403: /* Find the IDENTIFIER_NODE for the type name. */
404: if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
405: {
406: t = TYPE_NAME (type);
407: }
408: #if 1 /* As a temprary hack, use typedef names for C++ only. */
409: else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
410: && TYPE_LANG_SPECIFIC (type))
411: {
412: t = DECL_NAME (TYPE_NAME (type));
413: }
414: #endif
415:
416: /* Now get the name as a string, or invent one. */
417: if (t != 0)
418: name = IDENTIFIER_POINTER (t);
419: }
420:
421: no_name = (name == 0 || *name == 0);
422: if (no_name)
423: name = gen_fake_label ();
424:
425: SET_KNOWN_TYPE_TAG (type, name);
426: #ifdef SDB_ALLOW_FORWARD_REFERENCES
427: if (no_name)
428: sdbout_queue_anonymous_type (type);
429: #endif
430: }
431:
432: static int
433: plain_type_1 (type)
434: tree type;
435: {
436: if (type == 0)
437: type = void_type_node;
438: if (type == error_mark_node)
439: type = integer_type_node;
440: type = TYPE_MAIN_VARIANT (type);
441:
442: switch (TREE_CODE (type))
443: {
444: case VOID_TYPE:
445: return T_VOID;
446: case INTEGER_TYPE:
447: {
448: int size = int_size_in_bytes (type) * BITS_PER_UNIT;
449: if (size == CHAR_TYPE_SIZE)
450: return (TREE_UNSIGNED (type) ? T_UCHAR : T_CHAR);
451: if (size == SHORT_TYPE_SIZE)
452: return (TREE_UNSIGNED (type) ? T_USHORT : T_SHORT);
453: if (size == INT_TYPE_SIZE)
454: return (TREE_UNSIGNED (type) ? T_UINT : T_INT);
455: return 0;
456: }
457:
458: case REAL_TYPE:
459: {
460: int size = int_size_in_bytes (type) * BITS_PER_UNIT;
461: if (size == FLOAT_TYPE_SIZE)
462: return T_FLOAT;
463: if (size == DOUBLE_TYPE_SIZE)
464: return T_DOUBLE;
465: return 0;
466: }
467:
468: case ARRAY_TYPE:
469: {
470: int m;
471: m = plain_type_1 (TREE_TYPE (type));
472: if (sdb_n_dims < SDB_MAX_DIM)
473: sdb_dims[sdb_n_dims++]
474: = (TYPE_DOMAIN (type)
475: ? TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) + 1
476: : 0);
477: return PUSH_DERIVED_LEVEL (DT_ARY, m);
478: }
479:
480: case RECORD_TYPE:
481: case UNION_TYPE:
482: case ENUMERAL_TYPE:
483: {
484: char *tag;
485: #ifdef SDB_ALLOW_FORWARD_REFERENCES
486: sdbout_record_type_name (type);
487: #endif
488: #ifndef SDB_ALLOW_UNKNOWN_REFERENCES
489: if ((TREE_ASM_WRITTEN (type) && KNOWN_TYPE_TAG (type) != 0)
490: #ifdef SDB_ALLOW_FORWARD_REFERENCES
491: || TYPE_MODE (type) != VOIDmode
492: #endif
493: )
494: #endif
495: {
496: /* Output the referenced structure tag name
497: only if the .def has already been finished.
498: At least on 386, the Unix assembler
499: cannot handle forward references to tags. */
500: /* But the 88100, it requires them, sigh... */
501: /* And the MIPS requires unknown refs as well... */
502: tag = KNOWN_TYPE_TAG (type);
503: PUT_SDB_TAG (tag);
504: /* These 3 lines used to follow the close brace.
505: However, a size of 0 without a tag implies a tag of 0,
506: so if we don't know a tag, we can't mention the size. */
507: sdb_type_size = int_size_in_bytes (type);
508: if (sdb_type_size < 0)
509: sdb_type_size = 0;
510: }
511: return ((TREE_CODE (type) == RECORD_TYPE) ? T_STRUCT
512: : (TREE_CODE (type) == UNION_TYPE) ? T_UNION
513: : T_ENUM);
514: }
515: case POINTER_TYPE:
516: case REFERENCE_TYPE:
517: {
518: int m = plain_type_1 (TREE_TYPE (type));
519: return PUSH_DERIVED_LEVEL (DT_PTR, m);
520: }
521: case FUNCTION_TYPE:
522: case METHOD_TYPE:
523: {
524: int m = plain_type_1 (TREE_TYPE (type));
525: return PUSH_DERIVED_LEVEL (DT_FCN, m);
526: }
527: default:
528: return 0;
529: }
530: }
531:
532: /* Output the symbols defined in block number DO_BLOCK.
533: Set NEXT_BLOCK_NUMBER to 0 before calling.
534:
535: This function works by walking the tree structure of blocks,
536: counting blocks until it finds the desired block. */
537:
538: static int do_block = 0;
539:
540: static int next_block_number;
541:
542: static void
543: sdbout_block (block)
544: register tree block;
545: {
546: while (block)
547: {
548: /* Ignore blocks never expanded or otherwise marked as real. */
549: if (TREE_USED (block))
550: {
551: /* When we reach the specified block, output its symbols. */
552: if (next_block_number == do_block)
553: {
554: sdbout_syms (BLOCK_VARS (block));
555: }
556:
557: /* If we are past the specified block, stop the scan. */
558: if (next_block_number > do_block)
559: return;
560:
561: next_block_number++;
562:
563: /* Scan the blocks within this block. */
564: sdbout_block (BLOCK_SUBBLOCKS (block));
565: }
566:
567: block = BLOCK_CHAIN (block);
568: }
569: }
570:
571: /* Call sdbout_symbol on each decl in the chain SYMS. */
572:
573: static void
574: sdbout_syms (syms)
575: tree syms;
576: {
577: while (syms)
578: {
579: if (TREE_CODE (syms) != LABEL_DECL)
580: sdbout_symbol (syms, 1);
581: syms = TREE_CHAIN (syms);
582: }
583: }
584:
585: /* Output SDB information for a symbol described by DECL.
586: LOCAL is nonzero if the symbol is not file-scope. */
587:
588: void
589: sdbout_symbol (decl, local)
590: tree decl;
591: int local;
592: {
593: int letter = 0;
594: tree type = TREE_TYPE (decl);
595: tree context = NULL_TREE;
596: rtx value;
597: int regno = -1;
598: char *name;
599:
600: sdbout_one_type (type);
601:
602: switch (TREE_CODE (decl))
603: {
604: case CONST_DECL:
605: /* Enum values are defined by defining the enum type. */
606: return;
607:
608: case FUNCTION_DECL:
609: /* Don't mention a nested function under its parent. */
610: context = decl_function_context (decl);
611: if (context == current_function_decl)
612: return;
613: if (TREE_EXTERNAL (decl))
614: return;
615: if (GET_CODE (DECL_RTL (decl)) != MEM
616: || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
617: return;
618: PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
619: PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
620: PUT_SDB_SCL (TREE_PUBLIC (decl) ? C_EXT : C_STAT);
621: break;
622:
623: case TYPE_DECL:
624: /* Done with tagged types. */
625: if (DECL_NAME (decl) == 0)
626: return;
627:
628: /* Output typedef name. */
629: PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_NAME (decl)));
630: PUT_SDB_SCL (C_TPDEF);
631: break;
632:
633: case PARM_DECL:
634: /* Parm decls go in their own separate chains
635: and are output by sdbout_reg_parms and sdbout_parms. */
636: abort ();
637:
638: case VAR_DECL:
639: /* Don't mention a variable that is external.
640: Let the file that defines it describe it. */
641: if (TREE_EXTERNAL (decl))
642: return;
643:
644: /* If there was an error in the declaration, don't dump core
645: if there is no RTL associated with the variable doesn't
646: exist. */
647: if (DECL_RTL (decl) == 0)
648: return;
649:
650: value = eliminate_regs (DECL_RTL (decl), 0, 0);
651:
652: /* Don't mention a variable at all
653: if it was completely optimized into nothingness.
654:
655: If DECL was from an inline function, then its rtl
656: is not identically the rtl that was used in this
657: particular compilation. */
658: if (GET_CODE (value) == REG)
659: {
660: regno = REGNO (DECL_RTL (decl));
661: if (regno >= FIRST_PSEUDO_REGISTER)
662: regno = reg_renumber[REGNO (DECL_RTL (decl))];
663: if (regno < 0)
664: return;
665: }
666: else if (GET_CODE (DECL_RTL (decl)) == SUBREG)
667: {
668: int offset = 0;
669: while (GET_CODE (value) == SUBREG)
670: {
671: offset += SUBREG_WORD (value);
672: value = SUBREG_REG (value);
673: }
674: if (GET_CODE (value) == REG)
675: {
676: regno = REGNO (value);
677: if (regno >= FIRST_PSEUDO_REGISTER)
678: regno = reg_renumber[REGNO (value)];
679: if (regno >= 0)
680: regno += offset;
681: }
682: }
683:
684: /* Emit any structure, union, or enum type that has not been output.
685: This occurs for tag-less structs (et al) used to declare variables
686: within functions. */
687: if (TREE_CODE (type) == ENUMERAL_TYPE
688: || TREE_CODE (type) == RECORD_TYPE
689: || TREE_CODE (type) == UNION_TYPE)
690: {
691: if (TYPE_SIZE (type) != 0 /* not a forward reference */
692: && KNOWN_TYPE_TAG (type) == 0) /* not yet declared */
693: sdbout_one_type (type);
694: }
695:
696: /* Defer SDB information for top-level initialized variables! */
697: if (! local
698: && GET_CODE (value) == MEM
699: && DECL_INITIAL (decl))
700: return;
701:
702: /* Record the name for, starting a symtab entry. */
703: name = IDENTIFIER_POINTER (DECL_NAME (decl));
704:
705: if (GET_CODE (value) == MEM
706: && GET_CODE (XEXP (value, 0)) == SYMBOL_REF)
707: {
708: PUT_SDB_DEF (name);
709: if (TREE_PUBLIC (decl))
710: {
711: PUT_SDB_VAL (XEXP (value, 0));
712: PUT_SDB_SCL (C_EXT);
713: }
714: else
715: {
716: PUT_SDB_VAL (XEXP (value, 0));
717: PUT_SDB_SCL (C_STAT);
718: }
719: }
720: else if (regno >= 0)
721: {
722: PUT_SDB_DEF (name);
723: PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (regno));
724: PUT_SDB_SCL (C_REG);
725: }
726: else if (GET_CODE (value) == MEM
727: && (GET_CODE (XEXP (value, 0)) == MEM
728: || (GET_CODE (XEXP (value, 0)) == REG
729: && REGNO (XEXP (value, 0)) != FRAME_POINTER_REGNUM
730: && REGNO (XEXP (value, 0)) != STACK_POINTER_REGNUM)))
731: /* If the value is indirect by memory or by a register
732: that isn't the frame pointer
733: then it means the object is variable-sized and address through
734: that register or stack slot. COFF has no way to represent this
735: so all we can do is output the variable as a pointer. */
736: {
737: PUT_SDB_DEF (name);
738: if (GET_CODE (XEXP (value, 0)) == REG)
739: {
740: PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (XEXP (value, 0))));
741: PUT_SDB_SCL (C_REG);
742: }
743: else
744: {
745: /* DECL_RTL looks like (MEM (MEM (PLUS (REG...)
746: (CONST_INT...)))).
747: We want the value of that CONST_INT. */
748: /* Encore compiler hates a newline in a macro arg, it seems. */
749: PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
750: (XEXP (XEXP (value, 0), 0)));
751: PUT_SDB_SCL (C_AUTO);
752: }
753:
754: type = build_pointer_type (TREE_TYPE (decl));
755: }
756: else if (GET_CODE (value) == MEM
757: && GET_CODE (XEXP (value, 0)) == PLUS
758: && GET_CODE (XEXP (XEXP (value, 0), 0)) == REG
759: && GET_CODE (XEXP (XEXP (value, 0), 1)) == CONST_INT)
760: {
761: /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))).
762: We want the value of that CONST_INT. */
763: PUT_SDB_DEF (name);
764: PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET (XEXP (value, 0)));
765: PUT_SDB_SCL (C_AUTO);
766: }
767: else
768: {
769: /* It is something we don't know how to represent for SDB. */
770: return;
771: }
772: break;
773: }
774: PUT_SDB_TYPE (plain_type (type));
775: PUT_SDB_ENDEF;
776: }
777:
778: /* Output SDB information for a top-level initialized variable
779: that has been delayed. */
780:
781: void
782: sdbout_toplevel_data (decl)
783: tree decl;
784: {
785: tree type = TREE_TYPE (decl);
786:
787: if (! (TREE_CODE (decl) == VAR_DECL
788: && GET_CODE (DECL_RTL (decl)) == MEM
789: && DECL_INITIAL (decl)))
790: abort ();
791:
792: PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
793: PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
794: if (TREE_PUBLIC (decl))
795: {
796: PUT_SDB_SCL (C_EXT);
797: }
798: else
799: {
800: PUT_SDB_SCL (C_STAT);
801: }
802: PUT_SDB_TYPE (plain_type (type));
803: PUT_SDB_ENDEF;
804: }
805:
806: #ifdef SDB_ALLOW_FORWARD_REFERENCES
807:
808: /* Machinery to record and output anonymous types. */
809:
810: static tree anonymous_types;
811:
812: static void
813: sdbout_queue_anonymous_type (type)
814: tree type;
815: {
816: anonymous_types = saveable_tree_cons (NULL_TREE, type, anonymous_types);
817: }
818:
819: static void
820: sdbout_dequeue_anonymous_types ()
821: {
822: register tree types, link;
823:
824: while (anonymous_types)
825: {
826: types = nreverse (anonymous_types);
827: anonymous_types = NULL_TREE;
828:
829: for (link = types; link; link = TREE_CHAIN (link))
830: {
831: register tree type = TREE_VALUE (link);
832:
833: if (! TREE_ASM_WRITTEN (type))
834: sdbout_one_type (type);
835: }
836: }
837: }
838:
839: #endif
840:
841: /* Given a chain of ..._TYPE nodes, all of which have names,
842: output definitions of those names, as typedefs. */
843:
844: void
845: sdbout_types (types)
846: register tree types;
847: {
848: register tree link;
849:
850: for (link = types; link; link = TREE_CHAIN (link))
851: sdbout_one_type (link);
852:
853: #ifdef SDB_ALLOW_FORWARD_REFERENCES
854: sdbout_dequeue_anonymous_types ();
855: #endif
856: }
857:
858: static void
859: sdbout_type (type)
860: tree type;
861: {
862: register tree tem;
863: if (type == error_mark_node)
864: type = integer_type_node;
865: PUT_SDB_TYPE (plain_type (type));
866: }
867:
868: /* Output types of the fields of type TYPE, if they are structs.
869:
870: Formerly did not chase through pointer types, since that could be circular.
871: They must come before TYPE, since forward refs are not allowed.
872: Now [email protected] says to try them. */
873:
874: static void
875: sdbout_field_types (type)
876: tree type;
877: {
878: tree tail;
879: for (tail = TYPE_FIELDS (type); tail; tail = TREE_CHAIN (tail))
880: if (TREE_CODE (TREE_TYPE (tail)) == POINTER_TYPE)
881: sdbout_one_type (TREE_TYPE (TREE_TYPE (tail)));
882: else
883: sdbout_one_type (TREE_TYPE (tail));
884: }
885:
886: /* Use this to put out the top level defined record and union types
887: for later reference. If this is a struct with a name, then put that
888: name out. Other unnamed structs will have .xxfake labels generated so
889: that they may be referred to later.
890: The label will be stored in the KNOWN_TYPE_TAG slot of a type.
891: It may NOT be called recursively. */
892:
893: static void
894: sdbout_one_type (type)
895: tree type;
896: {
897: text_section ();
898:
899: switch (TREE_CODE (type))
900: {
901: case RECORD_TYPE:
902: case UNION_TYPE:
903: case ENUMERAL_TYPE:
904: type = TYPE_MAIN_VARIANT (type);
905: /* Don't output a type twice. */
906: if (TREE_ASM_WRITTEN (type))
907: /* James said test TREE_ASM_BEING_WRITTEN here. */
908: return;
909:
910: /* Output nothing if type is not yet defined. */
911: if (TYPE_SIZE (type) == 0)
912: return;
913:
914: TREE_ASM_WRITTEN (type) = 1;
915: #if 1
916: /* This is reputed to cause trouble with the following case,
917: but perhaps checking TYPE_SIZE above will fix it.
918:
919: /* Here is a test case:
920:
921: struct foo {
922: struct badstr *bbb;
923: } forwardref;
924:
925: typedef struct intermediate {
926: int aaaa;
927: } intermediate_ref;
928:
929: typedef struct badstr {
930: int ccccc;
931: } badtype; */
932:
933: #if 0
934: TREE_ASM_BEING_WRITTEN (type) = 1;
935: #endif
936: /* This change, which ought to make better output,
937: used to make the COFF assembler unhappy.
938: Changes involving KNOWN_TYPE_TAG may fix the problem. */
939: /* Before really doing anything, output types we want to refer to. */
940: /* Note that in version 1 the following two lines
941: are not used if forward references are in use. */
942: if (TREE_CODE (type) != ENUMERAL_TYPE)
943: sdbout_field_types (type);
944: #if 0
945: TREE_ASM_WRITTEN (type) = 1;
946: #endif
947: #endif
948:
949: /* Output a structure type. */
950: {
951: int size = int_size_in_bytes (type);
952: int member_scl;
953: tree tem;
954: int i, n_baseclasses = 0;
955:
956: /* Record the type tag, but not in its permanent place just yet. */
957: sdbout_record_type_name (type);
958:
959: PUT_SDB_DEF (KNOWN_TYPE_TAG (type));
960:
961: switch (TREE_CODE (type))
962: {
963: case UNION_TYPE:
964: PUT_SDB_SCL (C_UNTAG);
965: PUT_SDB_TYPE (T_UNION);
966: member_scl = C_MOU;
967: break;
968:
969: case RECORD_TYPE:
970: PUT_SDB_SCL (C_STRTAG);
971: PUT_SDB_TYPE (T_STRUCT);
972: member_scl = C_MOS;
973: break;
974:
975: case ENUMERAL_TYPE:
976: PUT_SDB_SCL (C_ENTAG);
977: PUT_SDB_TYPE (T_ENUM);
978: member_scl = C_MOE;
979: break;
980: }
981:
982: PUT_SDB_SIZE (size);
983: PUT_SDB_ENDEF;
984:
985: /* Print out the base class information with fields
986: named after the types they hold. */
987: if (TYPE_BINFO (type)
988: && TYPE_BINFO_BASETYPES (type))
989: n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
990: for (i = 0; i < n_baseclasses; i++)
991: {
992: tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i);
993: tree child_type = BINFO_TYPE (child);
994: tree child_type_name;
995: if (TYPE_NAME (child_type) == 0)
996: continue;
997: if (TREE_CODE (TYPE_NAME (child_type)) == IDENTIFIER_NODE)
998: child_type_name = TYPE_NAME (child_type);
999: else if (TREE_CODE (TYPE_NAME (child_type)) == TYPE_DECL)
1000: child_type_name = DECL_NAME (TYPE_NAME (child_type));
1001: else
1002: continue;
1003:
1004: CONTIN;
1005: PUT_SDB_DEF (IDENTIFIER_POINTER (child_type_name));
1006: PUT_SDB_INT_VAL (TREE_INT_CST_LOW (BINFO_OFFSET (child)));
1007: PUT_SDB_SCL (member_scl);
1008: sdbout_type (BINFO_TYPE (child));
1009: PUT_SDB_ENDEF;
1010: }
1011:
1012: /* output the individual fields */
1013:
1014: if (TREE_CODE (type) == ENUMERAL_TYPE)
1015: for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1016: {
1017: PUT_SDB_DEF (IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1018: PUT_SDB_INT_VAL (TREE_INT_CST_LOW (TREE_VALUE (tem)));
1019: PUT_SDB_SCL (C_MOE);
1020: PUT_SDB_TYPE (T_MOE);
1021: PUT_SDB_ENDEF;
1022: }
1023:
1024: else /* record or union type */
1025: for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1026: /* Output the name, type, position (in bits), size (in bits)
1027: of each field. */
1028:
1029: /* Omit here the nameless fields that are used to skip bits.
1030: Also omit fields with variable size or position.
1031: Also omit non FIELD_DECL nodes that GNU C++ may put here. */
1032: if (TREE_CODE (tem) == FIELD_DECL
1033: && DECL_NAME (tem) != 0
1034: && TREE_CODE (DECL_SIZE (tem)) == INTEGER_CST
1035: && TREE_CODE (DECL_FIELD_BITPOS (tem)) == INTEGER_CST)
1036: {
1037: CONTIN;
1038: PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_NAME (tem)));
1039: if (DECL_BIT_FIELD_TYPE (tem))
1040: {
1041: PUT_SDB_INT_VAL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)));
1042: PUT_SDB_SCL (C_FIELD);
1043: sdbout_type (DECL_BIT_FIELD_TYPE (tem));
1044: PUT_SDB_SIZE (TREE_INT_CST_LOW (DECL_SIZE (tem)));
1045: }
1046: else
1047: {
1048: PUT_SDB_INT_VAL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem))
1049: / BITS_PER_UNIT);
1050: PUT_SDB_SCL (member_scl);
1051: sdbout_type (TREE_TYPE (tem));
1052: }
1053: PUT_SDB_ENDEF;
1054: }
1055: /* output end of a structure,union, or enumeral definition */
1056:
1057: PUT_SDB_PLAIN_DEF ("eos");
1058: PUT_SDB_INT_VAL (size);
1059: PUT_SDB_SCL (C_EOS);
1060: PUT_SDB_TAG (KNOWN_TYPE_TAG (type));
1061: PUT_SDB_SIZE (size);
1062: PUT_SDB_ENDEF;
1063: break;
1064: }
1065: }
1066: }
1067:
1068: /* The following two functions output definitions of function parameters.
1069: Each parameter gets a definition locating it in the parameter list.
1070: Each parameter that is a register variable gets a second definition
1071: locating it in the register.
1072:
1073: Printing or argument lists in gdb uses the definitions that
1074: locate in the parameter list. But reference to the variable in
1075: expressions uses preferentially the definition as a register. */
1076:
1077: /* Output definitions, referring to storage in the parmlist,
1078: of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
1079:
1080: static void
1081: sdbout_parms (parms)
1082: tree parms;
1083: {
1084: for (; parms; parms = TREE_CHAIN (parms))
1085: if (DECL_NAME (parms))
1086: {
1087: int current_sym_value = 0;
1088: char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
1089:
1090: if (name == 0 || *name == 0)
1091: name = gen_fake_label ();
1092:
1093: /* Perform any necessary register eliminations on the parameter's rtl,
1094: so that the debugging output will be accurate. */
1095: DECL_INCOMING_RTL (parms) =
1096: eliminate_regs (DECL_INCOMING_RTL (parms), 0, 0);
1097: DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, 0);
1098:
1099: if (PARM_PASSED_IN_MEMORY (parms))
1100: {
1101: rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
1102: tree type;
1103:
1104: /* ??? Here we assume that the parm address is indexed
1105: off the frame pointer or arg pointer.
1106: If that is not true, we produce meaningless results,
1107: but do not crash. */
1108: if (GET_CODE (addr) == PLUS
1109: && GET_CODE (XEXP (addr, 1)) == CONST_INT)
1110: current_sym_value = INTVAL (XEXP (addr, 1));
1111: else
1112: current_sym_value = 0;
1113:
1114: if (GET_CODE (DECL_RTL (parms)) == REG
1115: && REGNO (DECL_RTL (parms)) >= 0
1116: && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1117: type = DECL_ARG_TYPE (parms);
1118: else
1119: {
1120: int original_sym_value = current_sym_value;
1121:
1122: /* This is the case where the parm is passed as an int or
1123: double and it is converted to a char, short or float
1124: and stored back in the parmlist. In this case, describe
1125: the parm with the variable's declared type, and adjust
1126: the address if the least significant bytes (which we are
1127: using) are not the first ones. */
1128: #if BYTES_BIG_ENDIAN
1129: if (TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1130: current_sym_value +=
1131: (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1132: - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1133: #endif
1134: if (GET_CODE (DECL_RTL (parms)) == MEM
1135: && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1136: && (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1))
1137: == CONST_INT)
1138: && (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1))
1139: == current_sym_value))
1140: type = TREE_TYPE (parms);
1141: else
1142: {
1143: current_sym_value = original_sym_value;
1144: type = DECL_ARG_TYPE (parms);
1145: }
1146: }
1147:
1148: PUT_SDB_DEF (name);
1149: PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value, addr));
1150: PUT_SDB_SCL (C_ARG);
1151: PUT_SDB_TYPE (plain_type (type));
1152: PUT_SDB_ENDEF;
1153: }
1154: else if (GET_CODE (DECL_RTL (parms)) == REG)
1155: {
1156: rtx best_rtl;
1157: /* Parm passed in registers and lives in registers or nowhere. */
1158:
1159: /* If parm lives in a register, use that register;
1160: pretend the parm was passed there. It would be more consistent
1161: to describe the register where the parm was passed,
1162: but in practice that register usually holds something else. */
1163: if (REGNO (DECL_RTL (parms)) >= 0
1164: && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1165: best_rtl = DECL_RTL (parms);
1166: /* If the parm lives nowhere,
1167: use the register where it was passed. */
1168: else
1169: best_rtl = DECL_INCOMING_RTL (parms);
1170:
1171: PUT_SDB_DEF (name);
1172: PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (best_rtl)));
1173: PUT_SDB_SCL (C_REGPARM);
1174: PUT_SDB_TYPE (plain_type (TREE_TYPE (parms), 0));
1175: PUT_SDB_ENDEF;
1176: }
1177: else if (GET_CODE (DECL_RTL (parms)) == MEM
1178: && XEXP (DECL_RTL (parms), 0) != const0_rtx)
1179: {
1180: /* Parm was passed in registers but lives on the stack. */
1181:
1182: /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
1183: in which case we want the value of that CONST_INT,
1184: or (MEM (REG ...)) or (MEM (MEM ...)),
1185: in which case we use a value of zero. */
1186: if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
1187: || GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
1188: current_sym_value = 0;
1189: else
1190: current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
1191:
1192: /* Again, this assumes the offset is based on the arg pointer. */
1193: PUT_SDB_DEF (name);
1194: PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value,
1195: XEXP (DECL_RTL (parms), 0)));
1196: PUT_SDB_SCL (C_ARG);
1197: PUT_SDB_TYPE (plain_type (TREE_TYPE (parms), 0));
1198: PUT_SDB_ENDEF;
1199: }
1200: }
1201: }
1202:
1203: /* Output definitions for the places where parms live during the function,
1204: when different from where they were passed, when the parms were passed
1205: in memory.
1206:
1207: It is not useful to do this for parms passed in registers
1208: that live during the function in different registers, because it is
1209: impossible to look in the passed register for the passed value,
1210: so we use the within-the-function register to begin with.
1211:
1212: PARMS is a chain of PARM_DECL nodes. */
1213:
1214: static void
1215: sdbout_reg_parms (parms)
1216: tree parms;
1217: {
1218: for (; parms; parms = TREE_CHAIN (parms))
1219: if (DECL_NAME (parms))
1220: {
1221: char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
1222:
1223: /* Report parms that live in registers during the function
1224: but were passed in memory. */
1225: if (GET_CODE (DECL_RTL (parms)) == REG
1226: && REGNO (DECL_RTL (parms)) >= 0
1227: && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER
1228: && PARM_PASSED_IN_MEMORY (parms))
1229: {
1230: if (name == 0 || *name == 0)
1231: name = gen_fake_label ();
1232: PUT_SDB_DEF (name);
1233: PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms))));
1234: PUT_SDB_SCL (C_REG);
1235: PUT_SDB_TYPE (plain_type (TREE_TYPE (parms), 0));
1236: PUT_SDB_ENDEF;
1237: }
1238: /* Report parms that live in memory but not where they were passed. */
1239: else if (GET_CODE (DECL_RTL (parms)) == MEM
1240: && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1241: && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
1242: && PARM_PASSED_IN_MEMORY (parms)
1243: && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
1244: {
1245: #if 0 /* ??? It is not clear yet what should replace this. */
1246: int offset = DECL_OFFSET (parms) / BITS_PER_UNIT;
1247: /* A parm declared char is really passed as an int,
1248: so it occupies the least significant bytes.
1249: On a big-endian machine those are not the low-numbered ones. */
1250: #if BYTES_BIG_ENDIAN
1251: if (offset != -1 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1252: offset += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1253: - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1254: #endif
1255: if (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) != offset) {...}
1256: #endif
1257: {
1258: if (name == 0 || *name == 0)
1259: name = gen_fake_label ();
1260: PUT_SDB_DEF (name);
1261: PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
1262: (XEXP (DECL_RTL (parms), 0)));
1263: PUT_SDB_SCL (C_AUTO);
1264: PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1265: PUT_SDB_ENDEF;
1266: }
1267: }
1268: }
1269: }
1270:
1271: /* Describe the beginning of an internal block within a function.
1272: Also output descriptions of variables defined in this block.
1273:
1274: N is the number of the block, by order of beginning, counting from 1,
1275: and not counting the outermost (function top-level) block.
1276: The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
1277: if the count starts at 0 for the outermost one. */
1278:
1279: void
1280: sdbout_begin_block (file, line, n)
1281: FILE *file;
1282: int line;
1283: int n;
1284: {
1285: tree decl = current_function_decl;
1286: MAKE_LINE_SAFE (line);
1287: PUT_SDB_BLOCK_START (line - sdb_begin_function_line);
1288: if (n == 1)
1289: {
1290: /* Include the outermost BLOCK's variables in block 1. */
1291: next_block_number = 0;
1292: do_block = 0;
1293: sdbout_block (DECL_INITIAL (decl));
1294: }
1295: /* If -g1, suppress all the internal symbols of functions
1296: except for arguments. */
1297: if (debug_info_level != DINFO_LEVEL_TERSE)
1298: {
1299: next_block_number = 0;
1300: do_block = n;
1301: sdbout_block (DECL_INITIAL (decl));
1302: }
1303:
1304: #ifdef SDB_ALLOW_FORWARD_REFERENCES
1305: sdbout_dequeue_anonymous_types ();
1306: #endif
1307: }
1308:
1309: /* Describe the end line-number of an internal block within a function. */
1310:
1311: void
1312: sdbout_end_block (file, line)
1313: FILE *file;
1314: int line;
1315: {
1316: MAKE_LINE_SAFE (line);
1317: PUT_SDB_BLOCK_END (line - sdb_begin_function_line);
1318: }
1319:
1320: /* Output sdb info for the current function name.
1321: Called from assemble_start_function. */
1322:
1323: void
1324: sdbout_mark_begin_function ()
1325: {
1326: sdbout_symbol (current_function_decl, 0);
1327: }
1328:
1329: /* Called at beginning of function body (after prologue).
1330: Record the function's starting line number, so we can output
1331: relative line numbers for the other lines.
1332: Describe beginning of outermost block.
1333: Also describe the parameter list. */
1334:
1335: void
1336: sdbout_begin_function (line)
1337: int line;
1338: {
1339: sdb_begin_function_line = line - 1;
1340: PUT_SDB_FUNCTION_START (line);
1341: sdbout_parms (DECL_ARGUMENTS (current_function_decl));
1342: sdbout_reg_parms (DECL_ARGUMENTS (current_function_decl));
1343: }
1344:
1345: /* Called at end of function (before epilogue).
1346: Describe end of outermost block. */
1347:
1348: void
1349: sdbout_end_function (line)
1350: int line;
1351: {
1352: #ifdef SDB_ALLOW_FORWARD_REFERENCES
1353: sdbout_dequeue_anonymous_types ();
1354: #endif
1355:
1356: MAKE_LINE_SAFE (line);
1357: PUT_SDB_FUNCTION_END (line - sdb_begin_function_line);
1358:
1359: /* Indicate we are between functions, for line-number output. */
1360: sdb_begin_function_line = -1;
1361: }
1362:
1363: /* Output sdb info for the absolute end of a function.
1364: Called after the epilogue is output. */
1365:
1366: void
1367: sdbout_end_epilogue ()
1368: {
1369: char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
1370: PUT_SDB_EPILOGUE_END (name);
1371: }
1372:
1373: /* Output sdb info for the given label. Called only if LABEL_NAME (insn)
1374: is present. */
1375:
1376: void
1377: sdbout_label (insn)
1378: register rtx insn;
1379: {
1380: PUT_SDB_DEF (LABEL_NAME (insn));
1381: PUT_SDB_VAL (insn);
1382: PUT_SDB_SCL (C_LABEL);
1383: PUT_SDB_TYPE (T_NULL);
1384: PUT_SDB_ENDEF;
1385: }
1386:
1387: #endif /* SDB_DEBUGGING_INFO */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.