![[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
1.1.1.3 root 37: end of file with all top level statics occurring first before externs.
1.1 root 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. */
1.1.1.4 root 56: #if defined(USG) && !defined(MIPS) && !defined (hpux)
1.1 root 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 ();
1.1.1.2 root 107: static void sdbout_dequeue_anonymous_types ();
1.1 root 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. */
1.1.1.5 ! root 347: #define PUSH_DERIVED_LEVEL(DT_type,PREV) \
! 348: ((((PREV) & ~(int)N_BTMASK) << (int)N_TSHIFT) \
! 349: | ((int)DT_type << (int)N_BTSHFT) \
! 350: | ((PREV) & (int)N_BTMASK))
1.1 root 351:
352: /* Number of elements used in sdb_dims. */
353: static int sdb_n_dims = 0;
354:
355: /* Table of array dimensions of current type. */
356: static int sdb_dims[SDB_MAX_DIM];
357:
358: /* Size of outermost array currently being processed. */
359: static int sdb_type_size = -1;
360:
361: static int
362: plain_type (type)
363: tree type;
364: {
365: int val = plain_type_1 (type);
366:
367: /* If we have already saved up some array dimensions, print them now. */
368: if (sdb_n_dims > 0)
369: {
370: int i;
371: PUT_SDB_START_DIM;
372: for (i = sdb_n_dims - 1; i > 0; i--)
373: PUT_SDB_NEXT_DIM (sdb_dims[i]);
374: PUT_SDB_LAST_DIM (sdb_dims[0]);
375: sdb_n_dims = 0;
376:
377: sdb_type_size = int_size_in_bytes (type);
378: /* Don't kill sdb if type is not laid out or has variable size. */
379: if (sdb_type_size < 0)
380: sdb_type_size = 0;
381: }
382: /* If we have computed the size of an array containing this type,
383: print it now. */
384: if (sdb_type_size >= 0)
385: {
386: PUT_SDB_SIZE (sdb_type_size);
387: sdb_type_size = -1;
388: }
389: return val;
390: }
391:
1.1.1.4 root 392: static int
393: template_name_p (name)
394: tree name;
395: {
396: register char *ptr = IDENTIFIER_POINTER (name);
397: while (*ptr && *ptr != '<')
398: ptr++;
399:
400: return *ptr != '\0';
401: }
402:
1.1 root 403: static void
404: sdbout_record_type_name (type)
405: tree type;
406: {
407: char *name = 0;
408: int no_name;
409:
410: if (KNOWN_TYPE_TAG (type))
411: return;
412:
413: if (TYPE_NAME (type) != 0)
414: {
415: tree t = 0;
416: /* Find the IDENTIFIER_NODE for the type name. */
417: if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
418: {
419: t = TYPE_NAME (type);
420: }
1.1.1.5 ! root 421: #if 1 /* As a temporary hack, use typedef names for C++ only. */
1.1 root 422: else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
423: && TYPE_LANG_SPECIFIC (type))
424: {
425: t = DECL_NAME (TYPE_NAME (type));
1.1.1.4 root 426: /* The DECL_NAME for templates includes "<>", which breaks
427: most assemblers. Use its assembler name instead, which
428: has been mangled into being safe. */
429: if (t && template_name_p (t))
430: t = DECL_ASSEMBLER_NAME (TYPE_NAME (type));
1.1 root 431: }
432: #endif
433:
434: /* Now get the name as a string, or invent one. */
1.1.1.4 root 435: if (t != NULL_TREE)
1.1 root 436: name = IDENTIFIER_POINTER (t);
437: }
438:
439: no_name = (name == 0 || *name == 0);
440: if (no_name)
441: name = gen_fake_label ();
442:
443: SET_KNOWN_TYPE_TAG (type, name);
444: #ifdef SDB_ALLOW_FORWARD_REFERENCES
445: if (no_name)
446: sdbout_queue_anonymous_type (type);
447: #endif
448: }
449:
450: static int
451: plain_type_1 (type)
452: tree type;
453: {
454: if (type == 0)
455: type = void_type_node;
456: if (type == error_mark_node)
457: type = integer_type_node;
458: type = TYPE_MAIN_VARIANT (type);
459:
460: switch (TREE_CODE (type))
461: {
462: case VOID_TYPE:
463: return T_VOID;
464: case INTEGER_TYPE:
465: {
466: int size = int_size_in_bytes (type) * BITS_PER_UNIT;
1.1.1.5 ! root 467:
! 468: /* Carefully distinguish all the standard types of C,
! 469: without messing up if the language is not C.
! 470: Note that we check only for the names that contain spaces;
! 471: other names might occur by coincidence in other languages. */
! 472: if (TYPE_NAME (type) != 0
! 473: && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
! 474: && DECL_NAME (TYPE_NAME (type)) != 0
! 475: && TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE)
! 476: {
! 477: char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
! 478:
! 479: if (!strcmp (name, "unsigned char"))
! 480: return T_UCHAR;
! 481: if (!strcmp (name, "signed char"))
! 482: return T_CHAR;
! 483: if (!strcmp (name, "unsigned int"))
! 484: return T_UINT;
! 485: if (!strcmp (name, "short int"))
! 486: return T_SHORT;
! 487: if (!strcmp (name, "short unsigned int"))
! 488: return T_USHORT;
! 489: if (!strcmp (name, "long int"))
! 490: return T_LONG;
! 491: if (!strcmp (name, "long unsigned int"))
! 492: return T_ULONG;
! 493: }
! 494:
1.1 root 495: if (size == CHAR_TYPE_SIZE)
496: return (TREE_UNSIGNED (type) ? T_UCHAR : T_CHAR);
497: if (size == SHORT_TYPE_SIZE)
498: return (TREE_UNSIGNED (type) ? T_USHORT : T_SHORT);
499: if (size == INT_TYPE_SIZE)
500: return (TREE_UNSIGNED (type) ? T_UINT : T_INT);
1.1.1.4 root 501: if (size == LONG_TYPE_SIZE)
502: return (TREE_UNSIGNED (type) ? T_ULONG : T_LONG);
1.1 root 503: return 0;
504: }
505:
506: case REAL_TYPE:
507: {
508: int size = int_size_in_bytes (type) * BITS_PER_UNIT;
509: if (size == FLOAT_TYPE_SIZE)
510: return T_FLOAT;
511: if (size == DOUBLE_TYPE_SIZE)
512: return T_DOUBLE;
513: return 0;
514: }
515:
516: case ARRAY_TYPE:
517: {
518: int m;
519: m = plain_type_1 (TREE_TYPE (type));
520: if (sdb_n_dims < SDB_MAX_DIM)
521: sdb_dims[sdb_n_dims++]
522: = (TYPE_DOMAIN (type)
523: ? TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) + 1
524: : 0);
525: return PUSH_DERIVED_LEVEL (DT_ARY, m);
526: }
527:
528: case RECORD_TYPE:
529: case UNION_TYPE:
1.1.1.5 ! root 530: case QUAL_UNION_TYPE:
1.1 root 531: case ENUMERAL_TYPE:
532: {
533: char *tag;
534: #ifdef SDB_ALLOW_FORWARD_REFERENCES
535: sdbout_record_type_name (type);
536: #endif
537: #ifndef SDB_ALLOW_UNKNOWN_REFERENCES
538: if ((TREE_ASM_WRITTEN (type) && KNOWN_TYPE_TAG (type) != 0)
539: #ifdef SDB_ALLOW_FORWARD_REFERENCES
540: || TYPE_MODE (type) != VOIDmode
541: #endif
542: )
543: #endif
544: {
545: /* Output the referenced structure tag name
546: only if the .def has already been finished.
547: At least on 386, the Unix assembler
548: cannot handle forward references to tags. */
549: /* But the 88100, it requires them, sigh... */
550: /* And the MIPS requires unknown refs as well... */
551: tag = KNOWN_TYPE_TAG (type);
552: PUT_SDB_TAG (tag);
553: /* These 3 lines used to follow the close brace.
554: However, a size of 0 without a tag implies a tag of 0,
555: so if we don't know a tag, we can't mention the size. */
556: sdb_type_size = int_size_in_bytes (type);
557: if (sdb_type_size < 0)
558: sdb_type_size = 0;
559: }
560: return ((TREE_CODE (type) == RECORD_TYPE) ? T_STRUCT
561: : (TREE_CODE (type) == UNION_TYPE) ? T_UNION
1.1.1.5 ! root 562: : (TREE_CODE (type) == QUAL_UNION_TYPE) ? T_UNION
1.1 root 563: : T_ENUM);
564: }
565: case POINTER_TYPE:
566: case REFERENCE_TYPE:
567: {
568: int m = plain_type_1 (TREE_TYPE (type));
569: return PUSH_DERIVED_LEVEL (DT_PTR, m);
570: }
571: case FUNCTION_TYPE:
572: case METHOD_TYPE:
573: {
574: int m = plain_type_1 (TREE_TYPE (type));
575: return PUSH_DERIVED_LEVEL (DT_FCN, m);
576: }
577: default:
578: return 0;
579: }
580: }
581:
582: /* Output the symbols defined in block number DO_BLOCK.
583: Set NEXT_BLOCK_NUMBER to 0 before calling.
584:
585: This function works by walking the tree structure of blocks,
586: counting blocks until it finds the desired block. */
587:
588: static int do_block = 0;
589:
590: static int next_block_number;
591:
592: static void
593: sdbout_block (block)
594: register tree block;
595: {
596: while (block)
597: {
598: /* Ignore blocks never expanded or otherwise marked as real. */
599: if (TREE_USED (block))
600: {
601: /* When we reach the specified block, output its symbols. */
602: if (next_block_number == do_block)
603: {
604: sdbout_syms (BLOCK_VARS (block));
605: }
606:
607: /* If we are past the specified block, stop the scan. */
608: if (next_block_number > do_block)
609: return;
610:
611: next_block_number++;
612:
613: /* Scan the blocks within this block. */
614: sdbout_block (BLOCK_SUBBLOCKS (block));
615: }
616:
617: block = BLOCK_CHAIN (block);
618: }
619: }
620:
621: /* Call sdbout_symbol on each decl in the chain SYMS. */
622:
623: static void
624: sdbout_syms (syms)
625: tree syms;
626: {
627: while (syms)
628: {
629: if (TREE_CODE (syms) != LABEL_DECL)
630: sdbout_symbol (syms, 1);
631: syms = TREE_CHAIN (syms);
632: }
633: }
634:
635: /* Output SDB information for a symbol described by DECL.
636: LOCAL is nonzero if the symbol is not file-scope. */
637:
638: void
639: sdbout_symbol (decl, local)
640: tree decl;
641: int local;
642: {
643: int letter = 0;
644: tree type = TREE_TYPE (decl);
645: tree context = NULL_TREE;
646: rtx value;
647: int regno = -1;
648: char *name;
649:
650: sdbout_one_type (type);
651:
1.1.1.3 root 652: #if 0 /* This loses when functions are marked to be ignored,
653: which happens in the C++ front end. */
654: if (DECL_IGNORED_P (decl))
655: return;
656: #endif
657:
1.1 root 658: switch (TREE_CODE (decl))
659: {
660: case CONST_DECL:
661: /* Enum values are defined by defining the enum type. */
662: return;
663:
664: case FUNCTION_DECL:
665: /* Don't mention a nested function under its parent. */
666: context = decl_function_context (decl);
667: if (context == current_function_decl)
668: return;
1.1.1.4 root 669: if (DECL_EXTERNAL (decl))
1.1 root 670: return;
671: if (GET_CODE (DECL_RTL (decl)) != MEM
672: || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
673: return;
674: PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
675: PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
676: PUT_SDB_SCL (TREE_PUBLIC (decl) ? C_EXT : C_STAT);
677: break;
678:
679: case TYPE_DECL:
680: /* Done with tagged types. */
681: if (DECL_NAME (decl) == 0)
682: return;
1.1.1.3 root 683: if (DECL_IGNORED_P (decl))
684: return;
1.1 root 685:
686: /* Output typedef name. */
1.1.1.4 root 687: if (template_name_p (DECL_NAME (decl)))
688: PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
689: else
690: PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_NAME (decl)));
1.1 root 691: PUT_SDB_SCL (C_TPDEF);
692: break;
693:
694: case PARM_DECL:
695: /* Parm decls go in their own separate chains
696: and are output by sdbout_reg_parms and sdbout_parms. */
697: abort ();
698:
699: case VAR_DECL:
700: /* Don't mention a variable that is external.
701: Let the file that defines it describe it. */
1.1.1.4 root 702: if (DECL_EXTERNAL (decl))
1.1 root 703: return;
704:
1.1.1.3 root 705: /* Ignore __FUNCTION__, etc. */
706: if (DECL_IGNORED_P (decl))
707: return;
708:
1.1 root 709: /* If there was an error in the declaration, don't dump core
710: if there is no RTL associated with the variable doesn't
711: exist. */
712: if (DECL_RTL (decl) == 0)
713: return;
714:
1.1.1.4 root 715: DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, NULL_RTX);
716: #ifdef LEAF_REG_REMAP
717: if (leaf_function)
718: leaf_renumber_regs_insn (DECL_RTL (decl));
719: #endif
720: value = DECL_RTL (decl);
1.1 root 721:
722: /* Don't mention a variable at all
723: if it was completely optimized into nothingness.
724:
725: If DECL was from an inline function, then its rtl
726: is not identically the rtl that was used in this
727: particular compilation. */
728: if (GET_CODE (value) == REG)
729: {
730: regno = REGNO (DECL_RTL (decl));
731: if (regno >= FIRST_PSEUDO_REGISTER)
732: return;
733: }
1.1.1.4 root 734: else if (GET_CODE (value) == SUBREG)
1.1 root 735: {
736: int offset = 0;
737: while (GET_CODE (value) == SUBREG)
738: {
739: offset += SUBREG_WORD (value);
740: value = SUBREG_REG (value);
741: }
742: if (GET_CODE (value) == REG)
743: {
744: regno = REGNO (value);
745: if (regno >= FIRST_PSEUDO_REGISTER)
1.1.1.4 root 746: return;
747: regno += offset;
1.1 root 748: }
1.1.1.4 root 749: alter_subreg (DECL_RTL (decl));
750: value = DECL_RTL (decl);
1.1 root 751: }
752:
753: /* Emit any structure, union, or enum type that has not been output.
754: This occurs for tag-less structs (et al) used to declare variables
755: within functions. */
756: if (TREE_CODE (type) == ENUMERAL_TYPE
757: || TREE_CODE (type) == RECORD_TYPE
1.1.1.5 ! root 758: || TREE_CODE (type) == UNION_TYPE
! 759: || TREE_CODE (type) == QUAL_UNION_TYPE)
1.1 root 760: {
761: if (TYPE_SIZE (type) != 0 /* not a forward reference */
762: && KNOWN_TYPE_TAG (type) == 0) /* not yet declared */
763: sdbout_one_type (type);
764: }
765:
766: /* Defer SDB information for top-level initialized variables! */
767: if (! local
768: && GET_CODE (value) == MEM
769: && DECL_INITIAL (decl))
770: return;
771:
1.1.1.4 root 772: /* C++ in 2.3 makes nameless symbols. That will be fixed later.
773: For now, avoid crashing. */
774: if (DECL_NAME (decl) == NULL_TREE)
775: return;
776:
1.1 root 777: /* Record the name for, starting a symtab entry. */
778: name = IDENTIFIER_POINTER (DECL_NAME (decl));
779:
780: if (GET_CODE (value) == MEM
781: && GET_CODE (XEXP (value, 0)) == SYMBOL_REF)
782: {
783: PUT_SDB_DEF (name);
784: if (TREE_PUBLIC (decl))
785: {
786: PUT_SDB_VAL (XEXP (value, 0));
787: PUT_SDB_SCL (C_EXT);
788: }
789: else
790: {
791: PUT_SDB_VAL (XEXP (value, 0));
792: PUT_SDB_SCL (C_STAT);
793: }
794: }
795: else if (regno >= 0)
796: {
797: PUT_SDB_DEF (name);
798: PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (regno));
799: PUT_SDB_SCL (C_REG);
800: }
801: else if (GET_CODE (value) == MEM
802: && (GET_CODE (XEXP (value, 0)) == MEM
803: || (GET_CODE (XEXP (value, 0)) == REG
804: && REGNO (XEXP (value, 0)) != FRAME_POINTER_REGNUM
805: && REGNO (XEXP (value, 0)) != STACK_POINTER_REGNUM)))
806: /* If the value is indirect by memory or by a register
807: that isn't the frame pointer
808: then it means the object is variable-sized and address through
809: that register or stack slot. COFF has no way to represent this
810: so all we can do is output the variable as a pointer. */
811: {
812: PUT_SDB_DEF (name);
813: if (GET_CODE (XEXP (value, 0)) == REG)
814: {
815: PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (XEXP (value, 0))));
816: PUT_SDB_SCL (C_REG);
817: }
818: else
819: {
820: /* DECL_RTL looks like (MEM (MEM (PLUS (REG...)
821: (CONST_INT...)))).
822: We want the value of that CONST_INT. */
823: /* Encore compiler hates a newline in a macro arg, it seems. */
824: PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
825: (XEXP (XEXP (value, 0), 0)));
826: PUT_SDB_SCL (C_AUTO);
827: }
828:
829: type = build_pointer_type (TREE_TYPE (decl));
830: }
831: else if (GET_CODE (value) == MEM
832: && GET_CODE (XEXP (value, 0)) == PLUS
833: && GET_CODE (XEXP (XEXP (value, 0), 0)) == REG
834: && GET_CODE (XEXP (XEXP (value, 0), 1)) == CONST_INT)
835: {
836: /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))).
837: We want the value of that CONST_INT. */
838: PUT_SDB_DEF (name);
839: PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET (XEXP (value, 0)));
840: PUT_SDB_SCL (C_AUTO);
841: }
1.1.1.2 root 842: else if (GET_CODE (value) == MEM && GET_CODE (XEXP (value, 0)) == CONST)
843: {
844: /* Handle an obscure case which can arise when optimizing and
845: when there are few available registers. (This is *always*
846: the case for i386/i486 targets). The DECL_RTL looks like
847: (MEM (CONST ...)) even though this variable is a local `auto'
848: or a local `register' variable. In effect, what has happened
849: is that the reload pass has seen that all assignments and
850: references for one such a local variable can be replaced by
851: equivalent assignments and references to some static storage
852: variable, thereby avoiding the need for a register. In such
853: cases we're forced to lie to debuggers and tell them that
854: this variable was itself `static'. */
855: PUT_SDB_DEF (name);
856: PUT_SDB_VAL (XEXP (XEXP (value, 0), 0));
857: PUT_SDB_SCL (C_STAT);
858: }
1.1 root 859: else
860: {
861: /* It is something we don't know how to represent for SDB. */
862: return;
863: }
864: break;
865: }
866: PUT_SDB_TYPE (plain_type (type));
867: PUT_SDB_ENDEF;
868: }
869:
870: /* Output SDB information for a top-level initialized variable
871: that has been delayed. */
872:
873: void
874: sdbout_toplevel_data (decl)
875: tree decl;
876: {
877: tree type = TREE_TYPE (decl);
878:
1.1.1.3 root 879: if (DECL_IGNORED_P (decl))
880: return;
881:
1.1 root 882: if (! (TREE_CODE (decl) == VAR_DECL
883: && GET_CODE (DECL_RTL (decl)) == MEM
884: && DECL_INITIAL (decl)))
885: abort ();
886:
887: PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
888: PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
889: if (TREE_PUBLIC (decl))
890: {
891: PUT_SDB_SCL (C_EXT);
892: }
893: else
894: {
895: PUT_SDB_SCL (C_STAT);
896: }
897: PUT_SDB_TYPE (plain_type (type));
898: PUT_SDB_ENDEF;
899: }
900:
901: #ifdef SDB_ALLOW_FORWARD_REFERENCES
902:
903: /* Machinery to record and output anonymous types. */
904:
905: static tree anonymous_types;
906:
907: static void
908: sdbout_queue_anonymous_type (type)
909: tree type;
910: {
911: anonymous_types = saveable_tree_cons (NULL_TREE, type, anonymous_types);
912: }
913:
914: static void
915: sdbout_dequeue_anonymous_types ()
916: {
917: register tree types, link;
918:
919: while (anonymous_types)
920: {
921: types = nreverse (anonymous_types);
922: anonymous_types = NULL_TREE;
923:
924: for (link = types; link; link = TREE_CHAIN (link))
925: {
926: register tree type = TREE_VALUE (link);
927:
1.1.1.2 root 928: if (type && ! TREE_ASM_WRITTEN (type))
1.1 root 929: sdbout_one_type (type);
930: }
931: }
932: }
933:
934: #endif
935:
936: /* Given a chain of ..._TYPE nodes, all of which have names,
937: output definitions of those names, as typedefs. */
938:
939: void
940: sdbout_types (types)
941: register tree types;
942: {
943: register tree link;
944:
945: for (link = types; link; link = TREE_CHAIN (link))
946: sdbout_one_type (link);
947:
948: #ifdef SDB_ALLOW_FORWARD_REFERENCES
949: sdbout_dequeue_anonymous_types ();
950: #endif
951: }
952:
953: static void
954: sdbout_type (type)
955: tree type;
956: {
957: register tree tem;
958: if (type == error_mark_node)
959: type = integer_type_node;
960: PUT_SDB_TYPE (plain_type (type));
961: }
962:
963: /* Output types of the fields of type TYPE, if they are structs.
964:
965: Formerly did not chase through pointer types, since that could be circular.
966: They must come before TYPE, since forward refs are not allowed.
967: Now [email protected] says to try them. */
968:
969: static void
970: sdbout_field_types (type)
971: tree type;
972: {
973: tree tail;
974: for (tail = TYPE_FIELDS (type); tail; tail = TREE_CHAIN (tail))
975: if (TREE_CODE (TREE_TYPE (tail)) == POINTER_TYPE)
976: sdbout_one_type (TREE_TYPE (TREE_TYPE (tail)));
977: else
978: sdbout_one_type (TREE_TYPE (tail));
979: }
980:
981: /* Use this to put out the top level defined record and union types
982: for later reference. If this is a struct with a name, then put that
983: name out. Other unnamed structs will have .xxfake labels generated so
984: that they may be referred to later.
985: The label will be stored in the KNOWN_TYPE_TAG slot of a type.
986: It may NOT be called recursively. */
987:
988: static void
989: sdbout_one_type (type)
990: tree type;
991: {
992: text_section ();
993:
994: switch (TREE_CODE (type))
995: {
996: case RECORD_TYPE:
997: case UNION_TYPE:
1.1.1.5 ! root 998: case QUAL_UNION_TYPE:
1.1 root 999: case ENUMERAL_TYPE:
1000: type = TYPE_MAIN_VARIANT (type);
1001: /* Don't output a type twice. */
1002: if (TREE_ASM_WRITTEN (type))
1003: /* James said test TREE_ASM_BEING_WRITTEN here. */
1004: return;
1005:
1006: /* Output nothing if type is not yet defined. */
1007: if (TYPE_SIZE (type) == 0)
1008: return;
1009:
1010: TREE_ASM_WRITTEN (type) = 1;
1011: #if 1
1012: /* This is reputed to cause trouble with the following case,
1.1.1.4 root 1013: but perhaps checking TYPE_SIZE above will fix it. */
1.1 root 1014:
1015: /* Here is a test case:
1016:
1017: struct foo {
1018: struct badstr *bbb;
1019: } forwardref;
1020:
1021: typedef struct intermediate {
1022: int aaaa;
1023: } intermediate_ref;
1024:
1025: typedef struct badstr {
1026: int ccccc;
1027: } badtype; */
1028:
1029: #if 0
1030: TREE_ASM_BEING_WRITTEN (type) = 1;
1031: #endif
1032: /* This change, which ought to make better output,
1033: used to make the COFF assembler unhappy.
1034: Changes involving KNOWN_TYPE_TAG may fix the problem. */
1035: /* Before really doing anything, output types we want to refer to. */
1036: /* Note that in version 1 the following two lines
1037: are not used if forward references are in use. */
1038: if (TREE_CODE (type) != ENUMERAL_TYPE)
1039: sdbout_field_types (type);
1040: #if 0
1041: TREE_ASM_WRITTEN (type) = 1;
1042: #endif
1043: #endif
1044:
1045: /* Output a structure type. */
1046: {
1047: int size = int_size_in_bytes (type);
1048: int member_scl;
1049: tree tem;
1050: int i, n_baseclasses = 0;
1051:
1052: /* Record the type tag, but not in its permanent place just yet. */
1053: sdbout_record_type_name (type);
1054:
1055: PUT_SDB_DEF (KNOWN_TYPE_TAG (type));
1056:
1057: switch (TREE_CODE (type))
1058: {
1059: case UNION_TYPE:
1.1.1.5 ! root 1060: case QUAL_UNION_TYPE:
1.1 root 1061: PUT_SDB_SCL (C_UNTAG);
1062: PUT_SDB_TYPE (T_UNION);
1063: member_scl = C_MOU;
1064: break;
1065:
1066: case RECORD_TYPE:
1067: PUT_SDB_SCL (C_STRTAG);
1068: PUT_SDB_TYPE (T_STRUCT);
1069: member_scl = C_MOS;
1070: break;
1071:
1072: case ENUMERAL_TYPE:
1073: PUT_SDB_SCL (C_ENTAG);
1074: PUT_SDB_TYPE (T_ENUM);
1075: member_scl = C_MOE;
1076: break;
1077: }
1078:
1079: PUT_SDB_SIZE (size);
1080: PUT_SDB_ENDEF;
1081:
1082: /* Print out the base class information with fields
1083: named after the types they hold. */
1084: if (TYPE_BINFO (type)
1085: && TYPE_BINFO_BASETYPES (type))
1086: n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
1087: for (i = 0; i < n_baseclasses; i++)
1088: {
1089: tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i);
1090: tree child_type = BINFO_TYPE (child);
1091: tree child_type_name;
1092: if (TYPE_NAME (child_type) == 0)
1093: continue;
1094: if (TREE_CODE (TYPE_NAME (child_type)) == IDENTIFIER_NODE)
1095: child_type_name = TYPE_NAME (child_type);
1096: else if (TREE_CODE (TYPE_NAME (child_type)) == TYPE_DECL)
1097: child_type_name = DECL_NAME (TYPE_NAME (child_type));
1098: else
1099: continue;
1100:
1101: CONTIN;
1102: PUT_SDB_DEF (IDENTIFIER_POINTER (child_type_name));
1103: PUT_SDB_INT_VAL (TREE_INT_CST_LOW (BINFO_OFFSET (child)));
1104: PUT_SDB_SCL (member_scl);
1105: sdbout_type (BINFO_TYPE (child));
1106: PUT_SDB_ENDEF;
1107: }
1108:
1109: /* output the individual fields */
1110:
1111: if (TREE_CODE (type) == ENUMERAL_TYPE)
1112: for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1113: {
1114: PUT_SDB_DEF (IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
1115: PUT_SDB_INT_VAL (TREE_INT_CST_LOW (TREE_VALUE (tem)));
1116: PUT_SDB_SCL (C_MOE);
1117: PUT_SDB_TYPE (T_MOE);
1118: PUT_SDB_ENDEF;
1119: }
1120:
1121: else /* record or union type */
1122: for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1123: /* Output the name, type, position (in bits), size (in bits)
1124: of each field. */
1125:
1126: /* Omit here the nameless fields that are used to skip bits.
1127: Also omit fields with variable size or position.
1128: Also omit non FIELD_DECL nodes that GNU C++ may put here. */
1129: if (TREE_CODE (tem) == FIELD_DECL
1130: && DECL_NAME (tem) != 0
1131: && TREE_CODE (DECL_SIZE (tem)) == INTEGER_CST
1132: && TREE_CODE (DECL_FIELD_BITPOS (tem)) == INTEGER_CST)
1133: {
1134: CONTIN;
1135: PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_NAME (tem)));
1136: if (DECL_BIT_FIELD_TYPE (tem))
1137: {
1138: PUT_SDB_INT_VAL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)));
1139: PUT_SDB_SCL (C_FIELD);
1140: sdbout_type (DECL_BIT_FIELD_TYPE (tem));
1141: PUT_SDB_SIZE (TREE_INT_CST_LOW (DECL_SIZE (tem)));
1142: }
1143: else
1144: {
1145: PUT_SDB_INT_VAL (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem))
1146: / BITS_PER_UNIT);
1147: PUT_SDB_SCL (member_scl);
1148: sdbout_type (TREE_TYPE (tem));
1149: }
1150: PUT_SDB_ENDEF;
1151: }
1152: /* output end of a structure,union, or enumeral definition */
1153:
1154: PUT_SDB_PLAIN_DEF ("eos");
1155: PUT_SDB_INT_VAL (size);
1156: PUT_SDB_SCL (C_EOS);
1157: PUT_SDB_TAG (KNOWN_TYPE_TAG (type));
1158: PUT_SDB_SIZE (size);
1159: PUT_SDB_ENDEF;
1160: break;
1161: }
1162: }
1163: }
1164:
1165: /* The following two functions output definitions of function parameters.
1166: Each parameter gets a definition locating it in the parameter list.
1167: Each parameter that is a register variable gets a second definition
1168: locating it in the register.
1169:
1170: Printing or argument lists in gdb uses the definitions that
1171: locate in the parameter list. But reference to the variable in
1172: expressions uses preferentially the definition as a register. */
1173:
1174: /* Output definitions, referring to storage in the parmlist,
1175: of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
1176:
1177: static void
1178: sdbout_parms (parms)
1179: tree parms;
1180: {
1181: for (; parms; parms = TREE_CHAIN (parms))
1182: if (DECL_NAME (parms))
1183: {
1184: int current_sym_value = 0;
1185: char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
1186:
1187: if (name == 0 || *name == 0)
1188: name = gen_fake_label ();
1189:
1190: /* Perform any necessary register eliminations on the parameter's rtl,
1191: so that the debugging output will be accurate. */
1192: DECL_INCOMING_RTL (parms) =
1.1.1.4 root 1193: eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
1194: DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX);
1.1 root 1195:
1196: if (PARM_PASSED_IN_MEMORY (parms))
1197: {
1198: rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
1199: tree type;
1200:
1201: /* ??? Here we assume that the parm address is indexed
1202: off the frame pointer or arg pointer.
1203: If that is not true, we produce meaningless results,
1204: but do not crash. */
1205: if (GET_CODE (addr) == PLUS
1206: && GET_CODE (XEXP (addr, 1)) == CONST_INT)
1207: current_sym_value = INTVAL (XEXP (addr, 1));
1208: else
1209: current_sym_value = 0;
1210:
1211: if (GET_CODE (DECL_RTL (parms)) == REG
1212: && REGNO (DECL_RTL (parms)) >= 0
1213: && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1214: type = DECL_ARG_TYPE (parms);
1215: else
1216: {
1217: int original_sym_value = current_sym_value;
1218:
1219: /* This is the case where the parm is passed as an int or
1220: double and it is converted to a char, short or float
1221: and stored back in the parmlist. In this case, describe
1222: the parm with the variable's declared type, and adjust
1223: the address if the least significant bytes (which we are
1224: using) are not the first ones. */
1225: #if BYTES_BIG_ENDIAN
1226: if (TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1227: current_sym_value +=
1228: (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1229: - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1230: #endif
1231: if (GET_CODE (DECL_RTL (parms)) == MEM
1232: && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1233: && (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1))
1234: == CONST_INT)
1235: && (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1))
1236: == current_sym_value))
1237: type = TREE_TYPE (parms);
1238: else
1239: {
1240: current_sym_value = original_sym_value;
1241: type = DECL_ARG_TYPE (parms);
1242: }
1243: }
1244:
1245: PUT_SDB_DEF (name);
1246: PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value, addr));
1247: PUT_SDB_SCL (C_ARG);
1248: PUT_SDB_TYPE (plain_type (type));
1249: PUT_SDB_ENDEF;
1250: }
1251: else if (GET_CODE (DECL_RTL (parms)) == REG)
1252: {
1253: rtx best_rtl;
1254: /* Parm passed in registers and lives in registers or nowhere. */
1255:
1256: /* If parm lives in a register, use that register;
1257: pretend the parm was passed there. It would be more consistent
1258: to describe the register where the parm was passed,
1259: but in practice that register usually holds something else. */
1260: if (REGNO (DECL_RTL (parms)) >= 0
1261: && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
1262: best_rtl = DECL_RTL (parms);
1263: /* If the parm lives nowhere,
1264: use the register where it was passed. */
1265: else
1266: best_rtl = DECL_INCOMING_RTL (parms);
1267:
1268: PUT_SDB_DEF (name);
1269: PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (best_rtl)));
1270: PUT_SDB_SCL (C_REGPARM);
1271: PUT_SDB_TYPE (plain_type (TREE_TYPE (parms), 0));
1272: PUT_SDB_ENDEF;
1273: }
1274: else if (GET_CODE (DECL_RTL (parms)) == MEM
1275: && XEXP (DECL_RTL (parms), 0) != const0_rtx)
1276: {
1277: /* Parm was passed in registers but lives on the stack. */
1278:
1279: /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
1280: in which case we want the value of that CONST_INT,
1281: or (MEM (REG ...)) or (MEM (MEM ...)),
1282: in which case we use a value of zero. */
1283: if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
1284: || GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
1285: current_sym_value = 0;
1286: else
1287: current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
1288:
1289: /* Again, this assumes the offset is based on the arg pointer. */
1290: PUT_SDB_DEF (name);
1291: PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value,
1292: XEXP (DECL_RTL (parms), 0)));
1293: PUT_SDB_SCL (C_ARG);
1294: PUT_SDB_TYPE (plain_type (TREE_TYPE (parms), 0));
1295: PUT_SDB_ENDEF;
1296: }
1297: }
1298: }
1299:
1300: /* Output definitions for the places where parms live during the function,
1301: when different from where they were passed, when the parms were passed
1302: in memory.
1303:
1304: It is not useful to do this for parms passed in registers
1305: that live during the function in different registers, because it is
1306: impossible to look in the passed register for the passed value,
1307: so we use the within-the-function register to begin with.
1308:
1309: PARMS is a chain of PARM_DECL nodes. */
1310:
1311: static void
1312: sdbout_reg_parms (parms)
1313: tree parms;
1314: {
1315: for (; parms; parms = TREE_CHAIN (parms))
1316: if (DECL_NAME (parms))
1317: {
1318: char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
1319:
1320: /* Report parms that live in registers during the function
1321: but were passed in memory. */
1322: if (GET_CODE (DECL_RTL (parms)) == REG
1323: && REGNO (DECL_RTL (parms)) >= 0
1324: && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER
1325: && PARM_PASSED_IN_MEMORY (parms))
1326: {
1327: if (name == 0 || *name == 0)
1328: name = gen_fake_label ();
1329: PUT_SDB_DEF (name);
1330: PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms))));
1331: PUT_SDB_SCL (C_REG);
1332: PUT_SDB_TYPE (plain_type (TREE_TYPE (parms), 0));
1333: PUT_SDB_ENDEF;
1334: }
1335: /* Report parms that live in memory but not where they were passed. */
1336: else if (GET_CODE (DECL_RTL (parms)) == MEM
1337: && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
1338: && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
1339: && PARM_PASSED_IN_MEMORY (parms)
1340: && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
1341: {
1342: #if 0 /* ??? It is not clear yet what should replace this. */
1343: int offset = DECL_OFFSET (parms) / BITS_PER_UNIT;
1344: /* A parm declared char is really passed as an int,
1345: so it occupies the least significant bytes.
1346: On a big-endian machine those are not the low-numbered ones. */
1347: #if BYTES_BIG_ENDIAN
1348: if (offset != -1 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
1349: offset += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
1350: - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
1351: #endif
1352: if (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) != offset) {...}
1353: #endif
1354: {
1355: if (name == 0 || *name == 0)
1356: name = gen_fake_label ();
1357: PUT_SDB_DEF (name);
1358: PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
1359: (XEXP (DECL_RTL (parms), 0)));
1360: PUT_SDB_SCL (C_AUTO);
1361: PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
1362: PUT_SDB_ENDEF;
1363: }
1364: }
1365: }
1366: }
1367:
1368: /* Describe the beginning of an internal block within a function.
1369: Also output descriptions of variables defined in this block.
1370:
1371: N is the number of the block, by order of beginning, counting from 1,
1372: and not counting the outermost (function top-level) block.
1373: The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
1374: if the count starts at 0 for the outermost one. */
1375:
1376: void
1377: sdbout_begin_block (file, line, n)
1378: FILE *file;
1379: int line;
1380: int n;
1381: {
1382: tree decl = current_function_decl;
1383: MAKE_LINE_SAFE (line);
1384: PUT_SDB_BLOCK_START (line - sdb_begin_function_line);
1385: if (n == 1)
1386: {
1387: /* Include the outermost BLOCK's variables in block 1. */
1388: next_block_number = 0;
1389: do_block = 0;
1390: sdbout_block (DECL_INITIAL (decl));
1391: }
1392: /* If -g1, suppress all the internal symbols of functions
1393: except for arguments. */
1394: if (debug_info_level != DINFO_LEVEL_TERSE)
1395: {
1396: next_block_number = 0;
1397: do_block = n;
1398: sdbout_block (DECL_INITIAL (decl));
1399: }
1400:
1401: #ifdef SDB_ALLOW_FORWARD_REFERENCES
1402: sdbout_dequeue_anonymous_types ();
1403: #endif
1404: }
1405:
1406: /* Describe the end line-number of an internal block within a function. */
1407:
1408: void
1409: sdbout_end_block (file, line)
1410: FILE *file;
1411: int line;
1412: {
1413: MAKE_LINE_SAFE (line);
1414: PUT_SDB_BLOCK_END (line - sdb_begin_function_line);
1415: }
1416:
1417: /* Output sdb info for the current function name.
1418: Called from assemble_start_function. */
1419:
1420: void
1421: sdbout_mark_begin_function ()
1422: {
1423: sdbout_symbol (current_function_decl, 0);
1424: }
1425:
1426: /* Called at beginning of function body (after prologue).
1427: Record the function's starting line number, so we can output
1428: relative line numbers for the other lines.
1429: Describe beginning of outermost block.
1430: Also describe the parameter list. */
1431:
1432: void
1433: sdbout_begin_function (line)
1434: int line;
1435: {
1436: sdb_begin_function_line = line - 1;
1437: PUT_SDB_FUNCTION_START (line);
1438: sdbout_parms (DECL_ARGUMENTS (current_function_decl));
1439: sdbout_reg_parms (DECL_ARGUMENTS (current_function_decl));
1440: }
1441:
1442: /* Called at end of function (before epilogue).
1443: Describe end of outermost block. */
1444:
1445: void
1446: sdbout_end_function (line)
1447: int line;
1448: {
1449: #ifdef SDB_ALLOW_FORWARD_REFERENCES
1450: sdbout_dequeue_anonymous_types ();
1451: #endif
1452:
1453: MAKE_LINE_SAFE (line);
1454: PUT_SDB_FUNCTION_END (line - sdb_begin_function_line);
1455:
1456: /* Indicate we are between functions, for line-number output. */
1457: sdb_begin_function_line = -1;
1458: }
1459:
1460: /* Output sdb info for the absolute end of a function.
1461: Called after the epilogue is output. */
1462:
1463: void
1464: sdbout_end_epilogue ()
1465: {
1466: char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
1467: PUT_SDB_EPILOGUE_END (name);
1468: }
1469:
1470: /* Output sdb info for the given label. Called only if LABEL_NAME (insn)
1471: is present. */
1472:
1473: void
1474: sdbout_label (insn)
1475: register rtx insn;
1476: {
1477: PUT_SDB_DEF (LABEL_NAME (insn));
1478: PUT_SDB_VAL (insn);
1479: PUT_SDB_SCL (C_LABEL);
1480: PUT_SDB_TYPE (T_NULL);
1481: PUT_SDB_ENDEF;
1482: }
1483:
1484: #endif /* SDB_DEBUGGING_INFO */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.