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