![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dwarfout.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 dwarfout.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* This file contains code written by Ron Guilmette ([email protected]) for
2: Network Computing Devices, August, September, October, November 1990.
3:
4: Output Dwarf format symbol table information from the GNU C compiler.
5: Copyright (C) 1992, 1993 Free Software Foundation, Inc.
6:
7: This file is part of GNU CC.
8:
9: GNU CC is free software; you can redistribute it and/or modify
10: it under the terms of the GNU General Public License as published by
11: the Free Software Foundation; either version 2, or (at your option)
12: any later version.
13:
14: GNU CC is distributed in the hope that it will be useful,
15: but WITHOUT ANY WARRANTY; without even the implied warranty of
16: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17: GNU General Public License for more details.
18:
19: You should have received a copy of the GNU General Public License
20: along with GNU CC; see the file COPYING. If not, write to
21: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
22:
23: #include "config.h"
24:
25: #ifdef DWARF_DEBUGGING_INFO
26: #include <stdio.h>
27: #include "dwarf.h"
28: #include "tree.h"
29: #include "flags.h"
30: #include "rtl.h"
31: #include "hard-reg-set.h"
32: #include "insn-config.h"
33: #include "reload.h"
34: #include "output.h"
35: #include "defaults.h"
36:
37: #ifndef DWARF_VERSION
38: #define DWARF_VERSION 1
39: #endif
40:
41: /* #define NDEBUG 1 */
42: #include "assert.h"
43:
44: #if defined(DWARF_TIMESTAMPS)
45: #if defined(POSIX)
46: #include <time.h>
47: #else /* !defined(POSIX) */
48: #include <sys/types.h>
49: #if defined(__STDC__)
50: extern time_t time (time_t *);
51: #else /* !defined(__STDC__) */
52: extern time_t time ();
53: #endif /* !defined(__STDC__) */
54: #endif /* !defined(POSIX) */
55: #endif /* defined(DWARF_TIMESTAMPS) */
56:
57: extern char *getpwd ();
58:
59: extern char *index ();
60: extern char *rindex ();
61:
62: /* IMPORTANT NOTE: Please see the file README.DWARF for important details
63: regarding the GNU implementation of Dwarf. */
64:
65: /* NOTE: In the comments in this file, many references are made to
66: so called "Debugging Information Entries". For the sake of brevity,
67: this term is abbreviated to `DIE' throughout the remainder of this
68: file. */
69:
70: /* Note that the implementation of C++ support herein is (as yet) unfinished.
71: If you want to try to complete it, more power to you. */
72:
73: #if defined(__GNUC__) && (NDEBUG == 1)
74: #define inline static inline
75: #else
76: #define inline static
77: #endif
78:
79: /* How to start an assembler comment. */
80: #ifndef ASM_COMMENT_START
81: #define ASM_COMMENT_START ";#"
82: #endif
83:
84: /* How to print out a register name. */
85: #ifndef PRINT_REG
86: #define PRINT_REG(RTX, CODE, FILE) \
87: fprintf ((FILE), "%s", reg_names[REGNO (RTX)])
88: #endif
89:
90: /* Define a macro which returns non-zero for any tagged type which is
91: used (directly or indirectly) in the specification of either some
92: function's return type or some formal parameter of some function.
93: We use this macro when we are operating in "terse" mode to help us
94: know what tagged types have to be represented in Dwarf (even in
95: terse mode) and which ones don't.
96:
97: A flag bit with this meaning really should be a part of the normal
98: GCC ..._TYPE nodes, but at the moment, there is no such bit defined
99: for these nodes. For now, we have to just fake it. It it safe for
100: us to simply return zero for all complete tagged types (which will
101: get forced out anyway if they were used in the specification of some
102: formal or return type) and non-zero for all incomplete tagged types.
103: */
104:
105: #define TYPE_USED_FOR_FUNCTION(tagged_type) (TYPE_SIZE (tagged_type) == 0)
106:
107: extern int flag_traditional;
108: extern char *version_string;
109: extern char *language_string;
110:
111: /* Maximum size (in bytes) of an artificially generated label. */
112:
113: #define MAX_ARTIFICIAL_LABEL_BYTES 30
114:
115: /* Make sure we know the sizes of the various types dwarf can describe.
116: These are only defaults. If the sizes are different for your target,
117: you should override these values by defining the appropriate symbols
118: in your tm.h file. */
119:
120: #ifndef CHAR_TYPE_SIZE
121: #define CHAR_TYPE_SIZE BITS_PER_UNIT
122: #endif
123:
124: #ifndef SHORT_TYPE_SIZE
125: #define SHORT_TYPE_SIZE (BITS_PER_UNIT * 2)
126: #endif
127:
128: #ifndef INT_TYPE_SIZE
129: #define INT_TYPE_SIZE BITS_PER_WORD
130: #endif
131:
132: #ifndef LONG_TYPE_SIZE
133: #define LONG_TYPE_SIZE BITS_PER_WORD
134: #endif
135:
136: #ifndef LONG_LONG_TYPE_SIZE
137: #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2)
138: #endif
139:
140: #ifndef WCHAR_TYPE_SIZE
141: #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
142: #endif
143:
144: #ifndef WCHAR_UNSIGNED
145: #define WCHAR_UNSIGNED 0
146: #endif
147:
148: #ifndef FLOAT_TYPE_SIZE
149: #define FLOAT_TYPE_SIZE BITS_PER_WORD
150: #endif
151:
152: #ifndef DOUBLE_TYPE_SIZE
153: #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
154: #endif
155:
156: #ifndef LONG_DOUBLE_TYPE_SIZE
157: #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2)
158: #endif
159:
160: /* Structure to keep track of source filenames. */
161:
162: struct filename_entry {
163: unsigned number;
164: char * name;
165: };
166:
167: typedef struct filename_entry filename_entry;
168:
169: /* Pointer to an array of elements, each one having the structure above. */
170:
171: static filename_entry *filename_table;
172:
173: /* Total number of entries in the table (i.e. array) pointed to by
174: `filename_table'. This is the *total* and includes both used and
175: unused slots. */
176:
177: static unsigned ft_entries_allocated;
178:
179: /* Number of entries in the filename_table which are actually in use. */
180:
181: static unsigned ft_entries;
182:
183: /* Size (in elements) of increments by which we may expand the filename
184: table. Actually, a single hunk of space of this size should be enough
185: for most typical programs. */
186:
187: #define FT_ENTRIES_INCREMENT 64
188:
189: /* Local pointer to the name of the main input file. Initialized in
190: dwarfout_init. */
191:
192: static char *primary_filename;
193:
194: /* Pointer to the most recent filename for which we produced some line info. */
195:
196: static char *last_filename;
197:
198: /* For Dwarf output, we must assign lexical-blocks id numbers
199: in the order in which their beginnings are encountered.
200: We output Dwarf debugging info that refers to the beginnings
201: and ends of the ranges of code for each lexical block with
202: assembler labels ..Bn and ..Bn.e, where n is the block number.
203: The labels themselves are generated in final.c, which assigns
204: numbers to the blocks in the same way. */
205:
206: static unsigned next_block_number = 2;
207:
208: /* Counter to generate unique names for DIEs. */
209:
210: static unsigned next_unused_dienum = 1;
211:
212: /* Number of the DIE which is currently being generated. */
213:
214: static unsigned current_dienum;
215:
216: /* Number to use for the special "pubname" label on the next DIE which
217: represents a function or data object defined in this compilation
218: unit which has "extern" linkage. */
219:
220: static next_pubname_number = 0;
221:
222: #define NEXT_DIE_NUM pending_sibling_stack[pending_siblings-1]
223:
224: /* Pointer to a dynamically allocated list of pre-reserved and still
225: pending sibling DIE numbers. Note that this list will grow as needed. */
226:
227: static unsigned *pending_sibling_stack;
228:
229: /* Counter to keep track of the number of pre-reserved and still pending
230: sibling DIE numbers. */
231:
232: static unsigned pending_siblings;
233:
234: /* The currently allocated size of the above list (expressed in number of
235: list elements). */
236:
237: static unsigned pending_siblings_allocated;
238:
239: /* Size (in elements) of increments by which we may expand the pending
240: sibling stack. Actually, a single hunk of space of this size should
241: be enough for most typical programs. */
242:
243: #define PENDING_SIBLINGS_INCREMENT 64
244:
245: /* Non-zero if we are performing our file-scope finalization pass and if
246: we should force out Dwarf descriptions of any and all file-scope
247: tagged types which are still incomplete types. */
248:
249: static int finalizing = 0;
250:
251: /* A pointer to the base of a list of pending types which we haven't
252: generated DIEs for yet, but which we will have to come back to
253: later on. */
254:
255: static tree *pending_types_list;
256:
257: /* Number of elements currently allocated for the pending_types_list. */
258:
259: static unsigned pending_types_allocated;
260:
261: /* Number of elements of pending_types_list currently in use. */
262:
263: static unsigned pending_types;
264:
265: /* Size (in elements) of increments by which we may expand the pending
266: types list. Actually, a single hunk of space of this size should
267: be enough for most typical programs. */
268:
269: #define PENDING_TYPES_INCREMENT 64
270:
271: /* Pointer to an artificial RECORD_TYPE which we create in dwarfout_init.
272: This is used in a hack to help us get the DIEs describing types of
273: formal parameters to come *after* all of the DIEs describing the formal
274: parameters themselves. That's necessary in order to be compatible
275: with what the brain-damaged svr4 SDB debugger requires. */
276:
277: static tree fake_containing_scope;
278:
279: /* The number of the current function definition that we are generating
280: debugging information for. These numbers range from 1 up to the maximum
281: number of function definitions contained within the current compilation
282: unit. These numbers are used to create unique labels for various things
283: contained within various function definitions. */
284:
285: static unsigned current_funcdef_number = 1;
286:
287: /* A pointer to the ..._DECL node which we have most recently been working
288: on. We keep this around just in case something about it looks screwy
289: and we want to tell the user what the source coordinates for the actual
290: declaration are. */
291:
292: static tree dwarf_last_decl;
293:
294: /* Forward declarations for functions defined in this file. */
295:
296: static void output_type ();
297: static void type_attribute ();
298: static void output_decls_for_scope ();
299: static void output_decl ();
300: static unsigned lookup_filename ();
301:
302: /* Definitions of defaults for assembler-dependent names of various
303: pseudo-ops and section names.
304:
305: Theses may be overridden in your tm.h file (if necessary) for your
306: particular assembler. The default values provided here correspond to
307: what is expected by "standard" AT&T System V.4 assemblers. */
308:
309: #ifndef FILE_ASM_OP
310: #define FILE_ASM_OP ".file"
311: #endif
312: #ifndef VERSION_ASM_OP
313: #define VERSION_ASM_OP ".version"
314: #endif
315: #ifndef UNALIGNED_SHORT_ASM_OP
316: #define UNALIGNED_SHORT_ASM_OP ".2byte"
317: #endif
318: #ifndef UNALIGNED_INT_ASM_OP
319: #define UNALIGNED_INT_ASM_OP ".4byte"
320: #endif
321: #ifndef ASM_BYTE_OP
322: #define ASM_BYTE_OP ".byte"
323: #endif
324: #ifndef SET_ASM_OP
325: #define SET_ASM_OP ".set"
326: #endif
327:
328: /* Pseudo-ops for pushing the current section onto the section stack (and
329: simultaneously changing to a new section) and for poping back to the
330: section we were in immediately before this one. Note that most svr4
331: assemblers only maintain a one level stack... you can push all the
332: sections you want, but you can only pop out one level. (The sparc
333: svr4 assembler is an exception to this general rule.) That's
334: OK because we only use at most one level of the section stack herein. */
335:
336: #ifndef PUSHSECTION_ASM_OP
337: #define PUSHSECTION_ASM_OP ".section"
338: #endif
339: #ifndef POPSECTION_ASM_OP
340: #define POPSECTION_ASM_OP ".previous"
341: #endif
342:
343: /* The default format used by the ASM_OUTPUT_PUSH_SECTION macro (see below)
344: to print the PUSHSECTION_ASM_OP and the section name. The default here
345: works for almost all svr4 assemblers, except for the sparc, where the
346: section name must be enclosed in double quotes. (See sparcv4.h.) */
347:
348: #ifndef PUSHSECTION_FORMAT
349: #define PUSHSECTION_FORMAT "%s\t%s\n"
350: #endif
351:
352: #ifndef DEBUG_SECTION
353: #define DEBUG_SECTION ".debug"
354: #endif
355: #ifndef LINE_SECTION
356: #define LINE_SECTION ".line"
357: #endif
358: #ifndef SFNAMES_SECTION
359: #define SFNAMES_SECTION ".debug_sfnames"
360: #endif
361: #ifndef SRCINFO_SECTION
362: #define SRCINFO_SECTION ".debug_srcinfo"
363: #endif
364: #ifndef MACINFO_SECTION
365: #define MACINFO_SECTION ".debug_macinfo"
366: #endif
367: #ifndef PUBNAMES_SECTION
368: #define PUBNAMES_SECTION ".debug_pubnames"
369: #endif
370: #ifndef ARANGES_SECTION
371: #define ARANGES_SECTION ".debug_aranges"
372: #endif
373: #ifndef TEXT_SECTION
374: #define TEXT_SECTION ".text"
375: #endif
376: #ifndef DATA_SECTION
377: #define DATA_SECTION ".data"
378: #endif
379: #ifndef DATA1_SECTION
380: #define DATA1_SECTION ".data1"
381: #endif
382: #ifndef RODATA_SECTION
383: #define RODATA_SECTION ".rodata"
384: #endif
385: #ifndef RODATA1_SECTION
386: #define RODATA1_SECTION ".rodata1"
387: #endif
388: #ifndef BSS_SECTION
389: #define BSS_SECTION ".bss"
390: #endif
391:
392: /* Definitions of defaults for formats and names of various special
393: (artificial) labels which may be generated within this file (when
394: the -g options is used and DWARF_DEBUGGING_INFO is in effect.
395:
396: If necessary, these may be overridden from within your tm.h file,
397: but typically, you should never need to override these.
398:
399: These labels have been hacked (temporarily) so that they all begin with
400: a `.L' sequence so as to appease the stock sparc/svr4 assembler and the
401: stock m88k/svr4 assembler, both of which need to see .L at the start of
402: a label in order to prevent that label from going into the linker symbol
403: table). When I get time, I'll have to fix this the right way so that we
404: will use ASM_GENERATE_INTERNAL_LABEL and ASM_OUTPUT_INTERNAL_LABEL herein,
405: but that will require a rather massive set of changes. For the moment,
406: the following definitions out to produce the right results for all svr4
407: and svr3 assemblers. -- rfg
408: */
409:
410: #ifndef TEXT_BEGIN_LABEL
411: #define TEXT_BEGIN_LABEL ".L_text_b"
412: #endif
413: #ifndef TEXT_END_LABEL
414: #define TEXT_END_LABEL ".L_text_e"
415: #endif
416:
417: #ifndef DATA_BEGIN_LABEL
418: #define DATA_BEGIN_LABEL ".L_data_b"
419: #endif
420: #ifndef DATA_END_LABEL
421: #define DATA_END_LABEL ".L_data_e"
422: #endif
423:
424: #ifndef DATA1_BEGIN_LABEL
425: #define DATA1_BEGIN_LABEL ".L_data1_b"
426: #endif
427: #ifndef DATA1_END_LABEL
428: #define DATA1_END_LABEL ".L_data1_e"
429: #endif
430:
431: #ifndef RODATA_BEGIN_LABEL
432: #define RODATA_BEGIN_LABEL ".L_rodata_b"
433: #endif
434: #ifndef RODATA_END_LABEL
435: #define RODATA_END_LABEL ".L_rodata_e"
436: #endif
437:
438: #ifndef RODATA1_BEGIN_LABEL
439: #define RODATA1_BEGIN_LABEL ".L_rodata1_b"
440: #endif
441: #ifndef RODATA1_END_LABEL
442: #define RODATA1_END_LABEL ".L_rodata1_e"
443: #endif
444:
445: #ifndef BSS_BEGIN_LABEL
446: #define BSS_BEGIN_LABEL ".L_bss_b"
447: #endif
448: #ifndef BSS_END_LABEL
449: #define BSS_END_LABEL ".L_bss_e"
450: #endif
451:
452: #ifndef LINE_BEGIN_LABEL
453: #define LINE_BEGIN_LABEL ".L_line_b"
454: #endif
455: #ifndef LINE_LAST_ENTRY_LABEL
456: #define LINE_LAST_ENTRY_LABEL ".L_line_last"
457: #endif
458: #ifndef LINE_END_LABEL
459: #define LINE_END_LABEL ".L_line_e"
460: #endif
461:
462: #ifndef DEBUG_BEGIN_LABEL
463: #define DEBUG_BEGIN_LABEL ".L_debug_b"
464: #endif
465: #ifndef SFNAMES_BEGIN_LABEL
466: #define SFNAMES_BEGIN_LABEL ".L_sfnames_b"
467: #endif
468: #ifndef SRCINFO_BEGIN_LABEL
469: #define SRCINFO_BEGIN_LABEL ".L_srcinfo_b"
470: #endif
471: #ifndef MACINFO_BEGIN_LABEL
472: #define MACINFO_BEGIN_LABEL ".L_macinfo_b"
473: #endif
474:
475: #ifndef DIE_BEGIN_LABEL_FMT
476: #define DIE_BEGIN_LABEL_FMT ".L_D%u"
477: #endif
478: #ifndef DIE_END_LABEL_FMT
479: #define DIE_END_LABEL_FMT ".L_D%u_e"
480: #endif
481: #ifndef PUB_DIE_LABEL_FMT
482: #define PUB_DIE_LABEL_FMT ".L_P%u"
483: #endif
484: #ifndef INSN_LABEL_FMT
485: #define INSN_LABEL_FMT ".L_I%u_%u"
486: #endif
487: #ifndef BLOCK_BEGIN_LABEL_FMT
488: #define BLOCK_BEGIN_LABEL_FMT ".L_B%u"
489: #endif
490: #ifndef BLOCK_END_LABEL_FMT
491: #define BLOCK_END_LABEL_FMT ".L_B%u_e"
492: #endif
493: #ifndef SS_BEGIN_LABEL_FMT
494: #define SS_BEGIN_LABEL_FMT ".L_s%u"
495: #endif
496: #ifndef SS_END_LABEL_FMT
497: #define SS_END_LABEL_FMT ".L_s%u_e"
498: #endif
499: #ifndef EE_BEGIN_LABEL_FMT
500: #define EE_BEGIN_LABEL_FMT ".L_e%u"
501: #endif
502: #ifndef EE_END_LABEL_FMT
503: #define EE_END_LABEL_FMT ".L_e%u_e"
504: #endif
505: #ifndef MT_BEGIN_LABEL_FMT
506: #define MT_BEGIN_LABEL_FMT ".L_t%u"
507: #endif
508: #ifndef MT_END_LABEL_FMT
509: #define MT_END_LABEL_FMT ".L_t%u_e"
510: #endif
511: #ifndef LOC_BEGIN_LABEL_FMT
512: #define LOC_BEGIN_LABEL_FMT ".L_l%u"
513: #endif
514: #ifndef LOC_END_LABEL_FMT
515: #define LOC_END_LABEL_FMT ".L_l%u_e"
516: #endif
517: #ifndef BOUND_BEGIN_LABEL_FMT
518: #define BOUND_BEGIN_LABEL_FMT ".L_b%u_%u_%c"
519: #endif
520: #ifndef BOUND_END_LABEL_FMT
521: #define BOUND_END_LABEL_FMT ".L_b%u_%u_%c_e"
522: #endif
523: #ifndef DERIV_BEGIN_LABEL_FMT
524: #define DERIV_BEGIN_LABEL_FMT ".L_d%u"
525: #endif
526: #ifndef DERIV_END_LABEL_FMT
527: #define DERIV_END_LABEL_FMT ".L_d%u_e"
528: #endif
529: #ifndef SL_BEGIN_LABEL_FMT
530: #define SL_BEGIN_LABEL_FMT ".L_sl%u"
531: #endif
532: #ifndef SL_END_LABEL_FMT
533: #define SL_END_LABEL_FMT ".L_sl%u_e"
534: #endif
535: #ifndef BODY_BEGIN_LABEL_FMT
536: #define BODY_BEGIN_LABEL_FMT ".L_b%u"
537: #endif
538: #ifndef BODY_END_LABEL_FMT
539: #define BODY_END_LABEL_FMT ".L_b%u_e"
540: #endif
541: #ifndef FUNC_END_LABEL_FMT
542: #define FUNC_END_LABEL_FMT ".L_f%u_e"
543: #endif
544: #ifndef TYPE_NAME_FMT
545: #define TYPE_NAME_FMT ".L_T%u"
546: #endif
547: #ifndef DECL_NAME_FMT
548: #define DECL_NAME_FMT ".L_E%u"
549: #endif
550: #ifndef LINE_CODE_LABEL_FMT
551: #define LINE_CODE_LABEL_FMT ".L_LC%u"
552: #endif
553: #ifndef SFNAMES_ENTRY_LABEL_FMT
554: #define SFNAMES_ENTRY_LABEL_FMT ".L_F%u"
555: #endif
556: #ifndef LINE_ENTRY_LABEL_FMT
557: #define LINE_ENTRY_LABEL_FMT ".L_LE%u"
558: #endif
559:
560: /* Definitions of defaults for various types of primitive assembly language
561: output operations.
562:
563: If necessary, these may be overridden from within your tm.h file,
564: but typically, you shouldn't need to override these. One known
565: exception is ASM_OUTPUT_DEF which has to be different for stock
566: sparc/svr4 assemblers.
567: */
568:
569: #ifndef ASM_OUTPUT_PUSH_SECTION
570: #define ASM_OUTPUT_PUSH_SECTION(FILE, SECTION) \
571: fprintf ((FILE), PUSHSECTION_FORMAT, PUSHSECTION_ASM_OP, SECTION)
572: #endif
573:
574: #ifndef ASM_OUTPUT_POP_SECTION
575: #define ASM_OUTPUT_POP_SECTION(FILE) \
576: fprintf ((FILE), "\t%s\n", POPSECTION_ASM_OP)
577: #endif
578:
579: #ifndef ASM_OUTPUT_SOURCE_FILENAME
580: #define ASM_OUTPUT_SOURCE_FILENAME(FILE,NAME) \
581: do { fprintf (FILE, "\t%s\t", FILE_ASM_OP); \
582: output_quoted_string (FILE, NAME); \
583: fputc ('\n', FILE); \
584: } while (0)
585: #endif
586:
587: #ifndef ASM_OUTPUT_DEF
588: #define ASM_OUTPUT_DEF(FILE,LABEL1,LABEL2) \
589: do { fprintf ((FILE), "\t%s\t", SET_ASM_OP); \
590: assemble_name (FILE, LABEL1); \
591: fprintf (FILE, ","); \
592: assemble_name (FILE, LABEL2); \
593: fprintf (FILE, "\n"); \
594: } while (0)
595: #endif
596:
597: #ifndef ASM_OUTPUT_DWARF_DELTA2
598: #define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
599: do { fprintf ((FILE), "\t%s\t", UNALIGNED_SHORT_ASM_OP); \
600: assemble_name (FILE, LABEL1); \
601: fprintf (FILE, "-"); \
602: assemble_name (FILE, LABEL2); \
603: fprintf (FILE, "\n"); \
604: } while (0)
605: #endif
606:
607: #ifndef ASM_OUTPUT_DWARF_DELTA4
608: #define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
609: do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
610: assemble_name (FILE, LABEL1); \
611: fprintf (FILE, "-"); \
612: assemble_name (FILE, LABEL2); \
613: fprintf (FILE, "\n"); \
614: } while (0)
615: #endif
616:
617: #ifndef ASM_OUTPUT_DWARF_TAG
618: #define ASM_OUTPUT_DWARF_TAG(FILE,TAG) \
619: do { \
620: fprintf ((FILE), "\t%s\t0x%x", \
621: UNALIGNED_SHORT_ASM_OP, (unsigned) TAG); \
622: if (flag_verbose_asm) \
623: fprintf ((FILE), "\t%s %s", \
624: ASM_COMMENT_START, dwarf_tag_name (TAG)); \
625: fputc ('\n', (FILE)); \
626: } while (0)
627: #endif
628:
629: #ifndef ASM_OUTPUT_DWARF_ATTRIBUTE
630: #define ASM_OUTPUT_DWARF_ATTRIBUTE(FILE,ATTR) \
631: do { \
632: fprintf ((FILE), "\t%s\t0x%x", \
633: UNALIGNED_SHORT_ASM_OP, (unsigned) ATTR); \
634: if (flag_verbose_asm) \
635: fprintf ((FILE), "\t%s %s", \
636: ASM_COMMENT_START, dwarf_attr_name (ATTR)); \
637: fputc ('\n', (FILE)); \
638: } while (0)
639: #endif
640:
641: #ifndef ASM_OUTPUT_DWARF_STACK_OP
642: #define ASM_OUTPUT_DWARF_STACK_OP(FILE,OP) \
643: do { \
644: fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) OP); \
645: if (flag_verbose_asm) \
646: fprintf ((FILE), "\t%s %s", \
647: ASM_COMMENT_START, dwarf_stack_op_name (OP)); \
648: fputc ('\n', (FILE)); \
649: } while (0)
650: #endif
651:
652: #ifndef ASM_OUTPUT_DWARF_FUND_TYPE
653: #define ASM_OUTPUT_DWARF_FUND_TYPE(FILE,FT) \
654: do { \
655: fprintf ((FILE), "\t%s\t0x%x", \
656: UNALIGNED_SHORT_ASM_OP, (unsigned) FT); \
657: if (flag_verbose_asm) \
658: fprintf ((FILE), "\t%s %s", \
659: ASM_COMMENT_START, dwarf_fund_type_name (FT)); \
660: fputc ('\n', (FILE)); \
661: } while (0)
662: #endif
663:
664: #ifndef ASM_OUTPUT_DWARF_FMT_BYTE
665: #define ASM_OUTPUT_DWARF_FMT_BYTE(FILE,FMT) \
666: do { \
667: fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) FMT); \
668: if (flag_verbose_asm) \
669: fprintf ((FILE), "\t%s %s", \
670: ASM_COMMENT_START, dwarf_fmt_byte_name (FMT)); \
671: fputc ('\n', (FILE)); \
672: } while (0)
673: #endif
674:
675: #ifndef ASM_OUTPUT_DWARF_TYPE_MODIFIER
676: #define ASM_OUTPUT_DWARF_TYPE_MODIFIER(FILE,MOD) \
677: do { \
678: fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) MOD); \
679: if (flag_verbose_asm) \
680: fprintf ((FILE), "\t%s %s", \
681: ASM_COMMENT_START, dwarf_typemod_name (MOD)); \
682: fputc ('\n', (FILE)); \
683: } while (0)
684: #endif
685:
686: #ifndef ASM_OUTPUT_DWARF_ADDR
687: #define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
688: do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
689: assemble_name (FILE, LABEL); \
690: fprintf (FILE, "\n"); \
691: } while (0)
692: #endif
693:
694: #ifndef ASM_OUTPUT_DWARF_ADDR_CONST
695: #define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,RTX) \
696: do { \
697: fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
698: output_addr_const ((FILE), (RTX)); \
699: fputc ('\n', (FILE)); \
700: } while (0)
701: #endif
702:
703: #ifndef ASM_OUTPUT_DWARF_REF
704: #define ASM_OUTPUT_DWARF_REF(FILE,LABEL) \
705: do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
706: assemble_name (FILE, LABEL); \
707: fprintf (FILE, "\n"); \
708: } while (0)
709: #endif
710:
711: #ifndef ASM_OUTPUT_DWARF_DATA1
712: #define ASM_OUTPUT_DWARF_DATA1(FILE,VALUE) \
713: fprintf ((FILE), "\t%s\t0x%x\n", ASM_BYTE_OP, VALUE)
714: #endif
715:
716: #ifndef ASM_OUTPUT_DWARF_DATA2
717: #define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \
718: fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_SHORT_ASM_OP, (unsigned) VALUE)
719: #endif
720:
721: #ifndef ASM_OUTPUT_DWARF_DATA4
722: #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
723: fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, (unsigned) VALUE)
724: #endif
725:
726: #ifndef ASM_OUTPUT_DWARF_DATA8
727: #define ASM_OUTPUT_DWARF_DATA8(FILE,HIGH_VALUE,LOW_VALUE) \
728: do { \
729: if (WORDS_BIG_ENDIAN) \
730: { \
731: fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, HIGH_VALUE); \
732: fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, LOW_VALUE);\
733: } \
734: else \
735: { \
736: fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, LOW_VALUE);\
737: fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, HIGH_VALUE); \
738: } \
739: } while (0)
740: #endif
741:
742: #ifndef ASM_OUTPUT_DWARF_STRING
743: #define ASM_OUTPUT_DWARF_STRING(FILE,P) \
744: ASM_OUTPUT_ASCII ((FILE), P, strlen (P)+1)
745: #endif
746:
747: /************************ general utility functions **************************/
748:
749: inline char *
750: xstrdup (s)
751: register char *s;
752: {
753: register char *p = (char *) xmalloc (strlen (s) + 1);
754:
755: strcpy (p, s);
756: return p;
757: }
758:
759: inline int
760: is_pseudo_reg (rtl)
761: register rtx rtl;
762: {
763: return (((GET_CODE (rtl) == REG) && (REGNO (rtl) >= FIRST_PSEUDO_REGISTER))
764: || ((GET_CODE (rtl) == SUBREG)
765: && (REGNO (XEXP (rtl, 0)) >= FIRST_PSEUDO_REGISTER)));
766: }
767:
768: inline tree
769: type_main_variant (type)
770: register tree type;
771: {
772: type = TYPE_MAIN_VARIANT (type);
773:
774: /* There really should be only one main variant among any group of variants
775: of a given type (and all of the MAIN_VARIANT values for all members of
776: the group should point to that one type) but sometimes the C front-end
777: messes this up for array types, so we work around that bug here. */
778:
779: if (TREE_CODE (type) == ARRAY_TYPE)
780: {
781: while (type != TYPE_MAIN_VARIANT (type))
782: type = TYPE_MAIN_VARIANT (type);
783: }
784:
785: return type;
786: }
787:
788: /* Return non-zero if the given type node represents a tagged type. */
789:
790: inline int
791: is_tagged_type (type)
792: register tree type;
793: {
794: register enum tree_code code = TREE_CODE (type);
795:
796: return (code == RECORD_TYPE || code == UNION_TYPE
797: || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
798: }
799:
800: static char *
801: dwarf_tag_name (tag)
802: register unsigned tag;
803: {
804: switch (tag)
805: {
806: case TAG_padding: return "TAG_padding";
807: case TAG_array_type: return "TAG_array_type";
808: case TAG_class_type: return "TAG_class_type";
809: case TAG_entry_point: return "TAG_entry_point";
810: case TAG_enumeration_type: return "TAG_enumeration_type";
811: case TAG_formal_parameter: return "TAG_formal_parameter";
812: case TAG_global_subroutine: return "TAG_global_subroutine";
813: case TAG_global_variable: return "TAG_global_variable";
814: case TAG_label: return "TAG_label";
815: case TAG_lexical_block: return "TAG_lexical_block";
816: case TAG_local_variable: return "TAG_local_variable";
817: case TAG_member: return "TAG_member";
818: case TAG_pointer_type: return "TAG_pointer_type";
819: case TAG_reference_type: return "TAG_reference_type";
820: case TAG_compile_unit: return "TAG_compile_unit";
821: case TAG_string_type: return "TAG_string_type";
822: case TAG_structure_type: return "TAG_structure_type";
823: case TAG_subroutine: return "TAG_subroutine";
824: case TAG_subroutine_type: return "TAG_subroutine_type";
825: case TAG_typedef: return "TAG_typedef";
826: case TAG_union_type: return "TAG_union_type";
827: case TAG_unspecified_parameters: return "TAG_unspecified_parameters";
828: case TAG_variant: return "TAG_variant";
829: case TAG_common_block: return "TAG_common_block";
830: case TAG_common_inclusion: return "TAG_common_inclusion";
831: case TAG_inheritance: return "TAG_inheritance";
832: case TAG_inlined_subroutine: return "TAG_inlined_subroutine";
833: case TAG_module: return "TAG_module";
834: case TAG_ptr_to_member_type: return "TAG_ptr_to_member_type";
835: case TAG_set_type: return "TAG_set_type";
836: case TAG_subrange_type: return "TAG_subrange_type";
837: case TAG_with_stmt: return "TAG_with_stmt";
838:
839: /* GNU extensions. */
840:
841: case TAG_format_label: return "TAG_format_label";
842: case TAG_namelist: return "TAG_namelist";
843: case TAG_function_template: return "TAG_function_template";
844: case TAG_class_template: return "TAG_class_template";
845:
846: default: return "TAG_<unknown>";
847: }
848: }
849:
850: static char *
851: dwarf_attr_name (attr)
852: register unsigned attr;
853: {
854: switch (attr)
855: {
856: case AT_sibling: return "AT_sibling";
857: case AT_location: return "AT_location";
858: case AT_name: return "AT_name";
859: case AT_fund_type: return "AT_fund_type";
860: case AT_mod_fund_type: return "AT_mod_fund_type";
861: case AT_user_def_type: return "AT_user_def_type";
862: case AT_mod_u_d_type: return "AT_mod_u_d_type";
863: case AT_ordering: return "AT_ordering";
864: case AT_subscr_data: return "AT_subscr_data";
865: case AT_byte_size: return "AT_byte_size";
866: case AT_bit_offset: return "AT_bit_offset";
867: case AT_bit_size: return "AT_bit_size";
868: case AT_element_list: return "AT_element_list";
869: case AT_stmt_list: return "AT_stmt_list";
870: case AT_low_pc: return "AT_low_pc";
871: case AT_high_pc: return "AT_high_pc";
872: case AT_language: return "AT_language";
873: case AT_member: return "AT_member";
874: case AT_discr: return "AT_discr";
875: case AT_discr_value: return "AT_discr_value";
876: case AT_string_length: return "AT_string_length";
877: case AT_common_reference: return "AT_common_reference";
878: case AT_comp_dir: return "AT_comp_dir";
879: case AT_const_value_string: return "AT_const_value_string";
880: case AT_const_value_data2: return "AT_const_value_data2";
881: case AT_const_value_data4: return "AT_const_value_data4";
882: case AT_const_value_data8: return "AT_const_value_data8";
883: case AT_const_value_block2: return "AT_const_value_block2";
884: case AT_const_value_block4: return "AT_const_value_block4";
885: case AT_containing_type: return "AT_containing_type";
886: case AT_default_value_addr: return "AT_default_value_addr";
887: case AT_default_value_data2: return "AT_default_value_data2";
888: case AT_default_value_data4: return "AT_default_value_data4";
889: case AT_default_value_data8: return "AT_default_value_data8";
890: case AT_default_value_string: return "AT_default_value_string";
891: case AT_friends: return "AT_friends";
892: case AT_inline: return "AT_inline";
893: case AT_is_optional: return "AT_is_optional";
894: case AT_lower_bound_ref: return "AT_lower_bound_ref";
895: case AT_lower_bound_data2: return "AT_lower_bound_data2";
896: case AT_lower_bound_data4: return "AT_lower_bound_data4";
897: case AT_lower_bound_data8: return "AT_lower_bound_data8";
898: case AT_private: return "AT_private";
899: case AT_producer: return "AT_producer";
900: case AT_program: return "AT_program";
901: case AT_protected: return "AT_protected";
902: case AT_prototyped: return "AT_prototyped";
903: case AT_public: return "AT_public";
904: case AT_pure_virtual: return "AT_pure_virtual";
905: case AT_return_addr: return "AT_return_addr";
906: case AT_abstract_origin: return "AT_abstract_origin";
907: case AT_start_scope: return "AT_start_scope";
908: case AT_stride_size: return "AT_stride_size";
909: case AT_upper_bound_ref: return "AT_upper_bound_ref";
910: case AT_upper_bound_data2: return "AT_upper_bound_data2";
911: case AT_upper_bound_data4: return "AT_upper_bound_data4";
912: case AT_upper_bound_data8: return "AT_upper_bound_data8";
913: case AT_virtual: return "AT_virtual";
914:
915: /* GNU extensions */
916:
917: case AT_sf_names: return "AT_sf_names";
918: case AT_src_info: return "AT_src_info";
919: case AT_mac_info: return "AT_mac_info";
920: case AT_src_coords: return "AT_src_coords";
921: case AT_body_begin: return "AT_body_begin";
922: case AT_body_end: return "AT_body_end";
923:
924: default: return "AT_<unknown>";
925: }
926: }
927:
928: static char *
929: dwarf_stack_op_name (op)
930: register unsigned op;
931: {
932: switch (op)
933: {
934: case OP_REG: return "OP_REG";
935: case OP_BASEREG: return "OP_BASEREG";
936: case OP_ADDR: return "OP_ADDR";
937: case OP_CONST: return "OP_CONST";
938: case OP_DEREF2: return "OP_DEREF2";
939: case OP_DEREF4: return "OP_DEREF4";
940: case OP_ADD: return "OP_ADD";
941: default: return "OP_<unknown>";
942: }
943: }
944:
945: static char *
946: dwarf_typemod_name (mod)
947: register unsigned mod;
948: {
949: switch (mod)
950: {
951: case MOD_pointer_to: return "MOD_pointer_to";
952: case MOD_reference_to: return "MOD_reference_to";
953: case MOD_const: return "MOD_const";
954: case MOD_volatile: return "MOD_volatile";
955: default: return "MOD_<unknown>";
956: }
957: }
958:
959: static char *
960: dwarf_fmt_byte_name (fmt)
961: register unsigned fmt;
962: {
963: switch (fmt)
964: {
965: case FMT_FT_C_C: return "FMT_FT_C_C";
966: case FMT_FT_C_X: return "FMT_FT_C_X";
967: case FMT_FT_X_C: return "FMT_FT_X_C";
968: case FMT_FT_X_X: return "FMT_FT_X_X";
969: case FMT_UT_C_C: return "FMT_UT_C_C";
970: case FMT_UT_C_X: return "FMT_UT_C_X";
971: case FMT_UT_X_C: return "FMT_UT_X_C";
972: case FMT_UT_X_X: return "FMT_UT_X_X";
973: case FMT_ET: return "FMT_ET";
974: default: return "FMT_<unknown>";
975: }
976: }
977: static char *
978: dwarf_fund_type_name (ft)
979: register unsigned ft;
980: {
981: switch (ft)
982: {
983: case FT_char: return "FT_char";
984: case FT_signed_char: return "FT_signed_char";
985: case FT_unsigned_char: return "FT_unsigned_char";
986: case FT_short: return "FT_short";
987: case FT_signed_short: return "FT_signed_short";
988: case FT_unsigned_short: return "FT_unsigned_short";
989: case FT_integer: return "FT_integer";
990: case FT_signed_integer: return "FT_signed_integer";
991: case FT_unsigned_integer: return "FT_unsigned_integer";
992: case FT_long: return "FT_long";
993: case FT_signed_long: return "FT_signed_long";
994: case FT_unsigned_long: return "FT_unsigned_long";
995: case FT_pointer: return "FT_pointer";
996: case FT_float: return "FT_float";
997: case FT_dbl_prec_float: return "FT_dbl_prec_float";
998: case FT_ext_prec_float: return "FT_ext_prec_float";
999: case FT_complex: return "FT_complex";
1000: case FT_dbl_prec_complex: return "FT_dbl_prec_complex";
1001: case FT_void: return "FT_void";
1002: case FT_boolean: return "FT_boolean";
1003: case FT_ext_prec_complex: return "FT_ext_prec_complex";
1004: case FT_label: return "FT_label";
1005:
1006: /* GNU extensions. */
1007:
1008: case FT_long_long: return "FT_long_long";
1009: case FT_signed_long_long: return "FT_signed_long_long";
1010: case FT_unsigned_long_long: return "FT_unsigned_long_long";
1011:
1012: case FT_int8: return "FT_int8";
1013: case FT_signed_int8: return "FT_signed_int8";
1014: case FT_unsigned_int8: return "FT_unsigned_int8";
1015: case FT_int16: return "FT_int16";
1016: case FT_signed_int16: return "FT_signed_int16";
1017: case FT_unsigned_int16: return "FT_unsigned_int16";
1018: case FT_int32: return "FT_int32";
1019: case FT_signed_int32: return "FT_signed_int32";
1020: case FT_unsigned_int32: return "FT_unsigned_int32";
1021: case FT_int64: return "FT_int64";
1022: case FT_signed_int64: return "FT_signed_int64";
1023: case FT_unsigned_int64: return "FT_signed_int64";
1024:
1025: case FT_real32: return "FT_real32";
1026: case FT_real64: return "FT_real64";
1027: case FT_real96: return "FT_real96";
1028: case FT_real128: return "FT_real128";
1029:
1030: default: return "FT_<unknown>";
1031: }
1032: }
1033:
1034: /* Determine the "ultimate origin" of a decl. The decl may be an
1035: inlined instance of an inlined instance of a decl which is local
1036: to an inline function, so we have to trace all of the way back
1037: through the origin chain to find out what sort of node actually
1038: served as the original seed for the given block. */
1039:
1040: static tree
1041: decl_ultimate_origin (decl)
1042: register tree decl;
1043: {
1044: register tree immediate_origin = DECL_ABSTRACT_ORIGIN (decl);
1045:
1046: if (immediate_origin == NULL)
1047: return NULL;
1048: else
1049: {
1050: register tree ret_val;
1051: register tree lookahead = immediate_origin;
1052:
1053: do
1054: {
1055: ret_val = lookahead;
1056: lookahead = DECL_ABSTRACT_ORIGIN (ret_val);
1057: }
1058: while (lookahead != NULL && lookahead != ret_val);
1059: return ret_val;
1060: }
1061: }
1062:
1063: /* Determine the "ultimate origin" of a block. The block may be an
1064: inlined instance of an inlined instance of a block which is local
1065: to an inline function, so we have to trace all of the way back
1066: through the origin chain to find out what sort of node actually
1067: served as the original seed for the given block. */
1068:
1069: static tree
1070: block_ultimate_origin (block)
1071: register tree block;
1072: {
1073: register tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
1074:
1075: if (immediate_origin == NULL)
1076: return NULL;
1077: else
1078: {
1079: register tree ret_val;
1080: register tree lookahead = immediate_origin;
1081:
1082: do
1083: {
1084: ret_val = lookahead;
1085: lookahead = (TREE_CODE (ret_val) == BLOCK)
1086: ? BLOCK_ABSTRACT_ORIGIN (ret_val)
1087: : NULL;
1088: }
1089: while (lookahead != NULL && lookahead != ret_val);
1090: return ret_val;
1091: }
1092: }
1093:
1094: static void
1095: output_unsigned_leb128 (value)
1096: register unsigned long value;
1097: {
1098: register unsigned long orig_value = value;
1099:
1100: do
1101: {
1102: register unsigned byte = (value & 0x7f);
1103:
1104: value >>= 7;
1105: if (value != 0) /* more bytes to follow */
1106: byte |= 0x80;
1107: fprintf (asm_out_file, "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) byte);
1108: if (flag_verbose_asm && value == 0)
1109: fprintf (asm_out_file, "\t%s ULEB128 number - value = %u",
1110: ASM_COMMENT_START, orig_value);
1111: fputc ('\n', asm_out_file);
1112: }
1113: while (value != 0);
1114: }
1115:
1116: static void
1117: output_signed_leb128 (value)
1118: register long value;
1119: {
1120: register long orig_value = value;
1121: register int negative = (value < 0);
1122: register int more;
1123:
1124: do
1125: {
1126: register unsigned byte = (value & 0x7f);
1127:
1128: value >>= 7;
1129: if (negative)
1130: value |= 0xfe000000; /* manually sign extend */
1131: if (((value == 0) && ((byte & 0x40) == 0))
1132: || ((value == -1) && ((byte & 0x40) == 1)))
1133: more = 0;
1134: else
1135: {
1136: byte |= 0x80;
1137: more = 1;
1138: }
1139: fprintf (asm_out_file, "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) byte);
1140: if (flag_verbose_asm && more == 0)
1141: fprintf (asm_out_file, "\t%s SLEB128 number - value = %d",
1142: ASM_COMMENT_START, orig_value);
1143: fputc ('\n', asm_out_file);
1144: }
1145: while (more);
1146: }
1147:
1148: /**************** utility functions for attribute functions ******************/
1149:
1150: /* Given a pointer to a BLOCK node return non-zero if (and only if) the
1151: node in question represents the outermost pair of curly braces (i.e.
1152: the "body block") of a function or method.
1153:
1154: For any BLOCK node representing a "body block" of a function or method,
1155: the BLOCK_SUPERCONTEXT of the node will point to another BLOCK node
1156: which represents the outermost (function) scope for the function or
1157: method (i.e. the one which includes the formal parameters). The
1158: BLOCK_SUPERCONTEXT of *that* node in turn will point to the relevant
1159: FUNCTION_DECL node.
1160: */
1161:
1162: inline int
1163: is_body_block (stmt)
1164: register tree stmt;
1165: {
1166: if (TREE_CODE (stmt) == BLOCK)
1167: {
1168: register tree parent = BLOCK_SUPERCONTEXT (stmt);
1169:
1170: if (TREE_CODE (parent) == BLOCK)
1171: {
1172: register tree grandparent = BLOCK_SUPERCONTEXT (parent);
1173:
1174: if (TREE_CODE (grandparent) == FUNCTION_DECL)
1175: return 1;
1176: }
1177: }
1178: return 0;
1179: }
1180:
1181: /* Given a pointer to a tree node for some type, return a Dwarf fundamental
1182: type code for the given type.
1183:
1184: This routine must only be called for GCC type nodes that correspond to
1185: Dwarf fundamental types.
1186:
1187: The current Dwarf draft specification calls for Dwarf fundamental types
1188: to accurately reflect the fact that a given type was either a "plain"
1189: integral type or an explicitly "signed" integral type. Unfortunately,
1190: we can't always do this, because GCC may already have thrown away the
1191: information about the precise way in which the type was originally
1192: specified, as in:
1193:
1194: typedef signed int my_type;
1195:
1196: struct s { my_type f; };
1197:
1198: Since we may be stuck here without enought information to do exactly
1199: what is called for in the Dwarf draft specification, we do the best
1200: that we can under the circumstances and always use the "plain" integral
1201: fundamental type codes for int, short, and long types. That's probably
1202: good enough. The additional accuracy called for in the current DWARF
1203: draft specification is probably never even useful in practice. */
1204:
1205: static int
1206: fundamental_type_code (type)
1207: register tree type;
1208: {
1209: if (TREE_CODE (type) == ERROR_MARK)
1210: return 0;
1211:
1212: switch (TREE_CODE (type))
1213: {
1214: case ERROR_MARK:
1215: return FT_void;
1216:
1217: case VOID_TYPE:
1218: return FT_void;
1219:
1220: case INTEGER_TYPE:
1221: /* Carefully distinguish all the standard types of C,
1222: without messing up if the language is not C.
1223: Note that we check only for the names that contain spaces;
1224: other names might occur by coincidence in other languages. */
1225: if (TYPE_NAME (type) != 0
1226: && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1227: && DECL_NAME (TYPE_NAME (type)) != 0
1228: && TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE)
1229: {
1230: char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
1231:
1232: if (!strcmp (name, "unsigned char"))
1233: return FT_unsigned_char;
1234: if (!strcmp (name, "signed char"))
1235: return FT_signed_char;
1236: if (!strcmp (name, "unsigned int"))
1237: return FT_unsigned_integer;
1238: if (!strcmp (name, "short int"))
1239: return FT_short;
1240: if (!strcmp (name, "short unsigned int"))
1241: return FT_unsigned_short;
1242: if (!strcmp (name, "long int"))
1243: return FT_long;
1244: if (!strcmp (name, "long unsigned int"))
1245: return FT_unsigned_long;
1246: if (!strcmp (name, "long long int"))
1247: return FT_long_long; /* Not grok'ed by svr4 SDB */
1248: if (!strcmp (name, "long long unsigned int"))
1249: return FT_unsigned_long_long; /* Not grok'ed by svr4 SDB */
1250: }
1251:
1252: /* Most integer types will be sorted out above, however, for the
1253: sake of special `array index' integer types, the following code
1254: is also provided. */
1255:
1256: if (TYPE_PRECISION (type) == INT_TYPE_SIZE)
1257: return (TREE_UNSIGNED (type) ? FT_unsigned_integer : FT_integer);
1258:
1259: if (TYPE_PRECISION (type) == LONG_TYPE_SIZE)
1260: return (TREE_UNSIGNED (type) ? FT_unsigned_long : FT_long);
1261:
1262: if (TYPE_PRECISION (type) == LONG_LONG_TYPE_SIZE)
1263: return (TREE_UNSIGNED (type) ? FT_unsigned_long_long : FT_long_long);
1264:
1265: if (TYPE_PRECISION (type) == SHORT_TYPE_SIZE)
1266: return (TREE_UNSIGNED (type) ? FT_unsigned_short : FT_short);
1267:
1268: if (TYPE_PRECISION (type) == CHAR_TYPE_SIZE)
1269: return (TREE_UNSIGNED (type) ? FT_unsigned_char : FT_char);
1270:
1271: abort ();
1272:
1273: case REAL_TYPE:
1274: /* Carefully distinguish all the standard types of C,
1275: without messing up if the language is not C. */
1276: if (TYPE_NAME (type) != 0
1277: && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1278: && DECL_NAME (TYPE_NAME (type)) != 0
1279: && TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE)
1280: {
1281: char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
1282:
1283: /* Note that here we can run afowl of a serious bug in "classic"
1284: svr4 SDB debuggers. They don't seem to understand the
1285: FT_ext_prec_float type (even though they should). */
1286:
1287: if (!strcmp (name, "long double"))
1288: return FT_ext_prec_float;
1289: }
1290:
1291: if (TYPE_PRECISION (type) == DOUBLE_TYPE_SIZE)
1292: return FT_dbl_prec_float;
1293: if (TYPE_PRECISION (type) == FLOAT_TYPE_SIZE)
1294: return FT_float;
1295:
1296: /* Note that here we can run afowl of a serious bug in "classic"
1297: svr4 SDB debuggers. They don't seem to understand the
1298: FT_ext_prec_float type (even though they should). */
1299:
1300: if (TYPE_PRECISION (type) == LONG_DOUBLE_TYPE_SIZE)
1301: return FT_ext_prec_float;
1302: abort ();
1303:
1304: case COMPLEX_TYPE:
1305: return FT_complex; /* GNU FORTRAN COMPLEX type. */
1306:
1307: case CHAR_TYPE:
1308: return FT_char; /* GNU Pascal CHAR type. Not used in C. */
1309:
1310: case BOOLEAN_TYPE:
1311: return FT_boolean; /* GNU FORTRAN BOOLEAN type. */
1312:
1313: default:
1314: abort (); /* No other TREE_CODEs are Dwarf fundamental types. */
1315: }
1316: return 0;
1317: }
1318:
1319: /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
1320: the Dwarf "root" type for the given input type. The Dwarf "root" type
1321: of a given type is generally the same as the given type, except that if
1322: the given type is a pointer or reference type, then the root type of
1323: the given type is the root type of the "basis" type for the pointer or
1324: reference type. (This definition of the "root" type is recursive.)
1325: Also, the root type of a `const' qualified type or a `volatile'
1326: qualified type is the root type of the given type without the
1327: qualifiers. */
1328:
1329: static tree
1330: root_type (type)
1331: register tree type;
1332: {
1333: if (TREE_CODE (type) == ERROR_MARK)
1334: return error_mark_node;
1335:
1336: switch (TREE_CODE (type))
1337: {
1338: case ERROR_MARK:
1339: return error_mark_node;
1340:
1341: case POINTER_TYPE:
1342: case REFERENCE_TYPE:
1343: return type_main_variant (root_type (TREE_TYPE (type)));
1344:
1345: default:
1346: return type_main_variant (type);
1347: }
1348: }
1349:
1350: /* Given a pointer to an arbitrary ..._TYPE tree node, write out a sequence
1351: of zero or more Dwarf "type-modifier" bytes applicable to the type. */
1352:
1353: static void
1354: write_modifier_bytes (type, decl_const, decl_volatile)
1355: register tree type;
1356: register int decl_const;
1357: register int decl_volatile;
1358: {
1359: if (TREE_CODE (type) == ERROR_MARK)
1360: return;
1361:
1362: if (TYPE_READONLY (type) || decl_const)
1363: ASM_OUTPUT_DWARF_TYPE_MODIFIER (asm_out_file, MOD_const);
1364: if (TYPE_VOLATILE (type) || decl_volatile)
1365: ASM_OUTPUT_DWARF_TYPE_MODIFIER (asm_out_file, MOD_volatile);
1366: switch (TREE_CODE (type))
1367: {
1368: case POINTER_TYPE:
1369: ASM_OUTPUT_DWARF_TYPE_MODIFIER (asm_out_file, MOD_pointer_to);
1370: write_modifier_bytes (TREE_TYPE (type), 0, 0);
1371: return;
1372:
1373: case REFERENCE_TYPE:
1374: ASM_OUTPUT_DWARF_TYPE_MODIFIER (asm_out_file, MOD_reference_to);
1375: write_modifier_bytes (TREE_TYPE (type), 0, 0);
1376: return;
1377:
1378: case ERROR_MARK:
1379: default:
1380: return;
1381: }
1382: }
1383:
1384: /* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the
1385: given input type is a Dwarf "fundamental" type. Otherwise return zero. */
1386:
1387: inline int
1388: type_is_fundamental (type)
1389: register tree type;
1390: {
1391: switch (TREE_CODE (type))
1392: {
1393: case ERROR_MARK:
1394: case VOID_TYPE:
1395: case INTEGER_TYPE:
1396: case REAL_TYPE:
1397: case COMPLEX_TYPE:
1398: case BOOLEAN_TYPE:
1399: case CHAR_TYPE:
1400: return 1;
1401:
1402: case SET_TYPE:
1403: case ARRAY_TYPE:
1404: case RECORD_TYPE:
1405: case UNION_TYPE:
1406: case QUAL_UNION_TYPE:
1407: case ENUMERAL_TYPE:
1408: case FUNCTION_TYPE:
1409: case METHOD_TYPE:
1410: case POINTER_TYPE:
1411: case REFERENCE_TYPE:
1412: case STRING_TYPE:
1413: case FILE_TYPE:
1414: case OFFSET_TYPE:
1415: case LANG_TYPE:
1416: return 0;
1417:
1418: default:
1419: abort ();
1420: }
1421: return 0;
1422: }
1423:
1424: /* Given a pointer to some ..._DECL tree node, generate an assembly language
1425: equate directive which will associate a symbolic name with the current DIE.
1426:
1427: The name used is an artificial label generated from the DECL_UID number
1428: associated with the given decl node. The name it gets equated to is the
1429: symbolic label that we (previously) output at the start of the DIE that
1430: we are currently generating.
1431:
1432: Calling this function while generating some "decl related" form of DIE
1433: makes it possible to later refer to the DIE which represents the given
1434: decl simply by re-generating the symbolic name from the ..._DECL node's
1435: UID number. */
1436:
1437: static void
1438: equate_decl_number_to_die_number (decl)
1439: register tree decl;
1440: {
1441: /* In the case where we are generating a DIE for some ..._DECL node
1442: which represents either some inline function declaration or some
1443: entity declared within an inline function declaration/definition,
1444: setup a symbolic name for the current DIE so that we have a name
1445: for this DIE that we can easily refer to later on within
1446: AT_abstract_origin attributes. */
1447:
1448: char decl_label[MAX_ARTIFICIAL_LABEL_BYTES];
1449: char die_label[MAX_ARTIFICIAL_LABEL_BYTES];
1450:
1451: sprintf (decl_label, DECL_NAME_FMT, DECL_UID (decl));
1452: sprintf (die_label, DIE_BEGIN_LABEL_FMT, current_dienum);
1453: ASM_OUTPUT_DEF (asm_out_file, decl_label, die_label);
1454: }
1455:
1456: /* Given a pointer to some ..._TYPE tree node, generate an assembly language
1457: equate directive which will associate a symbolic name with the current DIE.
1458:
1459: The name used is an artificial label generated from the TYPE_UID number
1460: associated with the given type node. The name it gets equated to is the
1461: symbolic label that we (previously) output at the start of the DIE that
1462: we are currently generating.
1463:
1464: Calling this function while generating some "type related" form of DIE
1465: makes it easy to later refer to the DIE which represents the given type
1466: simply by re-generating the alternative name from the ..._TYPE node's
1467: UID number. */
1468:
1469: inline void
1470: equate_type_number_to_die_number (type)
1471: register tree type;
1472: {
1473: char type_label[MAX_ARTIFICIAL_LABEL_BYTES];
1474: char die_label[MAX_ARTIFICIAL_LABEL_BYTES];
1475:
1476: /* We are generating a DIE to represent the main variant of this type
1477: (i.e the type without any const or volatile qualifiers) so in order
1478: to get the equate to come out right, we need to get the main variant
1479: itself here. */
1480:
1481: type = type_main_variant (type);
1482:
1483: sprintf (type_label, TYPE_NAME_FMT, TYPE_UID (type));
1484: sprintf (die_label, DIE_BEGIN_LABEL_FMT, current_dienum);
1485: ASM_OUTPUT_DEF (asm_out_file, type_label, die_label);
1486: }
1487:
1488: static void
1489: output_reg_number (rtl)
1490: register rtx rtl;
1491: {
1492: register unsigned regno = REGNO (rtl);
1493:
1494: if (regno >= FIRST_PSEUDO_REGISTER)
1495: {
1496: warning_with_decl (dwarf_last_decl, "internal regno botch: regno = %d\n",
1497: regno);
1498: regno = 0;
1499: }
1500: fprintf (asm_out_file, "\t%s\t0x%x",
1501: UNALIGNED_INT_ASM_OP, DBX_REGISTER_NUMBER (regno));
1502: if (flag_verbose_asm)
1503: {
1504: fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
1505: PRINT_REG (rtl, 0, asm_out_file);
1506: }
1507: fputc ('\n', asm_out_file);
1508: }
1509:
1510: /* The following routine is a nice and simple transducer. It converts the
1511: RTL for a variable or parameter (resident in memory) into an equivalent
1512: Dwarf representation of a mechanism for getting the address of that same
1513: variable onto the top of a hypothetical "address evaluation" stack.
1514:
1515: When creating memory location descriptors, we are effectively trans-
1516: forming the RTL for a memory-resident object into its Dwarf postfix
1517: expression equivalent. This routine just recursively descends an
1518: RTL tree, turning it into Dwarf postfix code as it goes. */
1519:
1520: static void
1521: output_mem_loc_descriptor (rtl)
1522: register rtx rtl;
1523: {
1524: /* Note that for a dynamically sized array, the location we will
1525: generate a description of here will be the lowest numbered location
1526: which is actually within the array. That's *not* necessarily the
1527: same as the zeroth element of the array. */
1528:
1529: switch (GET_CODE (rtl))
1530: {
1531: case SUBREG:
1532:
1533: /* The case of a subreg may arise when we have a local (register)
1534: variable or a formal (register) parameter which doesn't quite
1535: fill up an entire register. For now, just assume that it is
1536: legitimate to make the Dwarf info refer to the whole register
1537: which contains the given subreg. */
1538:
1539: rtl = XEXP (rtl, 0);
1540: /* Drop thru. */
1541:
1542: case REG:
1543:
1544: /* Whenever a register number forms a part of the description of
1545: the method for calculating the (dynamic) address of a memory
1546: resident object, DWARF rules require the register number to
1547: be referred to as a "base register". This distinction is not
1548: based in any way upon what category of register the hardware
1549: believes the given register belongs to. This is strictly
1550: DWARF terminology we're dealing with here.
1551:
1552: Note that in cases where the location of a memory-resident data
1553: object could be expressed as:
1554:
1555: OP_ADD (OP_BASEREG (basereg), OP_CONST (0))
1556:
1557: the actual DWARF location descriptor that we generate may just
1558: be OP_BASEREG (basereg). This may look deceptively like the
1559: object in question was allocated to a register (rather than
1560: in memory) so DWARF consumers need to be aware of the subtle
1561: distinction between OP_REG and OP_BASEREG. */
1562:
1563: ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_BASEREG);
1564: output_reg_number (rtl);
1565: break;
1566:
1567: case MEM:
1568: output_mem_loc_descriptor (XEXP (rtl, 0));
1569: ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_DEREF4);
1570: break;
1571:
1572: case CONST:
1573: case SYMBOL_REF:
1574: ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_ADDR);
1575: ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, rtl);
1576: break;
1577:
1578: case PLUS:
1579: output_mem_loc_descriptor (XEXP (rtl, 0));
1580: output_mem_loc_descriptor (XEXP (rtl, 1));
1581: ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_ADD);
1582: break;
1583:
1584: case CONST_INT:
1585: ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_CONST);
1586: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, INTVAL (rtl));
1587: break;
1588:
1589: default:
1590: abort ();
1591: }
1592: }
1593:
1594: /* Output a proper Dwarf location descriptor for a variable or parameter
1595: which is either allocated in a register or in a memory location. For
1596: a register, we just generate an OP_REG and the register number. For a
1597: memory location we provide a Dwarf postfix expression describing how to
1598: generate the (dynamic) address of the object onto the address stack. */
1599:
1600: static void
1601: output_loc_descriptor (rtl)
1602: register rtx rtl;
1603: {
1604: switch (GET_CODE (rtl))
1605: {
1606: case SUBREG:
1607:
1608: /* The case of a subreg may arise when we have a local (register)
1609: variable or a formal (register) parameter which doesn't quite
1610: fill up an entire register. For now, just assume that it is
1611: legitimate to make the Dwarf info refer to the whole register
1612: which contains the given subreg. */
1613:
1614: rtl = XEXP (rtl, 0);
1615: /* Drop thru. */
1616:
1617: case REG:
1618: ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_REG);
1619: output_reg_number (rtl);
1620: break;
1621:
1622: case MEM:
1623: output_mem_loc_descriptor (XEXP (rtl, 0));
1624: break;
1625:
1626: default:
1627: abort (); /* Should never happen */
1628: }
1629: }
1630:
1631: /* Given a tree node describing an array bound (either lower or upper)
1632: output a representation for that bound. */
1633:
1634: static void
1635: output_bound_representation (bound, dim_num, u_or_l)
1636: register tree bound;
1637: register unsigned dim_num; /* For multi-dimensional arrays. */
1638: register char u_or_l; /* Designates upper or lower bound. */
1639: {
1640: switch (TREE_CODE (bound))
1641: {
1642:
1643: case ERROR_MARK:
1644: return;
1645:
1646: /* All fixed-bounds are represented by INTEGER_CST nodes. */
1647:
1648: case INTEGER_CST:
1649: ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
1650: (unsigned) TREE_INT_CST_LOW (bound));
1651: break;
1652:
1653: /* Dynamic bounds may be represented by NOP_EXPR nodes containing
1654: SAVE_EXPR nodes. */
1655:
1656: case NOP_EXPR:
1657: bound = TREE_OPERAND (bound, 0);
1658: /* ... fall thru... */
1659:
1660: case SAVE_EXPR:
1661: {
1662: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
1663: char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
1664:
1665: sprintf (begin_label, BOUND_BEGIN_LABEL_FMT,
1666: current_dienum, dim_num, u_or_l);
1667:
1668: sprintf (end_label, BOUND_END_LABEL_FMT,
1669: current_dienum, dim_num, u_or_l);
1670:
1671: ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
1672: ASM_OUTPUT_LABEL (asm_out_file, begin_label);
1673:
1674: /* If we are working on a bound for a dynamic dimension in C,
1675: the dynamic dimension in question had better have a static
1676: (zero) lower bound and a dynamic *upper* bound. */
1677:
1678: if (u_or_l != 'u')
1679: abort ();
1680:
1681: /* If optimization is turned on, the SAVE_EXPRs that describe
1682: how to access the upper bound values are essentially bogus.
1683: They only describe (at best) how to get at these values at
1684: the points in the generated code right after they have just
1685: been computed. Worse yet, in the typical case, the upper
1686: bound values will not even *be* computed in the optimized
1687: code, so these SAVE_EXPRs are entirely bogus.
1688:
1689: In order to compensate for this fact, we check here to see
1690: if optimization is enabled, and if so, we effectively create
1691: an empty location description for the (unknown and unknowable)
1692: upper bound.
1693:
1694: This should not cause too much trouble for existing (stupid?)
1695: debuggers because they have to deal with empty upper bounds
1696: location descriptions anyway in order to be able to deal with
1697: incomplete array types.
1698:
1699: Of course an intelligent debugger (GDB?) should be able to
1700: comprehend that a missing upper bound specification in a
1701: array type used for a storage class `auto' local array variable
1702: indicates that the upper bound is both unknown (at compile-
1703: time) and unknowable (at run-time) due to optimization.
1704: */
1705:
1706: if (! optimize)
1707: output_loc_descriptor
1708: (eliminate_regs (SAVE_EXPR_RTL (bound), 0, NULL_RTX));
1709:
1710: ASM_OUTPUT_LABEL (asm_out_file, end_label);
1711: }
1712: break;
1713:
1714: default:
1715: abort ();
1716: }
1717: }
1718:
1719: /* Recursive function to output a sequence of value/name pairs for
1720: enumeration constants in reversed order. This is called from
1721: enumeration_type_die. */
1722:
1723: static void
1724: output_enumeral_list (link)
1725: register tree link;
1726: {
1727: if (link)
1728: {
1729: output_enumeral_list (TREE_CHAIN (link));
1730: ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
1731: (unsigned) TREE_INT_CST_LOW (TREE_VALUE (link)));
1732: ASM_OUTPUT_DWARF_STRING (asm_out_file,
1733: IDENTIFIER_POINTER (TREE_PURPOSE (link)));
1734: }
1735: }
1736:
1737: /* Given an unsigned value, round it up to the lowest multiple of `boundary'
1738: which is not less than the value itself. */
1739:
1740: inline unsigned
1741: ceiling (value, boundary)
1742: register unsigned value;
1743: register unsigned boundary;
1744: {
1745: return (((value + boundary - 1) / boundary) * boundary);
1746: }
1747:
1748: /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
1749: pointer to the declared type for the relevant field variable, or return
1750: `integer_type_node' if the given node turns out to be an ERROR_MARK node. */
1751:
1752: inline tree
1753: field_type (decl)
1754: register tree decl;
1755: {
1756: register tree type;
1757:
1758: if (TREE_CODE (decl) == ERROR_MARK)
1759: return integer_type_node;
1760:
1761: type = DECL_BIT_FIELD_TYPE (decl);
1762: if (type == NULL)
1763: type = TREE_TYPE (decl);
1764: return type;
1765: }
1766:
1767: /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
1768: node, return the alignment in bits for the type, or else return
1769: BITS_PER_WORD if the node actually turns out to be an ERROR_MARK node. */
1770:
1771: inline unsigned
1772: simple_type_align_in_bits (type)
1773: register tree type;
1774: {
1775: return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
1776: }
1777:
1778: /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
1779: node, return the size in bits for the type if it is a constant, or
1780: else return the alignment for the type if the type's size is not
1781: constant, or else return BITS_PER_WORD if the type actually turns out
1782: to be an ERROR_MARK node. */
1783:
1784: inline unsigned
1785: simple_type_size_in_bits (type)
1786: register tree type;
1787: {
1788: if (TREE_CODE (type) == ERROR_MARK)
1789: return BITS_PER_WORD;
1790: else
1791: {
1792: register tree type_size_tree = TYPE_SIZE (type);
1793:
1794: if (TREE_CODE (type_size_tree) != INTEGER_CST)
1795: return TYPE_ALIGN (type);
1796:
1797: return (unsigned) TREE_INT_CST_LOW (type_size_tree);
1798: }
1799: }
1800:
1801: /* Given a pointer to what is assumed to be a FIELD_DECL node, compute and
1802: return the byte offset of the lowest addressed byte of the "containing
1803: object" for the given FIELD_DECL, or return 0 if we are unable to deter-
1804: mine what that offset is, either because the argument turns out to be a
1805: pointer to an ERROR_MARK node, or because the offset is actually variable.
1806: (We can't handle the latter case just yet.) */
1807:
1808: static unsigned
1809: field_byte_offset (decl)
1810: register tree decl;
1811: {
1812: register unsigned type_align_in_bytes;
1813: register unsigned type_align_in_bits;
1814: register unsigned type_size_in_bits;
1815: register unsigned object_offset_in_align_units;
1816: register unsigned object_offset_in_bits;
1817: register unsigned object_offset_in_bytes;
1818: register tree type;
1819: register tree bitpos_tree;
1820: register tree field_size_tree;
1821: register unsigned bitpos_int;
1822: register unsigned deepest_bitpos;
1823: register unsigned field_size_in_bits;
1824:
1825: if (TREE_CODE (decl) == ERROR_MARK)
1826: return 0;
1827:
1828: if (TREE_CODE (decl) != FIELD_DECL)
1829: abort ();
1830:
1831: type = field_type (decl);
1832:
1833: bitpos_tree = DECL_FIELD_BITPOS (decl);
1834: field_size_tree = DECL_SIZE (decl);
1835:
1836: /* We cannot yet cope with fields whose positions or sizes are variable,
1837: so for now, when we see such things, we simply return 0. Someday,
1838: we may be able to handle such cases, but it will be damn difficult. */
1839:
1840: if (TREE_CODE (bitpos_tree) != INTEGER_CST)
1841: return 0;
1842: bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
1843:
1844: if (TREE_CODE (field_size_tree) != INTEGER_CST)
1845: return 0;
1846: field_size_in_bits = (unsigned) TREE_INT_CST_LOW (field_size_tree);
1847:
1848: type_size_in_bits = simple_type_size_in_bits (type);
1849:
1850: type_align_in_bits = simple_type_align_in_bits (type);
1851: type_align_in_bytes = type_align_in_bits / BITS_PER_UNIT;
1852:
1853: /* Note that the GCC front-end doesn't make any attempt to keep track
1854: of the starting bit offset (relative to the start of the containing
1855: structure type) of the hypothetical "containing object" for a bit-
1856: field. Thus, when computing the byte offset value for the start of
1857: the "containing object" of a bit-field, we must deduce this infor-
1858: mation on our own.
1859:
1860: This can be rather tricky to do in some cases. For example, handling
1861: the following structure type definition when compiling for an i386/i486
1862: target (which only aligns long long's to 32-bit boundaries) can be very
1863: tricky:
1864:
1865: struct S {
1866: int field1;
1867: long long field2:31;
1868: };
1869:
1870: Fortunately, there is a simple rule-of-thumb which can be used in such
1871: cases. When compiling for an i386/i486, GCC will allocate 8 bytes for
1872: the structure shown above. It decides to do this based upon one simple
1873: rule for bit-field allocation. Quite simply, GCC allocates each "con-
1874: taining object" for each bit-field at the first (i.e. lowest addressed)
1875: legitimate alignment boundary (based upon the required minimum alignment
1876: for the declared type of the field) which it can possibly use, subject
1877: to the condition that there is still enough available space remaining
1878: in the containing object (when allocated at the selected point) to
1879: fully accommodate all of the bits of the bit-field itself.
1880:
1881: This simple rule makes it obvious why GCC allocates 8 bytes for each
1882: object of the structure type shown above. When looking for a place to
1883: allocate the "containing object" for `field2', the compiler simply tries
1884: to allocate a 64-bit "containing object" at each successive 32-bit
1885: boundary (starting at zero) until it finds a place to allocate that 64-
1886: bit field such that at least 31 contiguous (and previously unallocated)
1887: bits remain within that selected 64 bit field. (As it turns out, for
1888: the example above, the compiler finds that it is OK to allocate the
1889: "containing object" 64-bit field at bit-offset zero within the
1890: structure type.)
1891:
1892: Here we attempt to work backwards from the limited set of facts we're
1893: given, and we try to deduce from those facts, where GCC must have
1894: believed that the containing object started (within the structure type).
1895:
1896: The value we deduce is then used (by the callers of this routine) to
1897: generate AT_location and AT_bit_offset attributes for fields (both
1898: bit-fields and, in the case of AT_location, regular fields as well).
1899: */
1900:
1901: /* Figure out the bit-distance from the start of the structure to the
1902: "deepest" bit of the bit-field. */
1903: deepest_bitpos = bitpos_int + field_size_in_bits;
1904:
1905: /* This is the tricky part. Use some fancy footwork to deduce where the
1906: lowest addressed bit of the containing object must be. */
1907: object_offset_in_bits
1908: = ceiling (deepest_bitpos, type_align_in_bits) - type_size_in_bits;
1909:
1910: /* Compute the offset of the containing object in "alignment units". */
1911: object_offset_in_align_units = object_offset_in_bits / type_align_in_bits;
1912:
1913: /* Compute the offset of the containing object in bytes. */
1914: object_offset_in_bytes = object_offset_in_align_units * type_align_in_bytes;
1915:
1916: return object_offset_in_bytes;
1917: }
1918:
1919: /****************************** attributes *********************************/
1920:
1921: /* The following routines are responsible for writing out the various types
1922: of Dwarf attributes (and any following data bytes associated with them).
1923: These routines are listed in order based on the numerical codes of their
1924: associated attributes. */
1925:
1926: /* Generate an AT_sibling attribute. */
1927:
1928: inline void
1929: sibling_attribute ()
1930: {
1931: char label[MAX_ARTIFICIAL_LABEL_BYTES];
1932:
1933: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_sibling);
1934: sprintf (label, DIE_BEGIN_LABEL_FMT, NEXT_DIE_NUM);
1935: ASM_OUTPUT_DWARF_REF (asm_out_file, label);
1936: }
1937:
1938: /* Output the form of location attributes suitable for whole variables and
1939: whole parameters. Note that the location attributes for struct fields
1940: are generated by the routine `data_member_location_attribute' below. */
1941:
1942: static void
1943: location_attribute (rtl)
1944: register rtx rtl;
1945: {
1946: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
1947: char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
1948:
1949: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_location);
1950: sprintf (begin_label, LOC_BEGIN_LABEL_FMT, current_dienum);
1951: sprintf (end_label, LOC_END_LABEL_FMT, current_dienum);
1952: ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
1953: ASM_OUTPUT_LABEL (asm_out_file, begin_label);
1954:
1955: /* Handle a special case. If we are about to output a location descriptor
1956: for a variable or parameter which has been optimized out of existence,
1957: don't do that. Instead we output a zero-length location descriptor
1958: value as part of the location attribute.
1959:
1960: A variable which has been optimized out of existence will have a
1961: DECL_RTL value which denotes a pseudo-reg.
1962:
1963: Currently, in some rare cases, variables can have DECL_RTL values
1964: which look like (MEM (REG pseudo-reg#)). These cases are due to
1965: bugs elsewhere in the compiler. We treat such cases
1966: as if the variable(s) in question had been optimized out of existence.
1967:
1968: Note that in all cases where we wish to express the fact that a
1969: variable has been optimized out of existence, we do not simply
1970: suppress the generation of the entire location attribute because
1971: the absence of a location attribute in certain kinds of DIEs is
1972: used to indicate something else entirely... i.e. that the DIE
1973: represents an object declaration, but not a definition. So sayeth
1974: the PLSIG.
1975: */
1976:
1977: if (! is_pseudo_reg (rtl)
1978: && (GET_CODE (rtl) != MEM || ! is_pseudo_reg (XEXP (rtl, 0))))
1979: output_loc_descriptor (eliminate_regs (rtl, 0, NULL_RTX));
1980:
1981: ASM_OUTPUT_LABEL (asm_out_file, end_label);
1982: }
1983:
1984: /* Output the specialized form of location attribute used for data members
1985: of struct and union types.
1986:
1987: In the special case of a FIELD_DECL node which represents a bit-field,
1988: the "offset" part of this special location descriptor must indicate the
1989: distance in bytes from the lowest-addressed byte of the containing
1990: struct or union type to the lowest-addressed byte of the "containing
1991: object" for the bit-field. (See the `field_byte_offset' function above.)
1992:
1993: For any given bit-field, the "containing object" is a hypothetical
1994: object (of some integral or enum type) within which the given bit-field
1995: lives. The type of this hypothetical "containing object" is always the
1996: same as the declared type of the individual bit-field itself (for GCC
1997: anyway... the DWARF spec doesn't actually mandate this).
1998:
1999: Note that it is the size (in bytes) of the hypothetical "containing
2000: object" which will be given in the AT_byte_size attribute for this
2001: bit-field. (See the `byte_size_attribute' function below.) It is
2002: also used when calculating the value of the AT_bit_offset attribute.
2003: (See the `bit_offset_attribute' function below.)
2004: */
2005:
2006: static void
2007: data_member_location_attribute (decl)
2008: register tree decl;
2009: {
2010: register unsigned object_offset_in_bytes = field_byte_offset (decl);
2011: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
2012: char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2013:
2014: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_location);
2015: sprintf (begin_label, LOC_BEGIN_LABEL_FMT, current_dienum);
2016: sprintf (end_label, LOC_END_LABEL_FMT, current_dienum);
2017: ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
2018: ASM_OUTPUT_LABEL (asm_out_file, begin_label);
2019: ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_CONST);
2020: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, object_offset_in_bytes);
2021: ASM_OUTPUT_DWARF_STACK_OP (asm_out_file, OP_ADD);
2022: ASM_OUTPUT_LABEL (asm_out_file, end_label);
2023: }
2024:
2025: /* Output an AT_const_value attribute for a variable or a parameter which
2026: does not have a "location" either in memory or in a register. These
2027: things can arise in GNU C when a constant is passed as an actual
2028: parameter to an inlined function. They can also arise in C++ where
2029: declared constants do not necessarily get memory "homes". */
2030:
2031: static void
2032: const_value_attribute (rtl)
2033: register rtx rtl;
2034: {
2035: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
2036: char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2037:
2038: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_const_value_block4);
2039: sprintf (begin_label, LOC_BEGIN_LABEL_FMT, current_dienum);
2040: sprintf (end_label, LOC_END_LABEL_FMT, current_dienum);
2041: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, end_label, begin_label);
2042: ASM_OUTPUT_LABEL (asm_out_file, begin_label);
2043:
2044: switch (GET_CODE (rtl))
2045: {
2046: case CONST_INT:
2047: /* Note that a CONST_INT rtx could represent either an integer or
2048: a floating-point constant. A CONST_INT is used whenever the
2049: constant will fit into a single word. In all such cases, the
2050: original mode of the constant value is wiped out, and the
2051: CONST_INT rtx is assigned VOIDmode. Since we no longer have
2052: precise mode information for these constants, we always just
2053: output them using 4 bytes. */
2054:
2055: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, (unsigned) INTVAL (rtl));
2056: break;
2057:
2058: case CONST_DOUBLE:
2059: /* Note that a CONST_DOUBLE rtx could represent either an integer
2060: or a floating-point constant. A CONST_DOUBLE is used whenever
2061: the constant requires more than one word in order to be adequately
2062: represented. In all such cases, the original mode of the constant
2063: value is preserved as the mode of the CONST_DOUBLE rtx, but for
2064: simplicity we always just output CONST_DOUBLEs using 8 bytes. */
2065:
2066: ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
2067: (unsigned HOST_WIDE_INT) CONST_DOUBLE_HIGH (rtl),
2068: (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (rtl));
2069: break;
2070:
2071: case CONST_STRING:
2072: ASM_OUTPUT_DWARF_STRING (asm_out_file, XSTR (rtl, 0));
2073: break;
2074:
2075: case SYMBOL_REF:
2076: case LABEL_REF:
2077: case CONST:
2078: ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, rtl);
2079: break;
2080:
2081: case PLUS:
2082: /* In cases where an inlined instance of an inline function is passed
2083: the address of an `auto' variable (which is local to the caller)
2084: we can get a situation where the DECL_RTL of the artificial
2085: local variable (for the inlining) which acts as a stand-in for
2086: the corresponding formal parameter (of the inline function)
2087: will look like (plus:SI (reg:SI FRAME_PTR) (const_int ...)).
2088: This is not exactly a compile-time constant expression, but it
2089: isn't the address of the (artificial) local variable either.
2090: Rather, it represents the *value* which the artificial local
2091: variable always has during its lifetime. We currently have no
2092: way to represent such quasi-constant values in Dwarf, so for now
2093: we just punt and generate an AT_const_value attribute with form
2094: FORM_BLOCK4 and a length of zero. */
2095: break;
2096:
2097: default:
2098: abort (); /* No other kinds of rtx should be possible here. */
2099: }
2100:
2101: ASM_OUTPUT_LABEL (asm_out_file, end_label);
2102: }
2103:
2104: /* Generate *either* an AT_location attribute or else an AT_const_value
2105: data attribute for a variable or a parameter. We generate the
2106: AT_const_value attribute only in those cases where the given
2107: variable or parameter does not have a true "location" either in
2108: memory or in a register. This can happen (for example) when a
2109: constant is passed as an actual argument in a call to an inline
2110: function. (It's possible that these things can crop up in other
2111: ways also.) Note that one type of constant value which can be
2112: passed into an inlined function is a constant pointer. This can
2113: happen for example if an actual argument in an inlined function
2114: call evaluates to a compile-time constant address. */
2115:
2116: static void
2117: location_or_const_value_attribute (decl)
2118: register tree decl;
2119: {
2120: register rtx rtl;
2121:
2122: if (TREE_CODE (decl) == ERROR_MARK)
2123: return;
2124:
2125: if ((TREE_CODE (decl) != VAR_DECL) && (TREE_CODE (decl) != PARM_DECL))
2126: {
2127: /* Should never happen. */
2128: abort ();
2129: return;
2130: }
2131:
2132: /* Here we have to decide where we are going to say the parameter "lives"
2133: (as far as the debugger is concerned). We only have a couple of choices.
2134: GCC provides us with DECL_RTL and with DECL_INCOMING_RTL. DECL_RTL
2135: normally indicates where the parameter lives during most of the activa-
2136: tion of the function. If optimization is enabled however, this could
2137: be either NULL or else a pseudo-reg. Both of those cases indicate that
2138: the parameter doesn't really live anywhere (as far as the code generation
2139: parts of GCC are concerned) during most of the function's activation.
2140: That will happen (for example) if the parameter is never referenced
2141: within the function.
2142:
2143: We could just generate a location descriptor here for all non-NULL
2144: non-pseudo values of DECL_RTL and ignore all of the rest, but we can
2145: be a little nicer than that if we also consider DECL_INCOMING_RTL in
2146: cases where DECL_RTL is NULL or is a pseudo-reg.
2147:
2148: Note however that we can only get away with using DECL_INCOMING_RTL as
2149: a backup substitute for DECL_RTL in certain limited cases. In cases
2150: where DECL_ARG_TYPE(decl) indicates the same type as TREE_TYPE(decl)
2151: we can be sure that the parameter was passed using the same type as it
2152: is declared to have within the function, and that its DECL_INCOMING_RTL
2153: points us to a place where a value of that type is passed. In cases
2154: where DECL_ARG_TYPE(decl) and TREE_TYPE(decl) are different types
2155: however, we cannot (in general) use DECL_INCOMING_RTL as a backup
2156: substitute for DECL_RTL because in these cases, DECL_INCOMING_RTL
2157: points us to a value of some type which is *different* from the type
2158: of the parameter itself. Thus, if we tried to use DECL_INCOMING_RTL
2159: to generate a location attribute in such cases, the debugger would
2160: end up (for example) trying to fetch a `float' from a place which
2161: actually contains the first part of a `double'. That would lead to
2162: really incorrect and confusing output at debug-time, and we don't
2163: want that now do we?
2164:
2165: So in general, we DO NOT use DECL_INCOMING_RTL as a backup for DECL_RTL
2166: in cases where DECL_ARG_TYPE(decl) != TREE_TYPE(decl). There are a
2167: couple of cute exceptions however. On little-endian machines we can
2168: get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE(decl) is
2169: not the same as TREE_TYPE(decl) but only when DECL_ARG_TYPE(decl) is
2170: an integral type which is smaller than TREE_TYPE(decl). These cases
2171: arise when (on a little-endian machine) a non-prototyped function has
2172: a parameter declared to be of type `short' or `char'. In such cases,
2173: TREE_TYPE(decl) will be `short' or `char', DECL_ARG_TYPE(decl) will be
2174: `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
2175: passed `int' value. If the debugger then uses that address to fetch a
2176: `short' or a `char' (on a little-endian machine) the result will be the
2177: correct data, so we allow for such exceptional cases below.
2178:
2179: Note that our goal here is to describe the place where the given formal
2180: parameter lives during most of the function's activation (i.e. between
2181: the end of the prologue and the start of the epilogue). We'll do that
2182: as best as we can. Note however that if the given formal parameter is
2183: modified sometime during the execution of the function, then a stack
2184: backtrace (at debug-time) will show the function as having been called
2185: with the *new* value rather than the value which was originally passed
2186: in. This happens rarely enough that it is not a major problem, but it
2187: *is* a problem, and I'd like to fix it. A future version of dwarfout.c
2188: may generate two additional attributes for any given TAG_formal_parameter
2189: DIE which will describe the "passed type" and the "passed location" for
2190: the given formal parameter in addition to the attributes we now generate
2191: to indicate the "declared type" and the "active location" for each
2192: parameter. This additional set of attributes could be used by debuggers
2193: for stack backtraces.
2194:
2195: Separately, note that sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL
2196: can be NULL also. This happens (for example) for inlined-instances of
2197: inline function formal parameters which are never referenced. This really
2198: shouldn't be happening. All PARM_DECL nodes should get valid non-NULL
2199: DECL_INCOMING_RTL values, but integrate.c doesn't currently generate
2200: these values for inlined instances of inline function parameters, so
2201: when we see such cases, we are just SOL (shit-out-of-luck) for the time
2202: being (until integrate.c gets fixed).
2203: */
2204:
2205: /* Use DECL_RTL as the "location" unless we find something better. */
2206: rtl = DECL_RTL (decl);
2207:
2208: if (TREE_CODE (decl) == PARM_DECL)
2209: if (rtl == NULL_RTX || is_pseudo_reg (rtl))
2210: {
2211: /* This decl represents a formal parameter which was optimized out. */
2212: register tree declared_type = type_main_variant (TREE_TYPE (decl));
2213: register tree passed_type = type_main_variant (DECL_ARG_TYPE (decl));
2214:
2215: /* Note that DECL_INCOMING_RTL may be NULL in here, but we handle
2216: *all* cases where (rtl == NULL_RTX) just below. */
2217:
2218: if (declared_type == passed_type)
2219: rtl = DECL_INCOMING_RTL (decl);
2220: #if (BYTES_BIG_ENDIAN == 0)
2221: else
2222: if (TREE_CODE (declared_type) == INTEGER_TYPE)
2223: if (TYPE_SIZE (declared_type) <= TYPE_SIZE (passed_type))
2224: rtl = DECL_INCOMING_RTL (decl);
2225: #endif /* (BYTES_BIG_ENDIAN == 0) */
2226: }
2227:
2228: if (rtl == NULL_RTX)
2229: return;
2230:
2231: switch (GET_CODE (rtl))
2232: {
2233: case CONST_INT:
2234: case CONST_DOUBLE:
2235: case CONST_STRING:
2236: case SYMBOL_REF:
2237: case LABEL_REF:
2238: case CONST:
2239: case PLUS: /* DECL_RTL could be (plus (reg ...) (const_int ...)) */
2240: const_value_attribute (rtl);
2241: break;
2242:
2243: case MEM:
2244: case REG:
2245: case SUBREG:
2246: location_attribute (rtl);
2247: break;
2248:
2249: default:
2250: abort (); /* Should never happen. */
2251: }
2252: }
2253:
2254: /* Generate an AT_name attribute given some string value to be included as
2255: the value of the attribute. */
2256:
2257: inline void
2258: name_attribute (name_string)
2259: register char *name_string;
2260: {
2261: if (name_string && *name_string)
2262: {
2263: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_name);
2264: ASM_OUTPUT_DWARF_STRING (asm_out_file, name_string);
2265: }
2266: }
2267:
2268: inline void
2269: fund_type_attribute (ft_code)
2270: register unsigned ft_code;
2271: {
2272: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_fund_type);
2273: ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file, ft_code);
2274: }
2275:
2276: static void
2277: mod_fund_type_attribute (type, decl_const, decl_volatile)
2278: register tree type;
2279: register int decl_const;
2280: register int decl_volatile;
2281: {
2282: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
2283: char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2284:
2285: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_mod_fund_type);
2286: sprintf (begin_label, MT_BEGIN_LABEL_FMT, current_dienum);
2287: sprintf (end_label, MT_END_LABEL_FMT, current_dienum);
2288: ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
2289: ASM_OUTPUT_LABEL (asm_out_file, begin_label);
2290: write_modifier_bytes (type, decl_const, decl_volatile);
2291: ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file,
2292: fundamental_type_code (root_type (type)));
2293: ASM_OUTPUT_LABEL (asm_out_file, end_label);
2294: }
2295:
2296: inline void
2297: user_def_type_attribute (type)
2298: register tree type;
2299: {
2300: char ud_type_name[MAX_ARTIFICIAL_LABEL_BYTES];
2301:
2302: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_user_def_type);
2303: sprintf (ud_type_name, TYPE_NAME_FMT, TYPE_UID (type));
2304: ASM_OUTPUT_DWARF_REF (asm_out_file, ud_type_name);
2305: }
2306:
2307: static void
2308: mod_u_d_type_attribute (type, decl_const, decl_volatile)
2309: register tree type;
2310: register int decl_const;
2311: register int decl_volatile;
2312: {
2313: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
2314: char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2315: char ud_type_name[MAX_ARTIFICIAL_LABEL_BYTES];
2316:
2317: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_mod_u_d_type);
2318: sprintf (begin_label, MT_BEGIN_LABEL_FMT, current_dienum);
2319: sprintf (end_label, MT_END_LABEL_FMT, current_dienum);
2320: ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
2321: ASM_OUTPUT_LABEL (asm_out_file, begin_label);
2322: write_modifier_bytes (type, decl_const, decl_volatile);
2323: sprintf (ud_type_name, TYPE_NAME_FMT, TYPE_UID (root_type (type)));
2324: ASM_OUTPUT_DWARF_REF (asm_out_file, ud_type_name);
2325: ASM_OUTPUT_LABEL (asm_out_file, end_label);
2326: }
2327:
2328: #ifdef USE_ORDERING_ATTRIBUTE
2329: inline void
2330: ordering_attribute (ordering)
2331: register unsigned ordering;
2332: {
2333: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_ordering);
2334: ASM_OUTPUT_DWARF_DATA2 (asm_out_file, ordering);
2335: }
2336: #endif /* defined(USE_ORDERING_ATTRIBUTE) */
2337:
2338: /* Note that the block of subscript information for an array type also
2339: includes information about the element type of type given array type. */
2340:
2341: static void
2342: subscript_data_attribute (type)
2343: register tree type;
2344: {
2345: register unsigned dimension_number;
2346: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
2347: char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2348:
2349: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_subscr_data);
2350: sprintf (begin_label, SS_BEGIN_LABEL_FMT, current_dienum);
2351: sprintf (end_label, SS_END_LABEL_FMT, current_dienum);
2352: ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
2353: ASM_OUTPUT_LABEL (asm_out_file, begin_label);
2354:
2355: /* The GNU compilers represent multidimensional array types as sequences
2356: of one dimensional array types whose element types are themselves array
2357: types. Here we squish that down, so that each multidimensional array
2358: type gets only one array_type DIE in the Dwarf debugging info. The
2359: draft Dwarf specification say that we are allowed to do this kind
2360: of compression in C (because there is no difference between an
2361: array or arrays and a multidimensional array in C) but for other
2362: source languages (e.g. Ada) we probably shouldn't do this. */
2363:
2364: for (dimension_number = 0;
2365: TREE_CODE (type) == ARRAY_TYPE;
2366: type = TREE_TYPE (type), dimension_number++)
2367: {
2368: register tree domain = TYPE_DOMAIN (type);
2369:
2370: /* Arrays come in three flavors. Unspecified bounds, fixed
2371: bounds, and (in GNU C only) variable bounds. Handle all
2372: three forms here. */
2373:
2374: if (domain)
2375: {
2376: /* We have an array type with specified bounds. */
2377:
2378: register tree lower = TYPE_MIN_VALUE (domain);
2379: register tree upper = TYPE_MAX_VALUE (domain);
2380:
2381: /* Handle only fundamental types as index types for now. */
2382:
2383: if (! type_is_fundamental (domain))
2384: abort ();
2385:
2386: /* Output the representation format byte for this dimension. */
2387:
2388: ASM_OUTPUT_DWARF_FMT_BYTE (asm_out_file,
2389: FMT_CODE (1,
2390: TREE_CODE (lower) == INTEGER_CST,
2391: TREE_CODE (upper) == INTEGER_CST));
2392:
2393: /* Output the index type for this dimension. */
2394:
2395: ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file,
2396: fundamental_type_code (domain));
2397:
2398: /* Output the representation for the lower bound. */
2399:
2400: output_bound_representation (lower, dimension_number, 'l');
2401:
2402: /* Output the representation for the upper bound. */
2403:
2404: output_bound_representation (upper, dimension_number, 'u');
2405: }
2406: else
2407: {
2408: /* We have an array type with an unspecified length. For C and
2409: C++ we can assume that this really means that (a) the index
2410: type is an integral type, and (b) the lower bound is zero.
2411: Note that Dwarf defines the representation of an unspecified
2412: (upper) bound as being a zero-length location description. */
2413:
2414: /* Output the array-bounds format byte. */
2415:
2416: ASM_OUTPUT_DWARF_FMT_BYTE (asm_out_file, FMT_FT_C_X);
2417:
2418: /* Output the (assumed) index type. */
2419:
2420: ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file, FT_integer);
2421:
2422: /* Output the (assumed) lower bound (constant) value. */
2423:
2424: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
2425:
2426: /* Output the (empty) location description for the upper bound. */
2427:
2428: ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 0);
2429: }
2430: }
2431:
2432: /* Output the prefix byte that says that the element type is comming up. */
2433:
2434: ASM_OUTPUT_DWARF_FMT_BYTE (asm_out_file, FMT_ET);
2435:
2436: /* Output a representation of the type of the elements of this array type. */
2437:
2438: type_attribute (type, 0, 0);
2439:
2440: ASM_OUTPUT_LABEL (asm_out_file, end_label);
2441: }
2442:
2443: static void
2444: byte_size_attribute (tree_node)
2445: register tree tree_node;
2446: {
2447: register unsigned size;
2448:
2449: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_byte_size);
2450: switch (TREE_CODE (tree_node))
2451: {
2452: case ERROR_MARK:
2453: size = 0;
2454: break;
2455:
2456: case ENUMERAL_TYPE:
2457: case RECORD_TYPE:
2458: case UNION_TYPE:
2459: case QUAL_UNION_TYPE:
2460: size = int_size_in_bytes (tree_node);
2461: break;
2462:
2463: case FIELD_DECL:
2464: /* For a data member of a struct or union, the AT_byte_size is
2465: generally given as the number of bytes normally allocated for
2466: an object of the *declared* type of the member itself. This
2467: is true even for bit-fields. */
2468: size = simple_type_size_in_bits (field_type (tree_node))
2469: / BITS_PER_UNIT;
2470: break;
2471:
2472: default:
2473: abort ();
2474: }
2475:
2476: /* Note that `size' might be -1 when we get to this point. If it
2477: is, that indicates that the byte size of the entity in question
2478: is variable. We have no good way of expressing this fact in Dwarf
2479: at the present time, so just let the -1 pass on through. */
2480:
2481: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, size);
2482: }
2483:
2484: /* For a FIELD_DECL node which represents a bit-field, output an attribute
2485: which specifies the distance in bits from the highest order bit of the
2486: "containing object" for the bit-field to the highest order bit of the
2487: bit-field itself.
2488:
2489: For any given bit-field, the "containing object" is a hypothetical
2490: object (of some integral or enum type) within which the given bit-field
2491: lives. The type of this hypothetical "containing object" is always the
2492: same as the declared type of the individual bit-field itself.
2493:
2494: The determination of the exact location of the "containing object" for
2495: a bit-field is rather complicated. It's handled by the `field_byte_offset'
2496: function (above).
2497:
2498: Note that it is the size (in bytes) of the hypothetical "containing
2499: object" which will be given in the AT_byte_size attribute for this
2500: bit-field. (See `byte_size_attribute' above.)
2501: */
2502:
2503: inline void
2504: bit_offset_attribute (decl)
2505: register tree decl;
2506: {
2507: register unsigned object_offset_in_bytes = field_byte_offset (decl);
2508: register tree type = DECL_BIT_FIELD_TYPE (decl);
2509: register tree bitpos_tree = DECL_FIELD_BITPOS (decl);
2510: register unsigned bitpos_int;
2511: register unsigned highest_order_object_bit_offset;
2512: register unsigned highest_order_field_bit_offset;
2513: register unsigned bit_offset;
2514:
2515: assert (TREE_CODE (decl) == FIELD_DECL); /* Must be a field. */
2516: assert (type); /* Must be a bit field. */
2517:
2518: /* We can't yet handle bit-fields whose offsets are variable, so if we
2519: encounter such things, just return without generating any attribute
2520: whatsoever. */
2521:
2522: if (TREE_CODE (bitpos_tree) != INTEGER_CST)
2523: return;
2524: bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
2525:
2526: /* Note that the bit offset is always the distance (in bits) from the
2527: highest-order bit of the "containing object" to the highest-order
2528: bit of the bit-field itself. Since the "high-order end" of any
2529: object or field is different on big-endian and little-endian machines,
2530: the computation below must take account of these differences. */
2531:
2532: highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
2533: highest_order_field_bit_offset = bitpos_int;
2534:
2535: #if (BYTES_BIG_ENDIAN == 0)
2536: highest_order_field_bit_offset
2537: += (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl));
2538:
2539: highest_order_object_bit_offset += simple_type_size_in_bits (type);
2540: #endif /* (BYTES_BIG_ENDIAN == 0) */
2541:
2542: bit_offset =
2543: #if (BYTES_BIG_ENDIAN == 0)
2544: highest_order_object_bit_offset - highest_order_field_bit_offset;
2545: #else /* (BYTES_BIG_ENDIAN != 0) */
2546: highest_order_field_bit_offset - highest_order_object_bit_offset;
2547: #endif /* (BYTES_BIG_ENDIAN != 0) */
2548:
2549: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_bit_offset);
2550: ASM_OUTPUT_DWARF_DATA2 (asm_out_file, bit_offset);
2551: }
2552:
2553: /* For a FIELD_DECL node which represents a bit field, output an attribute
2554: which specifies the length in bits of the given field. */
2555:
2556: inline void
2557: bit_size_attribute (decl)
2558: register tree decl;
2559: {
2560: assert (TREE_CODE (decl) == FIELD_DECL); /* Must be a field. */
2561: assert (DECL_BIT_FIELD_TYPE (decl)); /* Must be a bit field. */
2562:
2563: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_bit_size);
2564: ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
2565: (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl)));
2566: }
2567:
2568: /* The following routine outputs the `element_list' attribute for enumeration
2569: type DIEs. The element_lits attribute includes the names and values of
2570: all of the enumeration constants associated with the given enumeration
2571: type. */
2572:
2573: inline void
2574: element_list_attribute (element)
2575: register tree element;
2576: {
2577: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
2578: char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2579:
2580: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_element_list);
2581: sprintf (begin_label, EE_BEGIN_LABEL_FMT, current_dienum);
2582: sprintf (end_label, EE_END_LABEL_FMT, current_dienum);
2583: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, end_label, begin_label);
2584: ASM_OUTPUT_LABEL (asm_out_file, begin_label);
2585:
2586: /* Here we output a list of value/name pairs for each enumeration constant
2587: defined for this enumeration type (as required), but we do it in REVERSE
2588: order. The order is the one required by the draft #5 Dwarf specification
2589: published by the UI/PLSIG. */
2590:
2591: output_enumeral_list (element); /* Recursively output the whole list. */
2592:
2593: ASM_OUTPUT_LABEL (asm_out_file, end_label);
2594: }
2595:
2596: /* Generate an AT_stmt_list attribute. These are normally present only in
2597: DIEs with a TAG_compile_unit tag. */
2598:
2599: inline void
2600: stmt_list_attribute (label)
2601: register char *label;
2602: {
2603: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_stmt_list);
2604: /* Don't use ASM_OUTPUT_DWARF_DATA4 here. */
2605: ASM_OUTPUT_DWARF_ADDR (asm_out_file, label);
2606: }
2607:
2608: /* Generate an AT_low_pc attribute for a label DIE, a lexical_block DIE or
2609: for a subroutine DIE. */
2610:
2611: inline void
2612: low_pc_attribute (asm_low_label)
2613: register char *asm_low_label;
2614: {
2615: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_low_pc);
2616: ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_low_label);
2617: }
2618:
2619: /* Generate an AT_high_pc attribute for a lexical_block DIE or for a
2620: subroutine DIE. */
2621:
2622: inline void
2623: high_pc_attribute (asm_high_label)
2624: register char *asm_high_label;
2625: {
2626: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_high_pc);
2627: ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_high_label);
2628: }
2629:
2630: /* Generate an AT_body_begin attribute for a subroutine DIE. */
2631:
2632: inline void
2633: body_begin_attribute (asm_begin_label)
2634: register char *asm_begin_label;
2635: {
2636: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_body_begin);
2637: ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_begin_label);
2638: }
2639:
2640: /* Generate an AT_body_end attribute for a subroutine DIE. */
2641:
2642: inline void
2643: body_end_attribute (asm_end_label)
2644: register char *asm_end_label;
2645: {
2646: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_body_end);
2647: ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_end_label);
2648: }
2649:
2650: /* Generate an AT_language attribute given a LANG value. These attributes
2651: are used only within TAG_compile_unit DIEs. */
2652:
2653: inline void
2654: language_attribute (language_code)
2655: register unsigned language_code;
2656: {
2657: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_language);
2658: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, language_code);
2659: }
2660:
2661: inline void
2662: member_attribute (context)
2663: register tree context;
2664: {
2665: char label[MAX_ARTIFICIAL_LABEL_BYTES];
2666:
2667: /* Generate this attribute only for members in C++. */
2668:
2669: if (context != NULL && is_tagged_type (context))
2670: {
2671: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_member);
2672: sprintf (label, TYPE_NAME_FMT, TYPE_UID (context));
2673: ASM_OUTPUT_DWARF_REF (asm_out_file, label);
2674: }
2675: }
2676:
2677: inline void
2678: string_length_attribute (upper_bound)
2679: register tree upper_bound;
2680: {
2681: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
2682: char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2683:
2684: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_string_length);
2685: sprintf (begin_label, SL_BEGIN_LABEL_FMT, current_dienum);
2686: sprintf (end_label, SL_END_LABEL_FMT, current_dienum);
2687: ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, end_label, begin_label);
2688: ASM_OUTPUT_LABEL (asm_out_file, begin_label);
2689: output_bound_representation (upper_bound, 0, 'u');
2690: ASM_OUTPUT_LABEL (asm_out_file, end_label);
2691: }
2692:
2693: inline void
2694: comp_dir_attribute (dirname)
2695: register char *dirname;
2696: {
2697: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_comp_dir);
2698: ASM_OUTPUT_DWARF_STRING (asm_out_file, dirname);
2699: }
2700:
2701: inline void
2702: sf_names_attribute (sf_names_start_label)
2703: register char *sf_names_start_label;
2704: {
2705: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_sf_names);
2706: /* Don't use ASM_OUTPUT_DWARF_DATA4 here. */
2707: ASM_OUTPUT_DWARF_ADDR (asm_out_file, sf_names_start_label);
2708: }
2709:
2710: inline void
2711: src_info_attribute (src_info_start_label)
2712: register char *src_info_start_label;
2713: {
2714: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_src_info);
2715: /* Don't use ASM_OUTPUT_DWARF_DATA4 here. */
2716: ASM_OUTPUT_DWARF_ADDR (asm_out_file, src_info_start_label);
2717: }
2718:
2719: inline void
2720: mac_info_attribute (mac_info_start_label)
2721: register char *mac_info_start_label;
2722: {
2723: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_mac_info);
2724: /* Don't use ASM_OUTPUT_DWARF_DATA4 here. */
2725: ASM_OUTPUT_DWARF_ADDR (asm_out_file, mac_info_start_label);
2726: }
2727:
2728: inline void
2729: prototyped_attribute (func_type)
2730: register tree func_type;
2731: {
2732: if ((strcmp (language_string, "GNU C") == 0)
2733: && (TYPE_ARG_TYPES (func_type) != NULL))
2734: {
2735: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_prototyped);
2736: ASM_OUTPUT_DWARF_STRING (asm_out_file, "");
2737: }
2738: }
2739:
2740: inline void
2741: producer_attribute (producer)
2742: register char *producer;
2743: {
2744: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_producer);
2745: ASM_OUTPUT_DWARF_STRING (asm_out_file, producer);
2746: }
2747:
2748: inline void
2749: inline_attribute (decl)
2750: register tree decl;
2751: {
2752: if (DECL_INLINE (decl))
2753: {
2754: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_inline);
2755: ASM_OUTPUT_DWARF_STRING (asm_out_file, "");
2756: }
2757: }
2758:
2759: inline void
2760: containing_type_attribute (containing_type)
2761: register tree containing_type;
2762: {
2763: char label[MAX_ARTIFICIAL_LABEL_BYTES];
2764:
2765: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_containing_type);
2766: sprintf (label, TYPE_NAME_FMT, TYPE_UID (containing_type));
2767: ASM_OUTPUT_DWARF_REF (asm_out_file, label);
2768: }
2769:
2770: inline void
2771: abstract_origin_attribute (origin)
2772: register tree origin;
2773: {
2774: char label[MAX_ARTIFICIAL_LABEL_BYTES];
2775:
2776: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_abstract_origin);
2777: switch (TREE_CODE_CLASS (TREE_CODE (origin)))
2778: {
2779: case 'd':
2780: sprintf (label, DECL_NAME_FMT, DECL_UID (origin));
2781: break;
2782:
2783: case 't':
2784: sprintf (label, TYPE_NAME_FMT, TYPE_UID (origin));
2785: break;
2786:
2787: default:
2788: abort (); /* Should never happen. */
2789:
2790: }
2791: ASM_OUTPUT_DWARF_REF (asm_out_file, label);
2792: }
2793:
2794: #ifdef DWARF_DECL_COORDINATES
2795: inline void
2796: src_coords_attribute (src_fileno, src_lineno)
2797: register unsigned src_fileno;
2798: register unsigned src_lineno;
2799: {
2800: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_src_coords);
2801: ASM_OUTPUT_DWARF_DATA2 (asm_out_file, src_fileno);
2802: ASM_OUTPUT_DWARF_DATA2 (asm_out_file, src_lineno);
2803: }
2804: #endif /* defined(DWARF_DECL_COORDINATES) */
2805:
2806: inline void
2807: pure_or_virtual_attribute (func_decl)
2808: register tree func_decl;
2809: {
2810: if (DECL_VIRTUAL_P (func_decl))
2811: {
2812: #if 0 /* DECL_ABSTRACT_VIRTUAL_P is C++-specific. */
2813: if (DECL_ABSTRACT_VIRTUAL_P (func_decl))
2814: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_pure_virtual);
2815: else
2816: #endif
2817: ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_virtual);
2818: ASM_OUTPUT_DWARF_STRING (asm_out_file, "");
2819: }
2820: }
2821:
2822: /************************* end of attributes *****************************/
2823:
2824: /********************* utility routines for DIEs *************************/
2825:
2826: /* Output an AT_name attribute and an AT_src_coords attribute for the
2827: given decl, but only if it actually has a name. */
2828:
2829: static void
2830: name_and_src_coords_attributes (decl)
2831: register tree decl;
2832: {
2833: register tree decl_name = DECL_NAME (decl);
2834:
2835: if (decl_name && IDENTIFIER_POINTER (decl_name))
2836: {
2837: name_attribute (IDENTIFIER_POINTER (decl_name));
2838: #ifdef DWARF_DECL_COORDINATES
2839: {
2840: register unsigned file_index;
2841:
2842: /* This is annoying, but we have to pop out of the .debug section
2843: for a moment while we call `lookup_filename' because calling it
2844: may cause a temporary switch into the .debug_sfnames section and
2845: most svr4 assemblers are not smart enough be be able to nest
2846: section switches to any depth greater than one. Note that we
2847: also can't skirt this issue by delaying all output to the
2848: .debug_sfnames section unit the end of compilation because that
2849: would cause us to have inter-section forward references and
2850: Fred Fish sez that m68k/svr4 assemblers botch those. */
2851:
2852: ASM_OUTPUT_POP_SECTION (asm_out_file);
2853: file_index = lookup_filename (DECL_SOURCE_FILE (decl));
2854: ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SECTION);
2855:
2856: src_coords_attribute (file_index, DECL_SOURCE_LINE (decl));
2857: }
2858: #endif /* defined(DWARF_DECL_COORDINATES) */
2859: }
2860: }
2861:
2862: /* Many forms of DIEs contain a "type description" part. The following
2863: routine writes out these "type descriptor" parts. */
2864:
2865: static void
2866: type_attribute (type, decl_const, decl_volatile)
2867: register tree type;
2868: register int decl_const;
2869: register int decl_volatile;
2870: {
2871: register enum tree_code code = TREE_CODE (type);
2872: register int root_type_modified;
2873:
2874: if (TREE_CODE (type) == ERROR_MARK)
2875: return;
2876:
2877: /* Handle a special case. For functions whose return type is void,
2878: we generate *no* type attribute. (Note that no object may have
2879: type `void', so this only applies to function return types. */
2880:
2881: if (TREE_CODE (type) == VOID_TYPE)
2882: return;
2883:
2884: root_type_modified = (code == POINTER_TYPE || code == REFERENCE_TYPE
2885: || decl_const || decl_volatile
2886: || TYPE_READONLY (type) || TYPE_VOLATILE (type));
2887:
2888: if (type_is_fundamental (root_type (type)))
2889: if (root_type_modified)
2890: mod_fund_type_attribute (type, decl_const, decl_volatile);
2891: else
2892: fund_type_attribute (fundamental_type_code (type));
2893: else
2894: if (root_type_modified)
2895: mod_u_d_type_attribute (type, decl_const, decl_volatile);
2896: else
2897: /* We have to get the type_main_variant here (and pass that to the
2898: `user_def_type_attribute' routine) because the ..._TYPE node we
2899: have might simply be a *copy* of some original type node (where
2900: the copy was created to help us keep track of typedef names)
2901: and that copy might have a different TYPE_UID from the original
2902: ..._TYPE node. (Note that when `equate_type_number_to_die_number'
2903: is labeling a given type DIE for future reference, it always and
2904: only creates labels for DIEs representing *main variants*, and it
2905: never even knows about non-main-variants.) */
2906: user_def_type_attribute (type_main_variant (type));
2907: }
2908:
2909: /* Given a tree pointer to a struct, class, union, or enum type node, return
2910: a pointer to the (string) tag name for the given type, or zero if the
2911: type was declared without a tag. */
2912:
2913: static char *
2914: type_tag (type)
2915: register tree type;
2916: {
2917: register char *name = 0;
2918:
2919: if (TYPE_NAME (type) != 0)
2920: {
2921: register tree t = 0;
2922:
2923: /* Find the IDENTIFIER_NODE for the type name. */
2924: if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
2925: t = TYPE_NAME (type);
2926: #if 0
2927: /* The g++ front end makes the TYPE_NAME of *each* tagged type point
2928: to a TYPE_DECL node, regardless of whether or not a `typedef' was
2929: involved. This is distinctly different from what the gcc front-end
2930: does. It always makes the TYPE_NAME for each tagged type be either
2931: NULL (signifying an anonymous tagged type) or else a pointer to an
2932: IDENTIFIER_NODE. Obviously, we would like to generate correct Dwarf
2933: for both C and C++, but given this inconsistency in the TREE
2934: representation of tagged types for C and C++ in the GNU front-ends,
2935: we cannot support both languages correctly unless we introduce some
2936: front-end specific code here, and rms objects to that, so we can
2937: only generate correct Dwarf for one of these two languages. C is
2938: more important, so for now we'll do the right thing for C and let
2939: g++ go fish. */
2940:
2941: else
2942: if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2943: t = DECL_NAME (TYPE_NAME (type));
2944: #endif
2945: /* Now get the name as a string, or invent one. */
2946: if (t != 0)
2947: name = IDENTIFIER_POINTER (t);
2948: }
2949:
2950: return (name == 0 || *name == '\0') ? 0 : name;
2951: }
2952:
2953: inline void
2954: dienum_push ()
2955: {
2956: /* Start by checking if the pending_sibling_stack needs to be expanded.
2957: If necessary, expand it. */
2958:
2959: if (pending_siblings == pending_siblings_allocated)
2960: {
2961: pending_siblings_allocated += PENDING_SIBLINGS_INCREMENT;
2962: pending_sibling_stack
2963: = (unsigned *) xrealloc (pending_sibling_stack,
2964: pending_siblings_allocated * sizeof(unsigned));
2965: }
2966:
2967: pending_siblings++;
2968: NEXT_DIE_NUM = next_unused_dienum++;
2969: }
2970:
2971: /* Pop the sibling stack so that the most recently pushed DIEnum becomes the
2972: NEXT_DIE_NUM. */
2973:
2974: inline void
2975: dienum_pop ()
2976: {
2977: pending_siblings--;
2978: }
2979:
2980: inline tree
2981: member_declared_type (member)
2982: register tree member;
2983: {
2984: return (DECL_BIT_FIELD_TYPE (member))
2985: ? DECL_BIT_FIELD_TYPE (member)
2986: : TREE_TYPE (member);
2987: }
2988:
2989: /* Get the function's label, as described by its RTL.
2990: This may be different from the DECL_NAME name used
2991: in the source file. */
2992:
2993: static char *
2994: function_start_label (decl)
2995: register tree decl;
2996: {
2997: rtx x;
2998: char *fnname;
2999:
3000: x = DECL_RTL (decl);
3001: if (GET_CODE (x) != MEM)
3002: abort ();
3003: x = XEXP (x, 0);
3004: if (GET_CODE (x) != SYMBOL_REF)
3005: abort ();
3006: fnname = XSTR (x, 0);
3007: return fnname;
3008: }
3009:
3010:
3011: /******************************* DIEs ************************************/
3012:
3013: /* Output routines for individual types of DIEs. */
3014:
3015: /* Note that every type of DIE (except a null DIE) gets a sibling. */
3016:
3017: static void
3018: output_array_type_die (arg)
3019: register void *arg;
3020: {
3021: register tree type = arg;
3022:
3023: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_array_type);
3024: sibling_attribute ();
3025: equate_type_number_to_die_number (type);
3026: member_attribute (TYPE_CONTEXT (type));
3027:
3028: /* I believe that we can default the array ordering. SDB will probably
3029: do the right things even if AT_ordering is not present. It's not
3030: even an issue until we start to get into multidimensional arrays
3031: anyway. If SDB is ever caught doing the Wrong Thing for multi-
3032: dimensional arrays, then we'll have to put the AT_ordering attribute
3033: back in. (But if and when we find out that we need to put these in,
3034: we will only do so for multidimensional arrays. After all, we don't
3035: want to waste space in the .debug section now do we?) */
3036:
3037: #ifdef USE_ORDERING_ATTRIBUTE
3038: ordering_attribute (ORD_row_major);
3039: #endif /* defined(USE_ORDERING_ATTRIBUTE) */
3040:
3041: subscript_data_attribute (type);
3042: }
3043:
3044: static void
3045: output_set_type_die (arg)
3046: register void *arg;
3047: {
3048: register tree type = arg;
3049:
3050: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_set_type);
3051: sibling_attribute ();
3052: equate_type_number_to_die_number (type);
3053: member_attribute (TYPE_CONTEXT (type));
3054: type_attribute (TREE_TYPE (type), 0, 0);
3055: }
3056:
3057: #if 0
3058: /* Implement this when there is a GNU FORTRAN or GNU Ada front end. */
3059: static void
3060: output_entry_point_die (arg)
3061: register void *arg;
3062: {
3063: register tree decl = arg;
3064: register tree origin = decl_ultimate_origin (decl);
3065:
3066: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_entry_point);
3067: sibling_attribute ();
3068: dienum_push ();
3069: if (origin != NULL)
3070: abstract_origin_attribute (origin);
3071: else
3072: {
3073: name_and_src_coords_attributes (decl);
3074: member_attribute (DECL_CONTEXT (decl));
3075: type_attribute (TREE_TYPE (TREE_TYPE (decl)), 0, 0);
3076: }
3077: if (DECL_ABSTRACT (decl))
3078: equate_decl_number_to_die_number (decl);
3079: else
3080: low_pc_attribute (function_start_label (decl));
3081: }
3082: #endif
3083:
3084: /* Output a DIE to represent an inlined instance of an enumeration type. */
3085:
3086: static void
3087: output_inlined_enumeration_type_die (arg)
3088: register void *arg;
3089: {
3090: register tree type = arg;
3091:
3092: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_enumeration_type);
3093: sibling_attribute ();
3094: assert (TREE_ASM_WRITTEN (type));
3095: abstract_origin_attribute (type);
3096: }
3097:
3098: /* Output a DIE to represent an inlined instance of a structure type. */
3099:
3100: static void
3101: output_inlined_structure_type_die (arg)
3102: register void *arg;
3103: {
3104: register tree type = arg;
3105:
3106: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_structure_type);
3107: sibling_attribute ();
3108: assert (TREE_ASM_WRITTEN (type));
3109: abstract_origin_attribute (type);
3110: }
3111:
3112: /* Output a DIE to represent an inlined instance of a union type. */
3113:
3114: static void
3115: output_inlined_union_type_die (arg)
3116: register void *arg;
3117: {
3118: register tree type = arg;
3119:
3120: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_union_type);
3121: sibling_attribute ();
3122: assert (TREE_ASM_WRITTEN (type));
3123: abstract_origin_attribute (type);
3124: }
3125:
3126: /* Output a DIE to represent an enumeration type. Note that these DIEs
3127: include all of the information about the enumeration values also.
3128: This information is encoded into the element_list attribute. */
3129:
3130: static void
3131: output_enumeration_type_die (arg)
3132: register void *arg;
3133: {
3134: register tree type = arg;
3135:
3136: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_enumeration_type);
3137: sibling_attribute ();
3138: equate_type_number_to_die_number (type);
3139: name_attribute (type_tag (type));
3140: member_attribute (TYPE_CONTEXT (type));
3141:
3142: /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
3143: given enum type is incomplete, do not generate the AT_byte_size
3144: attribute or the AT_element_list attribute. */
3145:
3146: if (TYPE_SIZE (type))
3147: {
3148: byte_size_attribute (type);
3149: element_list_attribute (TYPE_FIELDS (type));
3150: }
3151: }
3152:
3153: /* Output a DIE to represent either a real live formal parameter decl or
3154: to represent just the type of some formal parameter position in some
3155: function type.
3156:
3157: Note that this routine is a bit unusual because its argument may be
3158: a ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
3159: represents an inlining of some PARM_DECL) or else some sort of a
3160: ..._TYPE node. If it's the former then this function is being called
3161: to output a DIE to represent a formal parameter object (or some inlining
3162: thereof). If it's the latter, then this function is only being called
3163: to output a TAG_formal_parameter DIE to stand as a placeholder for some
3164: formal argument type of some subprogram type. */
3165:
3166: static void
3167: output_formal_parameter_die (arg)
3168: register void *arg;
3169: {
3170: register tree node = arg;
3171:
3172: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_formal_parameter);
3173: sibling_attribute ();
3174:
3175: switch (TREE_CODE_CLASS (TREE_CODE (node)))
3176: {
3177: case 'd': /* We were called with some kind of a ..._DECL node. */
3178: {
3179: register tree origin = decl_ultimate_origin (node);
3180:
3181: if (origin != NULL)
3182: abstract_origin_attribute (origin);
3183: else
3184: {
3185: name_and_src_coords_attributes (node);
3186: type_attribute (TREE_TYPE (node),
3187: TREE_READONLY (node), TREE_THIS_VOLATILE (node));
3188: }
3189: if (DECL_ABSTRACT (node))
3190: equate_decl_number_to_die_number (node);
3191: else
3192: location_or_const_value_attribute (node);
3193: }
3194: break;
3195:
3196: case 't': /* We were called with some kind of a ..._TYPE node. */
3197: type_attribute (node, 0, 0);
3198: break;
3199:
3200: default:
3201: abort (); /* Should never happen. */
3202: }
3203: }
3204:
3205: /* Output a DIE to represent a declared function (either file-scope
3206: or block-local) which has "external linkage" (according to ANSI-C). */
3207:
3208: static void
3209: output_global_subroutine_die (arg)
3210: register void *arg;
3211: {
3212: register tree decl = arg;
3213: register tree origin = decl_ultimate_origin (decl);
3214:
3215: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_global_subroutine);
3216: sibling_attribute ();
3217: dienum_push ();
3218: if (origin != NULL)
3219: abstract_origin_attribute (origin);
3220: else
3221: {
3222: register tree type = TREE_TYPE (decl);
3223:
3224: name_and_src_coords_attributes (decl);
3225: inline_attribute (decl);
3226: prototyped_attribute (type);
3227: member_attribute (DECL_CONTEXT (decl));
3228: type_attribute (TREE_TYPE (type), 0, 0);
3229: pure_or_virtual_attribute (decl);
3230: }
3231: if (DECL_ABSTRACT (decl))
3232: equate_decl_number_to_die_number (decl);
3233: else
3234: {
3235: if (! DECL_EXTERNAL (decl))
3236: {
3237: char label[MAX_ARTIFICIAL_LABEL_BYTES];
3238:
3239: low_pc_attribute (function_start_label (decl));
3240: sprintf (label, FUNC_END_LABEL_FMT, current_funcdef_number);
3241: high_pc_attribute (label);
3242: sprintf (label, BODY_BEGIN_LABEL_FMT, current_funcdef_number);
3243: body_begin_attribute (label);
3244: sprintf (label, BODY_END_LABEL_FMT, current_funcdef_number);
3245: body_end_attribute (label);
3246: }
3247: }
3248: }
3249:
3250: /* Output a DIE to represent a declared data object (either file-scope
3251: or block-local) which has "external linkage" (according to ANSI-C). */
3252:
3253: static void
3254: output_global_variable_die (arg)
3255: register void *arg;
3256: {
3257: register tree decl = arg;
3258: register tree origin = decl_ultimate_origin (decl);
3259:
3260: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_global_variable);
3261: sibling_attribute ();
3262: if (origin != NULL)
3263: abstract_origin_attribute (origin);
3264: else
3265: {
3266: name_and_src_coords_attributes (decl);
3267: member_attribute (DECL_CONTEXT (decl));
3268: type_attribute (TREE_TYPE (decl),
3269: TREE_READONLY (decl), TREE_THIS_VOLATILE (decl));
3270: }
3271: if (DECL_ABSTRACT (decl))
3272: equate_decl_number_to_die_number (decl);
3273: else
3274: {
3275: if (!DECL_EXTERNAL (decl))
3276: location_or_const_value_attribute (decl);
3277: }
3278: }
3279:
3280: static void
3281: output_label_die (arg)
3282: register void *arg;
3283: {
3284: register tree decl = arg;
3285: register tree origin = decl_ultimate_origin (decl);
3286:
3287: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_label);
3288: sibling_attribute ();
3289: if (origin != NULL)
3290: abstract_origin_attribute (origin);
3291: else
3292: name_and_src_coords_attributes (decl);
3293: if (DECL_ABSTRACT (decl))
3294: equate_decl_number_to_die_number (decl);
3295: else
3296: {
3297: register rtx insn = DECL_RTL (decl);
3298:
3299: if (GET_CODE (insn) == CODE_LABEL)
3300: {
3301: char label[MAX_ARTIFICIAL_LABEL_BYTES];
3302:
3303: /* When optimization is enabled (via -O) some parts of the compiler
3304: (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
3305: represent source-level labels which were explicitly declared by
3306: the user. This really shouldn't be happening though, so catch
3307: it if it ever does happen. */
3308:
3309: if (INSN_DELETED_P (insn))
3310: abort (); /* Should never happen. */
3311:
3312: sprintf (label, INSN_LABEL_FMT, current_funcdef_number,
3313: (unsigned) INSN_UID (insn));
3314: low_pc_attribute (label);
3315: }
3316: }
3317: }
3318:
3319: static void
3320: output_lexical_block_die (arg)
3321: register void *arg;
3322: {
3323: register tree stmt = arg;
3324:
3325: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_lexical_block);
3326: sibling_attribute ();
3327: dienum_push ();
3328: if (! BLOCK_ABSTRACT (stmt))
3329: {
3330: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
3331: char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
3332:
3333: sprintf (begin_label, BLOCK_BEGIN_LABEL_FMT, next_block_number);
3334: low_pc_attribute (begin_label);
3335: sprintf (end_label, BLOCK_END_LABEL_FMT, next_block_number);
3336: high_pc_attribute (end_label);
3337: }
3338: }
3339:
3340: static void
3341: output_inlined_subroutine_die (arg)
3342: register void *arg;
3343: {
3344: register tree stmt = arg;
3345:
3346: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_inlined_subroutine);
3347: sibling_attribute ();
3348: dienum_push ();
3349: abstract_origin_attribute (block_ultimate_origin (stmt));
3350: if (! BLOCK_ABSTRACT (stmt))
3351: {
3352: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
3353: char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
3354:
3355: sprintf (begin_label, BLOCK_BEGIN_LABEL_FMT, next_block_number);
3356: low_pc_attribute (begin_label);
3357: sprintf (end_label, BLOCK_END_LABEL_FMT, next_block_number);
3358: high_pc_attribute (end_label);
3359: }
3360: }
3361:
3362: /* Output a DIE to represent a declared data object (either file-scope
3363: or block-local) which has "internal linkage" (according to ANSI-C). */
3364:
3365: static void
3366: output_local_variable_die (arg)
3367: register void *arg;
3368: {
3369: register tree decl = arg;
3370: register tree origin = decl_ultimate_origin (decl);
3371:
3372: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_local_variable);
3373: sibling_attribute ();
3374: if (origin != NULL)
3375: abstract_origin_attribute (origin);
3376: else
3377: {
3378: name_and_src_coords_attributes (decl);
3379: member_attribute (DECL_CONTEXT (decl));
3380: type_attribute (TREE_TYPE (decl),
3381: TREE_READONLY (decl), TREE_THIS_VOLATILE (decl));
3382: }
3383: if (DECL_ABSTRACT (decl))
3384: equate_decl_number_to_die_number (decl);
3385: else
3386: location_or_const_value_attribute (decl);
3387: }
3388:
3389: static void
3390: output_member_die (arg)
3391: register void *arg;
3392: {
3393: register tree decl = arg;
3394:
3395: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_member);
3396: sibling_attribute ();
3397: name_and_src_coords_attributes (decl);
3398: member_attribute (DECL_CONTEXT (decl));
3399: type_attribute (member_declared_type (decl),
3400: TREE_READONLY (decl), TREE_THIS_VOLATILE (decl));
3401: if (DECL_BIT_FIELD_TYPE (decl)) /* If this is a bit field... */
3402: {
3403: byte_size_attribute (decl);
3404: bit_size_attribute (decl);
3405: bit_offset_attribute (decl);
3406: }
3407: data_member_location_attribute (decl);
3408: }
3409:
3410: #if 0
3411: /* Don't generate either pointer_type DIEs or reference_type DIEs. Use
3412: modified types instead.
3413:
3414: We keep this code here just in case these types of DIEs may be needed
3415: to represent certain things in other languages (e.g. Pascal) someday.
3416: */
3417:
3418: static void
3419: output_pointer_type_die (arg)
3420: register void *arg;
3421: {
3422: register tree type = arg;
3423:
3424: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_pointer_type);
3425: sibling_attribute ();
3426: equate_type_number_to_die_number (type);
3427: member_attribute (TYPE_CONTEXT (type));
3428: type_attribute (TREE_TYPE (type), 0, 0);
3429: }
3430:
3431: static void
3432: output_reference_type_die (arg)
3433: register void *arg;
3434: {
3435: register tree type = arg;
3436:
3437: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_reference_type);
3438: sibling_attribute ();
3439: equate_type_number_to_die_number (type);
3440: member_attribute (TYPE_CONTEXT (type));
3441: type_attribute (TREE_TYPE (type), 0, 0);
3442: }
3443: #endif
3444:
3445: static void
3446: output_ptr_to_mbr_type_die (arg)
3447: register void *arg;
3448: {
3449: register tree type = arg;
3450:
3451: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_ptr_to_member_type);
3452: sibling_attribute ();
3453: equate_type_number_to_die_number (type);
3454: member_attribute (TYPE_CONTEXT (type));
3455: containing_type_attribute (TYPE_OFFSET_BASETYPE (type));
3456: type_attribute (TREE_TYPE (type), 0, 0);
3457: }
3458:
3459: static void
3460: output_compile_unit_die (arg)
3461: register void *arg;
3462: {
3463: register char *main_input_filename = arg;
3464:
3465: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_compile_unit);
3466: sibling_attribute ();
3467: dienum_push ();
3468: name_attribute (main_input_filename);
3469:
3470: {
3471: char producer[250];
3472:
3473: sprintf (producer, "%s %s", language_string, version_string);
3474: producer_attribute (producer);
3475: }
3476:
3477: if (strcmp (language_string, "GNU C++") == 0)
3478: language_attribute (LANG_C_PLUS_PLUS);
3479: else if (strcmp (language_string, "GNU Ada") == 0)
3480: language_attribute (LANG_ADA83);
3481: else if (flag_traditional)
3482: language_attribute (LANG_C);
3483: else
3484: language_attribute (LANG_C89);
3485: low_pc_attribute (TEXT_BEGIN_LABEL);
3486: high_pc_attribute (TEXT_END_LABEL);
3487: if (debug_info_level >= DINFO_LEVEL_NORMAL)
3488: stmt_list_attribute (LINE_BEGIN_LABEL);
3489: last_filename = xstrdup (main_input_filename);
3490:
3491: {
3492: char *wd = getpwd ();
3493: if (wd)
3494: comp_dir_attribute (wd);
3495: }
3496:
3497: if (debug_info_level >= DINFO_LEVEL_NORMAL)
3498: {
3499: sf_names_attribute (SFNAMES_BEGIN_LABEL);
3500: src_info_attribute (SRCINFO_BEGIN_LABEL);
3501: if (debug_info_level >= DINFO_LEVEL_VERBOSE)
3502: mac_info_attribute (MACINFO_BEGIN_LABEL);
3503: }
3504: }
3505:
3506: static void
3507: output_string_type_die (arg)
3508: register void *arg;
3509: {
3510: register tree type = arg;
3511:
3512: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_string_type);
3513: sibling_attribute ();
3514: member_attribute (TYPE_CONTEXT (type));
3515:
3516: /* Fudge the string length attribute for now. */
3517:
3518: string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
3519: }
3520:
3521: static void
3522: output_structure_type_die (arg)
3523: register void *arg;
3524: {
3525: register tree type = arg;
3526:
3527: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_structure_type);
3528: sibling_attribute ();
3529: equate_type_number_to_die_number (type);
3530: name_attribute (type_tag (type));
3531: member_attribute (TYPE_CONTEXT (type));
3532:
3533: /* If this type has been completed, then give it a byte_size attribute
3534: and prepare to give a list of members. Otherwise, don't do either of
3535: these things. In the latter case, we will not be generating a list
3536: of members (since we don't have any idea what they might be for an
3537: incomplete type). */
3538:
3539: if (TYPE_SIZE (type))
3540: {
3541: dienum_push ();
3542: byte_size_attribute (type);
3543: }
3544: }
3545:
3546: /* Output a DIE to represent a declared function (either file-scope
3547: or block-local) which has "internal linkage" (according to ANSI-C). */
3548:
3549: static void
3550: output_local_subroutine_die (arg)
3551: register void *arg;
3552: {
3553: register tree decl = arg;
3554: register tree origin = decl_ultimate_origin (decl);
3555:
3556: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_subroutine);
3557: sibling_attribute ();
3558: dienum_push ();
3559: if (origin != NULL)
3560: abstract_origin_attribute (origin);
3561: else
3562: {
3563: register tree type = TREE_TYPE (decl);
3564:
3565: name_and_src_coords_attributes (decl);
3566: inline_attribute (decl);
3567: prototyped_attribute (type);
3568: member_attribute (DECL_CONTEXT (decl));
3569: type_attribute (TREE_TYPE (type), 0, 0);
3570: pure_or_virtual_attribute (decl);
3571: }
3572: if (DECL_ABSTRACT (decl))
3573: equate_decl_number_to_die_number (decl);
3574: else
3575: {
3576: /* Avoid getting screwed up in cases where a function was declared
3577: static but where no definition was ever given for it. */
3578:
3579: if (TREE_ASM_WRITTEN (decl))
3580: {
3581: char label[MAX_ARTIFICIAL_LABEL_BYTES];
3582: low_pc_attribute (function_start_label (decl));
3583: sprintf (label, FUNC_END_LABEL_FMT, current_funcdef_number);
3584: high_pc_attribute (label);
3585: sprintf (label, BODY_BEGIN_LABEL_FMT, current_funcdef_number);
3586: body_begin_attribute (label);
3587: sprintf (label, BODY_END_LABEL_FMT, current_funcdef_number);
3588: body_end_attribute (label);
3589: }
3590: }
3591: }
3592:
3593: static void
3594: output_subroutine_type_die (arg)
3595: register void *arg;
3596: {
3597: register tree type = arg;
3598: register tree return_type = TREE_TYPE (type);
3599:
3600: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_subroutine_type);
3601: sibling_attribute ();
3602: dienum_push ();
3603: equate_type_number_to_die_number (type);
3604: prototyped_attribute (type);
3605: member_attribute (TYPE_CONTEXT (type));
3606: type_attribute (return_type, 0, 0);
3607: }
3608:
3609: static void
3610: output_typedef_die (arg)
3611: register void *arg;
3612: {
3613: register tree decl = arg;
3614: register tree origin = decl_ultimate_origin (decl);
3615:
3616: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_typedef);
3617: sibling_attribute ();
3618: if (origin != NULL)
3619: abstract_origin_attribute (origin);
3620: else
3621: {
3622: name_and_src_coords_attributes (decl);
3623: member_attribute (DECL_CONTEXT (decl));
3624: type_attribute (TREE_TYPE (decl),
3625: TREE_READONLY (decl), TREE_THIS_VOLATILE (decl));
3626: }
3627: if (DECL_ABSTRACT (decl))
3628: equate_decl_number_to_die_number (decl);
3629: }
3630:
3631: static void
3632: output_union_type_die (arg)
3633: register void *arg;
3634: {
3635: register tree type = arg;
3636:
3637: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_union_type);
3638: sibling_attribute ();
3639: equate_type_number_to_die_number (type);
3640: name_attribute (type_tag (type));
3641: member_attribute (TYPE_CONTEXT (type));
3642:
3643: /* If this type has been completed, then give it a byte_size attribute
3644: and prepare to give a list of members. Otherwise, don't do either of
3645: these things. In the latter case, we will not be generating a list
3646: of members (since we don't have any idea what they might be for an
3647: incomplete type). */
3648:
3649: if (TYPE_SIZE (type))
3650: {
3651: dienum_push ();
3652: byte_size_attribute (type);
3653: }
3654: }
3655:
3656: /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
3657: at the end of an (ANSI prototyped) formal parameters list. */
3658:
3659: static void
3660: output_unspecified_parameters_die (arg)
3661: register void *arg;
3662: {
3663: register tree decl_or_type = arg;
3664:
3665: ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_unspecified_parameters);
3666: sibling_attribute ();
3667:
3668: /* This kludge is here only for the sake of being compatible with what
3669: the USL CI5 C compiler does. The specification of Dwarf Version 1
3670: doesn't say that TAG_unspecified_parameters DIEs should contain any
3671: attributes other than the AT_sibling attribute, but they are certainly
3672: allowed to contain additional attributes, and the CI5 compiler
3673: generates AT_name, AT_fund_type, and AT_location attributes within
3674: TAG_unspecified_parameters DIEs which appear in the child lists for
3675: DIEs representing function definitions, so we do likewise here. */
3676:
3677: if (TREE_CODE (decl_or_type) == FUNCTION_DECL && DECL_INITIAL (decl_or_type))
3678: {
3679: name_attribute ("...");
3680: fund_type_attribute (FT_pointer);
3681: /* location_attribute (?); */
3682: }
3683: }
3684:
3685: static void
3686: output_padded_null_die (arg)
3687: register void *arg;
3688: {
3689: ASM_OUTPUT_ALIGN (asm_out_file, 2); /* 2**2 == 4 */
3690: }
3691:
3692: /*************************** end of DIEs *********************************/
3693:
3694: /* Generate some type of DIE. This routine generates the generic outer
3695: wrapper stuff which goes around all types of DIE's (regardless of their
3696: TAGs. All forms of DIEs start with a DIE-specific label, followed by a
3697: DIE-length word, followed by the guts of the DIE itself. After the guts
3698: of the DIE, there must always be a terminator label for the DIE. */
3699:
3700: static void
3701: output_die (die_specific_output_function, param)
3702: register void (*die_specific_output_function)();
3703: register void *param;
3704: {
3705: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
3706: char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
3707:
3708: current_dienum = NEXT_DIE_NUM;
3709: NEXT_DIE_NUM = next_unused_dienum;
3710:
3711: sprintf (begin_label, DIE_BEGIN_LABEL_FMT, current_dienum);
3712: sprintf (end_label, DIE_END_LABEL_FMT, current_dienum);
3713:
3714: /* Write a label which will act as the name for the start of this DIE. */
3715:
3716: ASM_OUTPUT_LABEL (asm_out_file, begin_label);
3717:
3718: /* Write the DIE-length word. */
3719:
3720: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, end_label, begin_label);
3721:
3722: /* Fill in the guts of the DIE. */
3723:
3724: next_unused_dienum++;
3725: die_specific_output_function (param);
3726:
3727: /* Write a label which will act as the name for the end of this DIE. */
3728:
3729: ASM_OUTPUT_LABEL (asm_out_file, end_label);
3730: }
3731:
3732: static void
3733: end_sibling_chain ()
3734: {
3735: char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
3736:
3737: current_dienum = NEXT_DIE_NUM;
3738: NEXT_DIE_NUM = next_unused_dienum;
3739:
3740: sprintf (begin_label, DIE_BEGIN_LABEL_FMT, current_dienum);
3741:
3742: /* Write a label which will act as the name for the start of this DIE. */
3743:
3744: ASM_OUTPUT_LABEL (asm_out_file, begin_label);
3745:
3746: /* Write the DIE-length word. */
3747:
3748: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 4);
3749:
3750: dienum_pop ();
3751: }
3752:
3753: /* Generate a list of nameless TAG_formal_parameter DIEs (and perhaps a
3754: TAG_unspecified_parameters DIE) to represent the types of the formal
3755: parameters as specified in some function type specification (except
3756: for those which appear as part of a function *definition*).
3757:
3758: Note that we must be careful here to output all of the parameter DIEs
3759: *before* we output any DIEs needed to represent the types of the formal
3760: parameters. This keeps svr4 SDB happy because it (incorrectly) thinks
3761: that the first non-parameter DIE it sees ends the formal parameter list.
3762: */
3763:
3764: static void
3765: output_formal_types (function_or_method_type)
3766: register tree function_or_method_type;
3767: {
3768: register tree link;
3769: register tree formal_type = NULL;
3770: register tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
3771:
3772: /* In the case where we are generating a formal types list for a C++
3773: non-static member function type, skip over the first thing on the
3774: TYPE_ARG_TYPES list because it only represents the type of the
3775: hidden `this pointer'. The debugger should be able to figure
3776: out (without being explicitly told) that this non-static member
3777: function type takes a `this pointer' and should be able to figure
3778: what the type of that hidden parameter is from the AT_member
3779: attribute of the parent TAG_subroutine_type DIE. */
3780:
3781: if (TREE_CODE (function_or_method_type) == METHOD_TYPE)
3782: first_parm_type = TREE_CHAIN (first_parm_type);
3783:
3784: /* Make our first pass over the list of formal parameter types and output
3785: a TAG_formal_parameter DIE for each one. */
3786:
3787: for (link = first_parm_type; link; link = TREE_CHAIN (link))
3788: {
3789: formal_type = TREE_VALUE (link);
3790: if (formal_type == void_type_node)
3791: break;
3792:
3793: /* Output a (nameless) DIE to represent the formal parameter itself. */
3794:
3795: output_die (output_formal_parameter_die, formal_type);
3796: }
3797:
3798: /* If this function type has an ellipsis, add a TAG_unspecified_parameters
3799: DIE to the end of the parameter list. */
3800:
3801: if (formal_type != void_type_node)
3802: output_die (output_unspecified_parameters_die, function_or_method_type);
3803:
3804: /* Make our second (and final) pass over the list of formal parameter types
3805: and output DIEs to represent those types (as necessary). */
3806:
3807: for (link = TYPE_ARG_TYPES (function_or_method_type);
3808: link;
3809: link = TREE_CHAIN (link))
3810: {
3811: formal_type = TREE_VALUE (link);
3812: if (formal_type == void_type_node)
3813: break;
3814:
3815: output_type (formal_type, function_or_method_type);
3816: }
3817: }
3818:
3819: /* Remember a type in the pending_types_list. */
3820:
3821: static void
3822: pend_type (type)
3823: register tree type;
3824: {
3825: if (pending_types == pending_types_allocated)
3826: {
3827: pending_types_allocated += PENDING_TYPES_INCREMENT;
3828: pending_types_list
3829: = (tree *) xrealloc (pending_types_list,
3830: sizeof (tree) * pending_types_allocated);
3831: }
3832: pending_types_list[pending_types++] = type;
3833:
3834: /* Mark the pending type as having been output already (even though
3835: it hasn't been). This prevents the type from being added to the
3836: pending_types_list more than once. */
3837:
3838: TREE_ASM_WRITTEN (type) = 1;
3839: }
3840:
3841: /* Return non-zero if it is legitimate to output DIEs to represent a
3842: given type while we are generating the list of child DIEs for some
3843: DIE (e.g. a function or lexical block DIE) associated with a given scope.
3844:
3845: See the comments within the function for a description of when it is
3846: considered legitimate to output DIEs for various kinds of types.
3847:
3848: Note that TYPE_CONTEXT(type) may be NULL (to indicate global scope)
3849: or it may point to a BLOCK node (for types local to a block), or to a
3850: FUNCTION_DECL node (for types local to the heading of some function
3851: definition), or to a FUNCTION_TYPE node (for types local to the
3852: prototyped parameter list of a function type specification), or to a
3853: RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE node
3854: (in the case of C++ nested types).
3855:
3856: The `scope' parameter should likewise be NULL or should point to a
3857: BLOCK node, a FUNCTION_DECL node, a FUNCTION_TYPE node, a RECORD_TYPE
3858: node, a UNION_TYPE node, or a QUAL_UNION_TYPE node.
3859:
3860: This function is used only for deciding when to "pend" and when to
3861: "un-pend" types to/from the pending_types_list.
3862:
3863: Note that we sometimes make use of this "type pending" feature in a
3864: rather twisted way to temporarily delay the production of DIEs for the
3865: types of formal parameters. (We do this just to make svr4 SDB happy.)
3866: It order to delay the production of DIEs representing types of formal
3867: parameters, callers of this function supply `fake_containing_scope' as
3868: the `scope' parameter to this function. Given that fake_containing_scope
3869: is a tagged type which is *not* the containing scope for *any* other type,
3870: the desired effect is achieved, i.e. output of DIEs representing types
3871: is temporarily suspended, and any type DIEs which would have otherwise
3872: been output are instead placed onto the pending_types_list. Later on,
3873: we force these (temporarily pended) types to be output simply by calling
3874: `output_pending_types_for_scope' with an actual argument equal to the
3875: true scope of the types we temporarily pended.
3876: */
3877:
3878: inline int
3879: type_ok_for_scope (type, scope)
3880: register tree type;
3881: register tree scope;
3882: {
3883: /* Tagged types (i.e. struct, union, and enum types) must always be
3884: output only in the scopes where they actually belong (or else the
3885: scoping of their own tag names and the scoping of their member
3886: names will be incorrect). Non-tagged-types on the other hand can
3887: generally be output anywhere, except that svr4 SDB really doesn't
3888: want to see them nested within struct or union types, so here we
3889: say it is always OK to immediately output any such a (non-tagged)
3890: type, so long as we are not within such a context. Note that the
3891: only kinds of non-tagged types which we will be dealing with here
3892: (for C and C++ anyway) will be array types and function types. */
3893:
3894: return is_tagged_type (type)
3895: ? (TYPE_CONTEXT (type) == scope)
3896: : (scope == NULL_TREE || ! is_tagged_type (scope));
3897: }
3898:
3899: /* Output any pending types (from the pending_types list) which we can output
3900: now (taking into account the scope that we are working on now).
3901:
3902: For each type output, remove the given type from the pending_types_list
3903: *before* we try to output it.
3904:
3905: Note that we have to process the list in beginning-to-end order,
3906: because the call made here to output_type may cause yet more types
3907: to be added to the end of the list, and we may have to output some
3908: of them too.
3909: */
3910:
3911: static void
3912: output_pending_types_for_scope (containing_scope)
3913: register tree containing_scope;
3914: {
3915: register unsigned i;
3916:
3917: for (i = 0; i < pending_types; )
3918: {
3919: register tree type = pending_types_list[i];
3920:
3921: if (type_ok_for_scope (type, containing_scope))
3922: {
3923: register tree *mover;
3924: register tree *limit;
3925:
3926: pending_types--;
3927: limit = &pending_types_list[pending_types];
3928: for (mover = &pending_types_list[i]; mover < limit; mover++)
3929: *mover = *(mover+1);
3930:
3931: /* Un-mark the type as having been output already (because it
3932: hasn't been, really). Then call output_type to generate a
3933: Dwarf representation of it. */
3934:
3935: TREE_ASM_WRITTEN (type) = 0;
3936: output_type (type, containing_scope);
3937:
3938: /* Don't increment the loop counter in this case because we
3939: have shifted all of the subsequent pending types down one
3940: element in the pending_types_list array. */
3941: }
3942: else
3943: i++;
3944: }
3945: }
3946:
3947: static void
3948: output_type (type, containing_scope)
3949: register tree type;
3950: register tree containing_scope;
3951: {
3952: if (type == 0 || type == error_mark_node)
3953: return;
3954:
3955: /* We are going to output a DIE to represent the unqualified version of
3956: of this type (i.e. without any const or volatile qualifiers) so get
3957: the main variant (i.e. the unqualified version) of this type now. */
3958:
3959: type = type_main_variant (type);
3960:
3961: if (TREE_ASM_WRITTEN (type))
3962: return;
3963:
3964: /* Don't generate any DIEs for this type now unless it is OK to do so
3965: (based upon what `type_ok_for_scope' tells us). */
3966:
3967: if (! type_ok_for_scope (type, containing_scope))
3968: {
3969: pend_type (type);
3970: return;
3971: }
3972:
3973: switch (TREE_CODE (type))
3974: {
3975: case ERROR_MARK:
3976: break;
3977:
3978: case POINTER_TYPE:
3979: case REFERENCE_TYPE:
3980: /* For these types, all that is required is that we output a DIE
3981: (or a set of DIEs) to represent the "basis" type. */
3982: output_type (TREE_TYPE (type), containing_scope);
3983: break;
3984:
3985: case OFFSET_TYPE:
3986: /* This code is used for C++ pointer-to-data-member types. */
3987: /* Output a description of the relevant class type. */
3988: output_type (TYPE_OFFSET_BASETYPE (type), containing_scope);
3989: /* Output a description of the type of the object pointed to. */
3990: output_type (TREE_TYPE (type), containing_scope);
3991: /* Now output a DIE to represent this pointer-to-data-member type
3992: itself. */
3993: output_die (output_ptr_to_mbr_type_die, type);
3994: break;
3995:
3996: case SET_TYPE:
3997: output_type (TYPE_DOMAIN (type), containing_scope);
3998: output_die (output_set_type_die, type);
3999: break;
4000:
4001: case FILE_TYPE:
4002: output_type (TREE_TYPE (type), containing_scope);
4003: abort (); /* No way to represent these in Dwarf yet! */
4004: break;
4005:
4006: case STRING_TYPE:
4007: output_type (TREE_TYPE (type), containing_scope);
4008: output_die (output_string_type_die, type);
4009: break;
4010:
4011: case FUNCTION_TYPE:
4012: /* Force out return type (in case it wasn't forced out already). */
4013: output_type (TREE_TYPE (type), containing_scope);
4014: output_die (output_subroutine_type_die, type);
4015: output_formal_types (type);
4016: end_sibling_chain ();
4017: break;
4018:
4019: case METHOD_TYPE:
4020: /* Force out return type (in case it wasn't forced out already). */
4021: output_type (TREE_TYPE (type), containing_scope);
4022: output_die (output_subroutine_type_die, type);
4023: output_formal_types (type);
4024: end_sibling_chain ();
4025: break;
4026:
4027: case ARRAY_TYPE:
4028: {
4029: register tree element_type;
4030:
4031: element_type = TREE_TYPE (type);
4032: while (TREE_CODE (element_type) == ARRAY_TYPE)
4033: element_type = TREE_TYPE (element_type);
4034:
4035: output_type (element_type, containing_scope);
4036: output_die (output_array_type_die, type);
4037: }
4038: break;
4039:
4040: case ENUMERAL_TYPE:
4041: case RECORD_TYPE:
4042: case UNION_TYPE:
4043: case QUAL_UNION_TYPE:
4044:
4045: /* For a non-file-scope tagged type, we can always go ahead and
4046: output a Dwarf description of this type right now, even if
4047: the type in question is still incomplete, because if this
4048: local type *was* ever completed anywhere within its scope,
4049: that complete definition would already have been attached to
4050: this RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE or ENUMERAL_TYPE
4051: node by the time we reach this point. That's true because of the
4052: way the front-end does its processing of file-scope declarations (of
4053: functions and class types) within which other types might be
4054: nested. The C and C++ front-ends always gobble up such "local
4055: scope" things en-mass before they try to output *any* debugging
4056: information for any of the stuff contained inside them and thus,
4057: we get the benefit here of what is (in effect) a pre-resolution
4058: of forward references to tagged types in local scopes.
4059:
4060: Note however that for file-scope tagged types we cannot assume
4061: that such pre-resolution of forward references has taken place.
4062: A given file-scope tagged type may appear to be incomplete when
4063: we reach this point, but it may yet be given a full definition
4064: (at file-scope) later on during compilation. In order to avoid
4065: generating a premature (and possibly incorrect) set of Dwarf
4066: DIEs for such (as yet incomplete) file-scope tagged types, we
4067: generate nothing at all for as-yet incomplete file-scope tagged
4068: types here unless we are making our special "finalization" pass
4069: for file-scope things at the very end of compilation. At that
4070: time, we will certainly know as much about each file-scope tagged
4071: type as we are ever going to know, so at that point in time, we
4072: can safely generate correct Dwarf descriptions for these file-
4073: scope tagged types.
4074: */
4075:
4076: if (TYPE_SIZE (type) == 0 && TYPE_CONTEXT (type) == NULL && !finalizing)
4077: return; /* EARLY EXIT! Avoid setting TREE_ASM_WRITTEN. */
4078:
4079: /* Prevent infinite recursion in cases where the type of some
4080: member of this type is expressed in terms of this type itself. */
4081:
4082: TREE_ASM_WRITTEN (type) = 1;
4083:
4084: /* Output a DIE to represent the tagged type itself. */
4085:
4086: switch (TREE_CODE (type))
4087: {
4088: case ENUMERAL_TYPE:
4089: output_die (output_enumeration_type_die, type);
4090: return; /* a special case -- nothing left to do so just return */
4091:
4092: case RECORD_TYPE:
4093: output_die (output_structure_type_die, type);
4094: break;
4095:
4096: case UNION_TYPE:
4097: case QUAL_UNION_TYPE:
4098: output_die (output_union_type_die, type);
4099: break;
4100:
4101: default:
4102: abort (); /* Should never happen. */
4103: }
4104:
4105: /* If this is not an incomplete type, output descriptions of
4106: each of its members.
4107:
4108: Note that as we output the DIEs necessary to represent the
4109: members of this record or union type, we will also be trying
4110: to output DIEs to represent the *types* of those members.
4111: However the `output_type' function (above) will specifically
4112: avoid generating type DIEs for member types *within* the list
4113: of member DIEs for this (containing) type execpt for those
4114: types (of members) which are explicitly marked as also being
4115: members of this (containing) type themselves. The g++ front-
4116: end can force any given type to be treated as a member of some
4117: other (containing) type by setting the TYPE_CONTEXT of the
4118: given (member) type to point to the TREE node representing the
4119: appropriate (containing) type.
4120: */
4121:
4122: if (TYPE_SIZE (type))
4123: {
4124: {
4125: register tree normal_member;
4126:
4127: /* First output info about the data members and type members. */
4128:
4129: for (normal_member = TYPE_FIELDS (type);
4130: normal_member;
4131: normal_member = TREE_CHAIN (normal_member))
4132: output_decl (normal_member, type);
4133: }
4134:
4135: {
4136: register tree vec_base;
4137:
4138: /* Now output info about the function members (if any). */
4139:
4140: vec_base = TYPE_METHODS (type);
4141: if (vec_base)
4142: {
4143: register tree first_func_member = TREE_VEC_ELT (vec_base, 0);
4144: register tree func_member;
4145:
4146: /* This isn't documented, but the first element of the
4147: vector of member functions can be NULL in cases where
4148: the class type in question didn't have either a
4149: constructor or a destructor declared for it. We have
4150: to make allowances for that here. */
4151:
4152: if (first_func_member == NULL)
4153: first_func_member = TREE_VEC_ELT (vec_base, 1);
4154:
4155: for (func_member = first_func_member;
4156: func_member;
4157: func_member = TREE_CHAIN (func_member))
4158: output_decl (func_member, type);
4159: }
4160: }
4161:
4162: /* RECORD_TYPEs, UNION_TYPEs, and QUAL_UNION_TYPEs are themselves
4163: scopes (at least in C++) so we must now output any nested
4164: pending types which are local just to this type. */
4165:
4166: output_pending_types_for_scope (type);
4167:
4168: end_sibling_chain (); /* Terminate member chain. */
4169: }
4170:
4171: break;
4172:
4173: case VOID_TYPE:
4174: case INTEGER_TYPE:
4175: case REAL_TYPE:
4176: case COMPLEX_TYPE:
4177: case BOOLEAN_TYPE:
4178: case CHAR_TYPE:
4179: break; /* No DIEs needed for fundamental types. */
4180:
4181: case LANG_TYPE: /* No Dwarf representation currently defined. */
4182: break;
4183:
4184: default:
4185: abort ();
4186: }
4187:
4188: TREE_ASM_WRITTEN (type) = 1;
4189: }
4190:
4191: static void
4192: output_tagged_type_instantiation (type)
4193: register tree type;
4194: {
4195: if (type == 0 || type == error_mark_node)
4196: return;
4197:
4198: /* We are going to output a DIE to represent the unqualified version of
4199: of this type (i.e. without any const or volatile qualifiers) so make
4200: sure that we have the main variant (i.e. the unqualified version) of
4201: this type now. */
4202:
4203: assert (type == type_main_variant (type));
4204:
4205: assert (TREE_ASM_WRITTEN (type));
4206:
4207: switch (TREE_CODE (type))
4208: {
4209: case ERROR_MARK:
4210: break;
4211:
4212: case ENUMERAL_TYPE:
4213: output_die (output_inlined_enumeration_type_die, type);
4214: break;
4215:
4216: case RECORD_TYPE:
4217: output_die (output_inlined_structure_type_die, type);
4218: break;
4219:
4220: case UNION_TYPE:
4221: case QUAL_UNION_TYPE:
4222: output_die (output_inlined_union_type_die, type);
4223: break;
4224:
4225: default:
4226: abort (); /* Should never happen. */
4227: }
4228: }
4229:
4230: /* Output a TAG_lexical_block DIE followed by DIEs to represent all of
4231: the things which are local to the given block. */
4232:
4233: static void
4234: output_block (stmt)
4235: register tree stmt;
4236: {
4237: register int must_output_die = 0;
4238: register tree origin;
4239: register enum tree_code origin_code;
4240:
4241: /* Ignore blocks never really used to make RTL. */
4242:
4243: if (! stmt || ! TREE_USED (stmt))
4244: return;
4245:
4246: /* Determine the "ultimate origin" of this block. This block may be an
4247: inlined instance of an inlined instance of inline function, so we
4248: have to trace all of the way back through the origin chain to find
4249: out what sort of node actually served as the original seed for the
4250: creation of the current block. */
4251:
4252: origin = block_ultimate_origin (stmt);
4253: origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
4254:
4255: /* Determine if we need to output any Dwarf DIEs at all to represent this
4256: block. */
4257:
4258: if (origin_code == FUNCTION_DECL)
4259: /* The outer scopes for inlinings *must* always be represented. We
4260: generate TAG_inlined_subroutine DIEs for them. (See below.) */
4261: must_output_die = 1;
4262: else
4263: {
4264: /* In the case where the current block represents an inlining of the
4265: "body block" of an inline function, we must *NOT* output any DIE
4266: for this block because we have already output a DIE to represent
4267: the whole inlined function scope and the "body block" of any
4268: function doesn't really represent a different scope according to
4269: ANSI C rules. So we check here to make sure that this block does
4270: not represent a "body block inlining" before trying to set the
4271: `must_output_die' flag. */
4272:
4273: if (origin == NULL || ! is_body_block (origin))
4274: {
4275: /* Determine if this block directly contains any "significant"
4276: local declarations which we will need to output DIEs for. */
4277:
4278: if (debug_info_level > DINFO_LEVEL_TERSE)
4279: /* We are not in terse mode so *any* local declaration counts
4280: as being a "significant" one. */
4281: must_output_die = (BLOCK_VARS (stmt) != NULL);
4282: else
4283: {
4284: register tree decl;
4285:
4286: /* We are in terse mode, so only local (nested) function
4287: definitions count as "significant" local declarations. */
4288:
4289: for (decl = BLOCK_VARS (stmt); decl; decl = TREE_CHAIN (decl))
4290: if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
4291: {
4292: must_output_die = 1;
4293: break;
4294: }
4295: }
4296: }
4297: }
4298:
4299: /* It would be a waste of space to generate a Dwarf TAG_lexical_block
4300: DIE for any block which contains no significant local declarations
4301: at all. Rather, in such cases we just call `output_decls_for_scope'
4302: so that any needed Dwarf info for any sub-blocks will get properly
4303: generated. Note that in terse mode, our definition of what constitutes
4304: a "significant" local declaration gets restricted to include only
4305: inlined function instances and local (nested) function definitions. */
4306:
4307: if (must_output_die)
4308: {
4309: output_die ((origin_code == FUNCTION_DECL)
4310: ? output_inlined_subroutine_die
4311: : output_lexical_block_die,
4312: stmt);
4313: output_decls_for_scope (stmt);
4314: end_sibling_chain ();
4315: }
4316: else
4317: output_decls_for_scope (stmt);
4318: }
4319:
4320: /* Output all of the decls declared within a given scope (also called
4321: a `binding contour') and (recursively) all of it's sub-blocks. */
4322:
4323: static void
4324: output_decls_for_scope (stmt)
4325: register tree stmt;
4326: {
4327: /* Ignore blocks never really used to make RTL. */
4328:
4329: if (! stmt || ! TREE_USED (stmt))
4330: return;
4331:
4332: if (! BLOCK_ABSTRACT (stmt))
4333: next_block_number++;
4334:
4335: /* Output the DIEs to represent all of the data objects, functions,
4336: typedefs, and tagged types declared directly within this block
4337: but not within any nested sub-blocks. */
4338:
4339: {
4340: register tree decl;
4341:
4342: for (decl = BLOCK_VARS (stmt); decl; decl = TREE_CHAIN (decl))
4343: output_decl (decl, stmt);
4344: }
4345:
4346: output_pending_types_for_scope (stmt);
4347:
4348: /* Output the DIEs to represent all sub-blocks (and the items declared
4349: therein) of this block. */
4350:
4351: {
4352: register tree subblocks;
4353:
4354: for (subblocks = BLOCK_SUBBLOCKS (stmt);
4355: subblocks;
4356: subblocks = BLOCK_CHAIN (subblocks))
4357: output_block (subblocks);
4358: }
4359: }
4360:
4361: /* Output Dwarf .debug information for a decl described by DECL. */
4362:
4363: static void
4364: output_decl (decl, containing_scope)
4365: register tree decl;
4366: register tree containing_scope;
4367: {
4368: /* Make a note of the decl node we are going to be working on. We may
4369: need to give the user the source coordinates of where it appeared in
4370: case we notice (later on) that something about it looks screwy. */
4371:
4372: dwarf_last_decl = decl;
4373:
4374: if (TREE_CODE (decl) == ERROR_MARK)
4375: return;
4376:
4377: /* If this ..._DECL node is marked to be ignored, then ignore it.
4378: But don't ignore a function definition, since that would screw
4379: up our count of blocks, and that it turn will completely screw up the
4380: the labels we will reference in subsequent AT_low_pc and AT_high_pc
4381: attributes (for subsequent blocks). */
4382:
4383: if (DECL_IGNORED_P (decl) && TREE_CODE (decl) != FUNCTION_DECL)
4384: return;
4385:
4386: switch (TREE_CODE (decl))
4387: {
4388: case CONST_DECL:
4389: /* The individual enumerators of an enum type get output when we
4390: output the Dwarf representation of the relevant enum type itself. */
4391: break;
4392:
4393: case FUNCTION_DECL:
4394: /* If we are in terse mode, don't output any DIEs to represent
4395: mere function declarations. Also, if we are conforming
4396: to the DWARF version 1 specification, don't output DIEs for
4397: mere function declarations. */
4398:
4399: if (DECL_INITIAL (decl) == NULL_TREE)
4400: #if (DWARF_VERSION > 1)
4401: if (debug_info_level <= DINFO_LEVEL_TERSE)
4402: #endif
4403: break;
4404:
4405: /* Before we describe the FUNCTION_DECL itself, make sure that we
4406: have described its return type. */
4407:
4408: output_type (TREE_TYPE (TREE_TYPE (decl)), containing_scope);
4409:
4410: /* If the following DIE will represent a function definition for a
4411: function with "extern" linkage, output a special "pubnames" DIE
4412: label just ahead of the actual DIE. A reference to this label
4413: was already generated in the .debug_pubnames section sub-entry
4414: for this function definition. */
4415:
4416: if (TREE_PUBLIC (decl))
4417: {
4418: char label[MAX_ARTIFICIAL_LABEL_BYTES];
4419:
4420: sprintf (label, PUB_DIE_LABEL_FMT, next_pubname_number++);
4421: ASM_OUTPUT_LABEL (asm_out_file, label);
4422: }
4423:
4424: /* Now output a DIE to represent the function itself. */
4425:
4426: output_die (TREE_PUBLIC (decl) || DECL_EXTERNAL (decl)
4427: ? output_global_subroutine_die
4428: : output_local_subroutine_die,
4429: decl);
4430:
4431: /* Now output descriptions of the arguments for this function.
4432: This gets (unnecessarily?) complex because of the fact that
4433: the DECL_ARGUMENT list for a FUNCTION_DECL doesn't indicate
4434: cases where there was a trailing `...' at the end of the formal
4435: parameter list. In order to find out if there was a trailing
4436: ellipsis or not, we must instead look at the type associated
4437: with the FUNCTION_DECL. This will be a node of type FUNCTION_TYPE.
4438: If the chain of type nodes hanging off of this FUNCTION_TYPE node
4439: ends with a void_type_node then there should *not* be an ellipsis
4440: at the end. */
4441:
4442: /* In the case where we are describing a mere function declaration, all
4443: we need to do here (and all we *can* do here) is to describe
4444: the *types* of its formal parameters. */
4445:
4446: if (DECL_INITIAL (decl) == NULL_TREE)
4447: output_formal_types (TREE_TYPE (decl));
4448: else
4449: {
4450: register tree arg_decls = DECL_ARGUMENTS (decl);
4451:
4452: {
4453: register tree last_arg;
4454:
4455: last_arg = (arg_decls && TREE_CODE (arg_decls) != ERROR_MARK)
4456: ? tree_last (arg_decls)
4457: : NULL;
4458:
4459: /* Generate DIEs to represent all known formal parameters, but
4460: don't do it if this looks like a varargs function. A given
4461: function is considered to be a varargs function if (and only
4462: if) its last named argument is named `__builtin_va_alist'. */
4463:
4464: if (! last_arg
4465: || ! DECL_NAME (last_arg)
4466: || strcmp (IDENTIFIER_POINTER (DECL_NAME (last_arg)),
4467: "__builtin_va_alist"))
4468: {
4469: register tree parm;
4470:
4471: /* WARNING! Kludge zone ahead! Here we have a special
4472: hack for svr4 SDB compatibility. Instead of passing the
4473: current FUNCTION_DECL node as the second parameter (i.e.
4474: the `containing_scope' parameter) to `output_decl' (as
4475: we ought to) we instead pass a pointer to our own private
4476: fake_containing_scope node. That node is a RECORD_TYPE
4477: node which NO OTHER TYPE may ever actually be a member of.
4478:
4479: This pointer will ultimately get passed into `output_type'
4480: as its `containing_scope' parameter. `Output_type' will
4481: then perform its part in the hack... i.e. it will pend
4482: the type of the formal parameter onto the pending_types
4483: list. Later on, when we are done generating the whole
4484: sequence of formal parameter DIEs for this function
4485: definition, we will un-pend all previously pended types
4486: of formal parameters for this function definition.
4487:
4488: This whole kludge prevents any type DIEs from being
4489: mixed in with the formal parameter DIEs. That's good
4490: because svr4 SDB believes that the list of formal
4491: parameter DIEs for a function ends wherever the first
4492: non-formal-parameter DIE appears. Thus, we have to
4493: keep the formal parameter DIEs segregated. They must
4494: all appear (consecutively) at the start of the list of
4495: children for the DIE representing the function definition.
4496: Then (and only then) may we output any additional DIEs
4497: needed to represent the types of these formal parameters.
4498: */
4499:
4500: for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
4501: if (TREE_CODE (parm) == PARM_DECL)
4502: output_decl (parm, fake_containing_scope);
4503:
4504: /* Now that we have finished generating all of the DIEs to
4505: represent the formal parameters themselves, force out
4506: any DIEs needed to represent their types. We do this
4507: simply by un-pending all previously pended types which
4508: can legitimately go into the chain of children DIEs for
4509: the current FUNCTION_DECL. */
4510:
4511: output_pending_types_for_scope (decl);
4512: }
4513: }
4514:
4515: /* Now try to decide if we should put an ellipsis at the end. */
4516:
4517: {
4518: register int has_ellipsis = TRUE; /* default assumption */
4519: register tree fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
4520:
4521: if (fn_arg_types)
4522: {
4523: /* This function declaration/definition was prototyped. */
4524:
4525: /* If the list of formal argument types ends with a
4526: void_type_node, then the formals list did *not* end
4527: with an ellipsis. */
4528:
4529: if (TREE_VALUE (tree_last (fn_arg_types)) == void_type_node)
4530: has_ellipsis = FALSE;
4531: }
4532: else
4533: {
4534: /* This function declaration/definition was not prototyped. */
4535:
4536: /* Note that all non-prototyped function *declarations* are
4537: assumed to represent varargs functions (until proven
4538: otherwise). */
4539:
4540: if (DECL_INITIAL (decl)) /* if this is a func definition */
4541: {
4542: if (!arg_decls)
4543: has_ellipsis = FALSE; /* no args == (void) */
4544: else
4545: {
4546: /* For a non-prototyped function definition which
4547: declares one or more formal parameters, if the name
4548: of the first formal parameter is *not*
4549: __builtin_va_alist then we must assume that this
4550: is *not* a varargs function. */
4551:
4552: if (DECL_NAME (arg_decls)
4553: && strcmp (IDENTIFIER_POINTER (DECL_NAME (arg_decls)),
4554: "__builtin_va_alist"))
4555: has_ellipsis = FALSE;
4556: }
4557: }
4558: }
4559:
4560: if (has_ellipsis)
4561: output_die (output_unspecified_parameters_die, decl);
4562: }
4563: }
4564:
4565: /* Output Dwarf info for all of the stuff within the body of the
4566: function (if it has one - it may be just a declaration). */
4567:
4568: {
4569: register tree outer_scope = DECL_INITIAL (decl);
4570:
4571: if (outer_scope && TREE_CODE (outer_scope) != ERROR_MARK)
4572: {
4573: /* Note that here, `outer_scope' is a pointer to the outermost
4574: BLOCK node created to represent a function.
4575: This outermost BLOCK actually represents the outermost
4576: binding contour for the function, i.e. the contour in which
4577: the function's formal parameters and labels get declared.
4578:
4579: Curiously, it appears that the front end doesn't actually
4580: put the PARM_DECL nodes for the current function onto the
4581: BLOCK_VARS list for this outer scope. (They are strung
4582: off of the DECL_ARGUMENTS list for the function instead.)
4583: The BLOCK_VARS list for the `outer_scope' does provide us
4584: with a list of the LABEL_DECL nodes for the function however,
4585: and we output DWARF info for those here.
4586:
4587: Just within the `outer_scope' there will be another BLOCK
4588: node representing the function's outermost pair of curly
4589: braces. We musn't generate a lexical_block DIE for this
4590: outermost pair of curly braces because that is not really an
4591: independent scope according to ANSI C rules. Rather, it is
4592: the same scope in which the parameters were declared. */
4593:
4594: {
4595: register tree label;
4596:
4597: for (label = BLOCK_VARS (outer_scope);
4598: label;
4599: label = TREE_CHAIN (label))
4600: output_decl (label, outer_scope);
4601: }
4602:
4603: /* Note here that `BLOCK_SUBBLOCKS (outer_scope)' points to a
4604: list of BLOCK nodes which is always only one element long.
4605: That one element represents the outermost pair of curley
4606: braces for the function body. */
4607:
4608: output_decls_for_scope (BLOCK_SUBBLOCKS (outer_scope));
4609:
4610: /* Finally, force out any pending types which are local to the
4611: outermost block of this function definition. These will
4612: all have a TYPE_CONTEXT which points to the FUNCTION_DECL
4613: node itself. */
4614:
4615: output_pending_types_for_scope (decl);
4616: }
4617: }
4618:
4619: /* Generate a terminator for the list of stuff `owned' by this
4620: function. */
4621:
4622: end_sibling_chain ();
4623:
4624: break;
4625:
4626: case TYPE_DECL:
4627: /* If we are in terse mode, don't generate any DIEs to represent
4628: any actual typedefs. Note that even when we are in terse mode,
4629: we must still output DIEs to represent those tagged types which
4630: are used (directly or indirectly) in the specification of either
4631: a return type or a formal parameter type of some function. */
4632:
4633: if (debug_info_level <= DINFO_LEVEL_TERSE)
4634: if (DECL_NAME (decl) != NULL
4635: || ! TYPE_USED_FOR_FUNCTION (TREE_TYPE (decl)))
4636: return;
4637:
4638: /* In the special case of a null-named TYPE_DECL node (representing
4639: the declaration of some type tag), if the given TYPE_DECL is
4640: marked as having been instantiated from some other (original)
4641: TYPE_DECL node (e.g. one which was generated within the original
4642: definition of an inline function) we have to generate a special
4643: (abbreviated) TAG_structure_type, TAG_union_type, or
4644: TAG_enumeration-type DIE here. */
4645:
4646: if (! DECL_NAME (decl) && DECL_ABSTRACT_ORIGIN (decl))
4647: {
4648: output_tagged_type_instantiation (TREE_TYPE (decl));
4649: return;
4650: }
4651:
4652: output_type (TREE_TYPE (decl), containing_scope);
4653:
4654: /* Note that unlike the gcc front end (which generates a NULL named
4655: TYPE_DECL node for each complete tagged type, each array type,
4656: and each function type node created) the g++ front end generates
4657: a *named* TYPE_DECL node for each tagged type node created.
4658: Unfortunately, these g++ TYPE_DECL nodes cause us to output many
4659: superfluous and unnecessary TAG_typedef DIEs here. When g++ is
4660: fixed to stop generating these superfluous named TYPE_DECL nodes,
4661: the superfluous TAG_typedef DIEs will likewise cease. */
4662:
4663: if (DECL_NAME (decl))
4664: /* Output a DIE to represent the typedef itself. */
4665: output_die (output_typedef_die, decl);
4666: break;
4667:
4668: case LABEL_DECL:
4669: if (debug_info_level >= DINFO_LEVEL_NORMAL)
4670: output_die (output_label_die, decl);
4671: break;
4672:
4673: case VAR_DECL:
4674: /* If we are conforming to the DWARF version 1 specification, don't
4675: generated any DIEs to represent mere external object declarations. */
4676:
4677: #if (DWARF_VERSION <= 1)
4678: if (DECL_EXTERNAL (decl) && ! TREE_PUBLIC (decl))
4679: break;
4680: #endif
4681:
4682: /* If we are in terse mode, don't generate any DIEs to represent
4683: any variable declarations or definitions. */
4684:
4685: if (debug_info_level <= DINFO_LEVEL_TERSE)
4686: break;
4687:
4688: /* Output any DIEs that are needed to specify the type of this data
4689: object. */
4690:
4691: output_type (TREE_TYPE (decl), containing_scope);
4692:
4693: /* If the following DIE will represent a data object definition for a
4694: data object with "extern" linkage, output a special "pubnames" DIE
4695: label just ahead of the actual DIE. A reference to this label
4696: was already generated in the .debug_pubnames section sub-entry
4697: for this data object definition. */
4698:
4699: if (TREE_PUBLIC (decl) && ! DECL_ABSTRACT (decl))
4700: {
4701: char label[MAX_ARTIFICIAL_LABEL_BYTES];
4702:
4703: sprintf (label, PUB_DIE_LABEL_FMT, next_pubname_number++);
4704: ASM_OUTPUT_LABEL (asm_out_file, label);
4705: }
4706:
4707: /* Now output the DIE to represent the data object itself. This gets
4708: complicated because of the possibility that the VAR_DECL really
4709: represents an inlined instance of a formal parameter for an inline
4710: function. */
4711:
4712: {
4713: register void (*func) ();
4714: register tree origin = decl_ultimate_origin (decl);
4715:
4716: if (origin != NULL && TREE_CODE (origin) == PARM_DECL)
4717: func = output_formal_parameter_die;
4718: else
4719: {
4720: if (TREE_PUBLIC (decl) || DECL_EXTERNAL (decl))
4721: func = output_global_variable_die;
4722: else
4723: func = output_local_variable_die;
4724: }
4725: output_die (func, decl);
4726: }
4727: break;
4728:
4729: case FIELD_DECL:
4730: /* Ignore the nameless fields that are used to skip bits. */
4731: if (DECL_NAME (decl) != 0)
4732: {
4733: output_type (member_declared_type (decl), containing_scope);
4734: output_die (output_member_die, decl);
4735: }
4736: break;
4737:
4738: case PARM_DECL:
4739: /* Force out the type of this formal, if it was not forced out yet.
4740: Note that here we can run afowl of a bug in "classic" svr4 SDB.
4741: It should be able to grok the presence of type DIEs within a list
4742: of TAG_formal_parameter DIEs, but it doesn't. */
4743:
4744: output_type (TREE_TYPE (decl), containing_scope);
4745: output_die (output_formal_parameter_die, decl);
4746: break;
4747:
4748: default:
4749: abort ();
4750: }
4751: }
4752:
4753: void
4754: dwarfout_file_scope_decl (decl, set_finalizing)
4755: register tree decl;
4756: register int set_finalizing;
4757: {
4758: if (TREE_CODE (decl) == ERROR_MARK)
4759: return;
4760:
4761: /* If this ..._DECL node is marked to be ignored, then ignore it. We
4762: gotta hope that the node in question doesn't represent a function
4763: definition. If it does, then totally ignoring it is bound to screw
4764: up our count of blocks, and that it turn will completely screw up the
4765: the labels we will reference in subsequent AT_low_pc and AT_high_pc
4766: attributes (for subsequent blocks). (It's too bad that BLOCK nodes
4767: don't carry their own sequence numbers with them!) */
4768:
4769: if (DECL_IGNORED_P (decl))
4770: {
4771: if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl) != NULL)
4772: abort ();
4773: return;
4774: }
4775:
4776: switch (TREE_CODE (decl))
4777: {
4778: case FUNCTION_DECL:
4779:
4780: /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of
4781: a builtin function. Explicit programmer-supplied declarations of
4782: these same functions should NOT be ignored however. */
4783:
4784: if (DECL_EXTERNAL (decl) && DECL_FUNCTION_CODE (decl))
4785: return;
4786:
4787: /* What we would really like to do here is to filter out all mere
4788: file-scope declarations of file-scope functions which are never
4789: referenced later within this translation unit (and keep all of
4790: ones that *are* referenced later on) but we aren't clarvoiant,
4791: so we have no idea which functions will be referenced in the
4792: future (i.e. later on within the current translation unit).
4793: So here we just ignore all file-scope function declarations
4794: which are not also definitions. If and when the debugger needs
4795: to know something about these funcstion, it wil have to hunt
4796: around and find the DWARF information associated with the
4797: *definition* of the function.
4798:
4799: Note that we can't just check `DECL_EXTERNAL' to find out which
4800: FUNCTION_DECL nodes represent definitions and which ones represent
4801: mere declarations. We have to check `DECL_INITIAL' instead. That's
4802: because the C front-end supports some weird semantics for "extern
4803: inline" function definitions. These can get inlined within the
4804: current translation unit (an thus, we need to generate DWARF info
4805: for their abstract instances so that the DWARF info for the
4806: concrete inlined instances can have something to refer to) but
4807: the compiler never generates any out-of-lines instances of such
4808: things (despite the fact that they *are* definitions). The
4809: important point is that the C front-end marks these "extern inline"
4810: functions as DECL_EXTERNAL, but we need to generate DWARf for them
4811: anyway.
4812:
4813: Note that the C++ front-end also plays some similar games for inline
4814: function definitions appearing within include files which also
4815: contain `#pragma interface' pragmas. */
4816:
4817: if (DECL_INITIAL (decl) == NULL_TREE)
4818: return;
4819:
4820: if (TREE_PUBLIC (decl)
4821: && ! DECL_EXTERNAL (decl)
4822: && ! DECL_ABSTRACT (decl))
4823: {
4824: char label[MAX_ARTIFICIAL_LABEL_BYTES];
4825:
4826: /* Output a .debug_pubnames entry for a public function
4827: defined in this compilation unit. */
4828:
4829: fputc ('\n', asm_out_file);
4830: ASM_OUTPUT_PUSH_SECTION (asm_out_file, PUBNAMES_SECTION);
4831: sprintf (label, PUB_DIE_LABEL_FMT, next_pubname_number);
4832: ASM_OUTPUT_DWARF_ADDR (asm_out_file, label);
4833: ASM_OUTPUT_DWARF_STRING (asm_out_file,
4834: IDENTIFIER_POINTER (DECL_NAME (decl)));
4835: ASM_OUTPUT_POP_SECTION (asm_out_file);
4836: }
4837:
4838: break;
4839:
4840: case VAR_DECL:
4841:
4842: /* Ignore this VAR_DECL if it refers to a file-scope extern data
4843: object declaration and if the declaration was never even
4844: referenced from within this entire compilation unit. We
4845: suppress these DIEs in order to save space in the .debug section
4846: (by eliminating entries which are probably useless). Note that
4847: we must not suppress block-local extern declarations (whether
4848: used or not) because that would screw-up the debugger's name
4849: lookup mechanism and cause it to miss things which really ought
4850: to be in scope at a given point. */
4851:
4852: if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
4853: return;
4854:
4855: if (TREE_PUBLIC (decl)
4856: && ! DECL_EXTERNAL (decl)
4857: && GET_CODE (DECL_RTL (decl)) == MEM
4858: && ! DECL_ABSTRACT (decl))
4859: {
4860: char label[MAX_ARTIFICIAL_LABEL_BYTES];
4861:
4862: if (debug_info_level >= DINFO_LEVEL_NORMAL)
4863: {
4864: /* Output a .debug_pubnames entry for a public variable
4865: defined in this compilation unit. */
4866:
4867: fputc ('\n', asm_out_file);
4868: ASM_OUTPUT_PUSH_SECTION (asm_out_file, PUBNAMES_SECTION);
4869: sprintf (label, PUB_DIE_LABEL_FMT, next_pubname_number);
4870: ASM_OUTPUT_DWARF_ADDR (asm_out_file, label);
4871: ASM_OUTPUT_DWARF_STRING (asm_out_file,
4872: IDENTIFIER_POINTER (DECL_NAME (decl)));
4873: ASM_OUTPUT_POP_SECTION (asm_out_file);
4874: }
4875:
4876: if (DECL_INITIAL (decl) == NULL)
4877: {
4878: /* Output a .debug_aranges entry for a public variable
4879: which is tentatively defined in this compilation unit. */
4880:
4881: fputc ('\n', asm_out_file);
4882: ASM_OUTPUT_PUSH_SECTION (asm_out_file, ARANGES_SECTION);
4883: ASM_OUTPUT_DWARF_ADDR (asm_out_file,
4884: IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
4885: ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
4886: (unsigned) int_size_in_bytes (TREE_TYPE (decl)));
4887: ASM_OUTPUT_POP_SECTION (asm_out_file);
4888: }
4889: }
4890:
4891: /* If we are in terse mode, don't generate any DIEs to represent
4892: any variable declarations or definitions. */
4893:
4894: if (debug_info_level <= DINFO_LEVEL_TERSE)
4895: return;
4896:
4897: break;
4898:
4899: case TYPE_DECL:
4900: /* Don't bother trying to generate any DIEs to represent any of the
4901: normal built-in types for the language we are compiling, except
4902: in cases where the types in question are *not* DWARF fundamental
4903: types. We make an exception in the case of non-fundamental types
4904: for the sake of objective C (and perhaps C++) because the GNU
4905: front-ends for these languages may in fact create certain "built-in"
4906: types which are (for example) RECORD_TYPEs. In such cases, we
4907: really need to output these (non-fundamental) types because other
4908: DIEs may contain references to them. */
4909:
4910: if (DECL_SOURCE_LINE (decl) == 0
4911: && type_is_fundamental (TREE_TYPE (decl)))
4912: return;
4913:
4914: /* If we are in terse mode, don't generate any DIEs to represent
4915: any actual typedefs. Note that even when we are in terse mode,
4916: we must still output DIEs to represent those tagged types which
4917: are used (directly or indirectly) in the specification of either
4918: a return type or a formal parameter type of some function. */
4919:
4920: if (debug_info_level <= DINFO_LEVEL_TERSE)
4921: if (DECL_NAME (decl) != NULL
4922: || ! TYPE_USED_FOR_FUNCTION (TREE_TYPE (decl)))
4923: return;
4924:
4925: break;
4926:
4927: default:
4928: return;
4929: }
4930:
4931: fputc ('\n', asm_out_file);
4932: ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SECTION);
4933: finalizing = set_finalizing;
4934: output_decl (decl, NULL_TREE);
4935:
4936: /* NOTE: The call above to `output_decl' may have caused one or more
4937: file-scope named types (i.e. tagged types) to be placed onto the
4938: pending_types_list. We have to get those types off of that list
4939: at some point, and this is the perfect time to do it. If we didn't
4940: take them off now, they might still be on the list when cc1 finally
4941: exits. That might be OK if it weren't for the fact that when we put
4942: types onto the pending_types_list, we set the TREE_ASM_WRITTEN flag
4943: for these types, and that causes them never to be output unless
4944: `output_pending_types_for_scope' takes them off of the list and un-sets
4945: their TREE_ASM_WRITTEN flags. */
4946:
4947: output_pending_types_for_scope (NULL_TREE);
4948:
4949: /* The above call should have totally emptied the pending_types_list. */
4950:
4951: assert (pending_types == 0);
4952:
4953: ASM_OUTPUT_POP_SECTION (asm_out_file);
4954:
4955: if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl) != NULL)
4956: current_funcdef_number++;
4957: }
4958:
4959: /* Output a marker (i.e. a label) for the beginning of the generated code
4960: for a lexical block. */
4961:
4962: void
4963: dwarfout_begin_block (blocknum)
4964: register unsigned blocknum;
4965: {
4966: char label[MAX_ARTIFICIAL_LABEL_BYTES];
4967:
4968: text_section ();
4969: sprintf (label, BLOCK_BEGIN_LABEL_FMT, blocknum);
4970: ASM_OUTPUT_LABEL (asm_out_file, label);
4971: }
4972:
4973: /* Output a marker (i.e. a label) for the end of the generated code
4974: for a lexical block. */
4975:
4976: void
4977: dwarfout_end_block (blocknum)
4978: register unsigned blocknum;
4979: {
4980: char label[MAX_ARTIFICIAL_LABEL_BYTES];
4981:
4982: text_section ();
4983: sprintf (label, BLOCK_END_LABEL_FMT, blocknum);
4984: ASM_OUTPUT_LABEL (asm_out_file, label);
4985: }
4986:
4987: /* Output a marker (i.e. a label) at a point in the assembly code which
4988: corresponds to a given source level label. */
4989:
4990: void
4991: dwarfout_label (insn)
4992: register rtx insn;
4993: {
4994: if (debug_info_level >= DINFO_LEVEL_NORMAL)
4995: {
4996: char label[MAX_ARTIFICIAL_LABEL_BYTES];
4997:
4998: text_section ();
4999: sprintf (label, INSN_LABEL_FMT, current_funcdef_number,
5000: (unsigned) INSN_UID (insn));
5001: ASM_OUTPUT_LABEL (asm_out_file, label);
5002: }
5003: }
5004:
5005: /* Output a marker (i.e. a label) for the point in the generated code where
5006: the real body of the function begins (after parameters have been moved
5007: to their home locations). */
5008:
5009: void
5010: dwarfout_begin_function ()
5011: {
5012: char label[MAX_ARTIFICIAL_LABEL_BYTES];
5013:
5014: text_section ();
5015: sprintf (label, BODY_BEGIN_LABEL_FMT, current_funcdef_number);
5016: ASM_OUTPUT_LABEL (asm_out_file, label);
5017: }
5018:
5019: /* Output a marker (i.e. a label) for the point in the generated code where
5020: the real body of the function ends (just before the epilogue code). */
5021:
5022: void
5023: dwarfout_end_function ()
5024: {
5025: char label[MAX_ARTIFICIAL_LABEL_BYTES];
5026:
5027: text_section ();
5028: sprintf (label, BODY_END_LABEL_FMT, current_funcdef_number);
5029: ASM_OUTPUT_LABEL (asm_out_file, label);
5030: }
5031:
5032: /* Output a marker (i.e. a label) for the absolute end of the generated code
5033: for a function definition. This gets called *after* the epilogue code
5034: has been generated. */
5035:
5036: void
5037: dwarfout_end_epilogue ()
5038: {
5039: char label[MAX_ARTIFICIAL_LABEL_BYTES];
5040:
5041: /* Output a label to mark the endpoint of the code generated for this
5042: function. */
5043:
5044: sprintf (label, FUNC_END_LABEL_FMT, current_funcdef_number);
5045: ASM_OUTPUT_LABEL (asm_out_file, label);
5046: }
5047:
5048: static void
5049: shuffle_filename_entry (new_zeroth)
5050: register filename_entry *new_zeroth;
5051: {
5052: filename_entry temp_entry;
5053: register filename_entry *limit_p;
5054: register filename_entry *move_p;
5055:
5056: if (new_zeroth == &filename_table[0])
5057: return;
5058:
5059: temp_entry = *new_zeroth;
5060:
5061: /* Shift entries up in the table to make room at [0]. */
5062:
5063: limit_p = &filename_table[0];
5064: for (move_p = new_zeroth; move_p > limit_p; move_p--)
5065: *move_p = *(move_p-1);
5066:
5067: /* Install the found entry at [0]. */
5068:
5069: filename_table[0] = temp_entry;
5070: }
5071:
5072: /* Create a new (string) entry for the .debug_sfnames section. */
5073:
5074: static void
5075: generate_new_sfname_entry ()
5076: {
5077: char label[MAX_ARTIFICIAL_LABEL_BYTES];
5078:
5079: fputc ('\n', asm_out_file);
5080: ASM_OUTPUT_PUSH_SECTION (asm_out_file, SFNAMES_SECTION);
5081: sprintf (label, SFNAMES_ENTRY_LABEL_FMT, filename_table[0].number);
5082: ASM_OUTPUT_LABEL (asm_out_file, label);
5083: ASM_OUTPUT_DWARF_STRING (asm_out_file,
5084: filename_table[0].name
5085: ? filename_table[0].name
5086: : "");
5087: ASM_OUTPUT_POP_SECTION (asm_out_file);
5088: }
5089:
5090: /* Lookup a filename (in the list of filenames that we know about here in
5091: dwarfout.c) and return its "index". The index of each (known) filename
5092: is just a unique number which is associated with only that one filename.
5093: We need such numbers for the sake of generating labels (in the
5094: .debug_sfnames section) and references to those unique labels (in the
5095: .debug_srcinfo and .debug_macinfo sections).
5096:
5097: If the filename given as an argument is not found in our current list,
5098: add it to the list and assign it the next available unique index number.
5099:
5100: Whatever we do (i.e. whether we find a pre-existing filename or add a new
5101: one), we shuffle the filename found (or added) up to the zeroth entry of
5102: our list of filenames (which is always searched linearly). We do this so
5103: as to optimize the most common case for these filename lookups within
5104: dwarfout.c. The most common case by far is the case where we call
5105: lookup_filename to lookup the very same filename that we did a lookup
5106: on the last time we called lookup_filename. We make sure that this
5107: common case is fast because such cases will constitute 99.9% of the
5108: lookups we ever do (in practice).
5109:
5110: If we add a new filename entry to our table, we go ahead and generate
5111: the corresponding entry in the .debug_sfnames section right away.
5112: Doing so allows us to avoid tickling an assembler bug (present in some
5113: m68k assemblers) which yields assembly-time errors in cases where the
5114: difference of two label addresses is taken and where the two labels
5115: are in a section *other* than the one where the difference is being
5116: calculated, and where at least one of the two symbol references is a
5117: forward reference. (This bug could be tickled by our .debug_srcinfo
5118: entries if we don't output their corresponding .debug_sfnames entries
5119: before them.)
5120: */
5121:
5122: static unsigned
5123: lookup_filename (file_name)
5124: char *file_name;
5125: {
5126: register filename_entry *search_p;
5127: register filename_entry *limit_p = &filename_table[ft_entries];
5128:
5129: for (search_p = filename_table; search_p < limit_p; search_p++)
5130: if (!strcmp (file_name, search_p->name))
5131: {
5132: /* When we get here, we have found the filename that we were
5133: looking for in the filename_table. Now we want to make sure
5134: that it gets moved to the zero'th entry in the table (if it
5135: is not already there) so that subsequent attempts to find the
5136: same filename will find it as quickly as possible. */
5137:
5138: shuffle_filename_entry (search_p);
5139: return filename_table[0].number;
5140: }
5141:
5142: /* We come here whenever we have a new filename which is not registered
5143: in the current table. Here we add it to the table. */
5144:
5145: /* Prepare to add a new table entry by making sure there is enough space
5146: in the table to do so. If not, expand the current table. */
5147:
5148: if (ft_entries == ft_entries_allocated)
5149: {
5150: ft_entries_allocated += FT_ENTRIES_INCREMENT;
5151: filename_table
5152: = (filename_entry *)
5153: xrealloc (filename_table,
5154: ft_entries_allocated * sizeof (filename_entry));
5155: }
5156:
5157: /* Initially, add the new entry at the end of the filename table. */
5158:
5159: filename_table[ft_entries].number = ft_entries;
5160: filename_table[ft_entries].name = xstrdup (file_name);
5161:
5162: /* Shuffle the new entry into filename_table[0]. */
5163:
5164: shuffle_filename_entry (&filename_table[ft_entries]);
5165:
5166: if (debug_info_level >= DINFO_LEVEL_NORMAL)
5167: generate_new_sfname_entry ();
5168:
5169: ft_entries++;
5170: return filename_table[0].number;
5171: }
5172:
5173: static void
5174: generate_srcinfo_entry (line_entry_num, files_entry_num)
5175: unsigned line_entry_num;
5176: unsigned files_entry_num;
5177: {
5178: char label[MAX_ARTIFICIAL_LABEL_BYTES];
5179:
5180: fputc ('\n', asm_out_file);
5181: ASM_OUTPUT_PUSH_SECTION (asm_out_file, SRCINFO_SECTION);
5182: sprintf (label, LINE_ENTRY_LABEL_FMT, line_entry_num);
5183: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, label, LINE_BEGIN_LABEL);
5184: sprintf (label, SFNAMES_ENTRY_LABEL_FMT, files_entry_num);
5185: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, label, SFNAMES_BEGIN_LABEL);
5186: ASM_OUTPUT_POP_SECTION (asm_out_file);
5187: }
5188:
5189: void
5190: dwarfout_line (filename, line)
5191: register char *filename;
5192: register unsigned line;
5193: {
5194: if (debug_info_level >= DINFO_LEVEL_NORMAL)
5195: {
5196: char label[MAX_ARTIFICIAL_LABEL_BYTES];
5197: static unsigned last_line_entry_num = 0;
5198: static unsigned prev_file_entry_num = (unsigned) -1;
5199: register unsigned this_file_entry_num = lookup_filename (filename);
5200:
5201: text_section ();
5202: sprintf (label, LINE_CODE_LABEL_FMT, ++last_line_entry_num);
5203: ASM_OUTPUT_LABEL (asm_out_file, label);
5204:
5205: fputc ('\n', asm_out_file);
5206: ASM_OUTPUT_PUSH_SECTION (asm_out_file, LINE_SECTION);
5207:
5208: if (this_file_entry_num != prev_file_entry_num)
5209: {
5210: char line_entry_label[MAX_ARTIFICIAL_LABEL_BYTES];
5211:
5212: sprintf (line_entry_label, LINE_ENTRY_LABEL_FMT, last_line_entry_num);
5213: ASM_OUTPUT_LABEL (asm_out_file, line_entry_label);
5214: }
5215:
5216: {
5217: register char *tail = rindex (filename, '/');
5218:
5219: if (tail != NULL)
5220: filename = tail;
5221: }
5222:
5223: fprintf (asm_out_file, "\t%s\t%u\t%s %s:%u\n",
5224: UNALIGNED_INT_ASM_OP, line, ASM_COMMENT_START,
5225: filename, line);
5226: ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 0xffff);
5227: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, label, TEXT_BEGIN_LABEL);
5228: ASM_OUTPUT_POP_SECTION (asm_out_file);
5229:
5230: if (this_file_entry_num != prev_file_entry_num)
5231: generate_srcinfo_entry (last_line_entry_num, this_file_entry_num);
5232: prev_file_entry_num = this_file_entry_num;
5233: }
5234: }
5235:
5236: /* Generate an entry in the .debug_macinfo section. */
5237:
5238: static void
5239: generate_macinfo_entry (type_and_offset, string)
5240: register char *type_and_offset;
5241: register char *string;
5242: {
5243: fputc ('\n', asm_out_file);
5244: ASM_OUTPUT_PUSH_SECTION (asm_out_file, MACINFO_SECTION);
5245: fprintf (asm_out_file, "\t%s\t%s\n", UNALIGNED_INT_ASM_OP, type_and_offset);
5246: ASM_OUTPUT_DWARF_STRING (asm_out_file, string);
5247: ASM_OUTPUT_POP_SECTION (asm_out_file);
5248: }
5249:
5250: void
5251: dwarfout_start_new_source_file (filename)
5252: register char *filename;
5253: {
5254: char label[MAX_ARTIFICIAL_LABEL_BYTES];
5255: char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*3];
5256:
5257: sprintf (label, SFNAMES_ENTRY_LABEL_FMT, lookup_filename (filename));
5258: sprintf (type_and_offset, "0x%08x+%s-%s",
5259: ((unsigned) MACINFO_start << 24), label, SFNAMES_BEGIN_LABEL);
5260: generate_macinfo_entry (type_and_offset, "");
5261: }
5262:
5263: void
5264: dwarfout_resume_previous_source_file (lineno)
5265: register unsigned lineno;
5266: {
5267: char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*2];
5268:
5269: sprintf (type_and_offset, "0x%08x+%u",
5270: ((unsigned) MACINFO_resume << 24), lineno);
5271: generate_macinfo_entry (type_and_offset, "");
5272: }
5273:
5274: /* Called from check_newline in c-parse.y. The `buffer' parameter
5275: contains the tail part of the directive line, i.e. the part which
5276: is past the initial whitespace, #, whitespace, directive-name,
5277: whitespace part. */
5278:
5279: void
5280: dwarfout_define (lineno, buffer)
5281: register unsigned lineno;
5282: register char *buffer;
5283: {
5284: static int initialized = 0;
5285: char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*2];
5286:
5287: if (!initialized)
5288: {
5289: dwarfout_start_new_source_file (primary_filename);
5290: initialized = 1;
5291: }
5292: sprintf (type_and_offset, "0x%08x+%u",
5293: ((unsigned) MACINFO_define << 24), lineno);
5294: generate_macinfo_entry (type_and_offset, buffer);
5295: }
5296:
5297: /* Called from check_newline in c-parse.y. The `buffer' parameter
5298: contains the tail part of the directive line, i.e. the part which
5299: is past the initial whitespace, #, whitespace, directive-name,
5300: whitespace part. */
5301:
5302: void
5303: dwarfout_undef (lineno, buffer)
5304: register unsigned lineno;
5305: register char *buffer;
5306: {
5307: char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*2];
5308:
5309: sprintf (type_and_offset, "0x%08x+%u",
5310: ((unsigned) MACINFO_undef << 24), lineno);
5311: generate_macinfo_entry (type_and_offset, buffer);
5312: }
5313:
5314: /* Set up for Dwarf output at the start of compilation. */
5315:
5316: void
5317: dwarfout_init (asm_out_file, main_input_filename)
5318: register FILE *asm_out_file;
5319: register char *main_input_filename;
5320: {
5321: /* Remember the name of the primary input file. */
5322:
5323: primary_filename = main_input_filename;
5324:
5325: /* Allocate the initial hunk of the pending_sibling_stack. */
5326:
5327: pending_sibling_stack
5328: = (unsigned *)
5329: xmalloc (PENDING_SIBLINGS_INCREMENT * sizeof (unsigned));
5330: pending_siblings_allocated = PENDING_SIBLINGS_INCREMENT;
5331: pending_siblings = 1;
5332:
5333: /* Allocate the initial hunk of the filename_table. */
5334:
5335: filename_table
5336: = (filename_entry *)
5337: xmalloc (FT_ENTRIES_INCREMENT * sizeof (filename_entry));
5338: ft_entries_allocated = FT_ENTRIES_INCREMENT;
5339: ft_entries = 0;
5340:
5341: /* Allocate the initial hunk of the pending_types_list. */
5342:
5343: pending_types_list
5344: = (tree *) xmalloc (PENDING_TYPES_INCREMENT * sizeof (tree));
5345: pending_types_allocated = PENDING_TYPES_INCREMENT;
5346: pending_types = 0;
5347:
5348: /* Create an artificial RECORD_TYPE node which we can use in our hack
5349: to get the DIEs representing types of formal parameters to come out
5350: only *after* the DIEs for the formal parameters themselves. */
5351:
5352: fake_containing_scope = make_node (RECORD_TYPE);
5353:
5354: /* Output a starting label for the .text section. */
5355:
5356: fputc ('\n', asm_out_file);
5357: ASM_OUTPUT_PUSH_SECTION (asm_out_file, TEXT_SECTION);
5358: ASM_OUTPUT_LABEL (asm_out_file, TEXT_BEGIN_LABEL);
5359: ASM_OUTPUT_POP_SECTION (asm_out_file);
5360:
5361: /* Output a starting label for the .data section. */
5362:
5363: fputc ('\n', asm_out_file);
5364: ASM_OUTPUT_PUSH_SECTION (asm_out_file, DATA_SECTION);
5365: ASM_OUTPUT_LABEL (asm_out_file, DATA_BEGIN_LABEL);
5366: ASM_OUTPUT_POP_SECTION (asm_out_file);
5367:
5368: #if 0 /* GNU C doesn't currently use .data1. */
5369: /* Output a starting label for the .data1 section. */
5370:
5371: fputc ('\n', asm_out_file);
5372: ASM_OUTPUT_PUSH_SECTION (asm_out_file, DATA1_SECTION);
5373: ASM_OUTPUT_LABEL (asm_out_file, DATA1_BEGIN_LABEL);
5374: ASM_OUTPUT_POP_SECTION (asm_out_file);
5375: #endif
5376:
5377: /* Output a starting label for the .rodata section. */
5378:
5379: fputc ('\n', asm_out_file);
5380: ASM_OUTPUT_PUSH_SECTION (asm_out_file, RODATA_SECTION);
5381: ASM_OUTPUT_LABEL (asm_out_file, RODATA_BEGIN_LABEL);
5382: ASM_OUTPUT_POP_SECTION (asm_out_file);
5383:
5384: #if 0 /* GNU C doesn't currently use .rodata1. */
5385: /* Output a starting label for the .rodata1 section. */
5386:
5387: fputc ('\n', asm_out_file);
5388: ASM_OUTPUT_PUSH_SECTION (asm_out_file, RODATA1_SECTION);
5389: ASM_OUTPUT_LABEL (asm_out_file, RODATA1_BEGIN_LABEL);
5390: ASM_OUTPUT_POP_SECTION (asm_out_file);
5391: #endif
5392:
5393: /* Output a starting label for the .bss section. */
5394:
5395: fputc ('\n', asm_out_file);
5396: ASM_OUTPUT_PUSH_SECTION (asm_out_file, BSS_SECTION);
5397: ASM_OUTPUT_LABEL (asm_out_file, BSS_BEGIN_LABEL);
5398: ASM_OUTPUT_POP_SECTION (asm_out_file);
5399:
5400: if (debug_info_level >= DINFO_LEVEL_NORMAL)
5401: {
5402: /* Output a starting label and an initial (compilation directory)
5403: entry for the .debug_sfnames section. The starting label will be
5404: referenced by the initial entry in the .debug_srcinfo section. */
5405:
5406: fputc ('\n', asm_out_file);
5407: ASM_OUTPUT_PUSH_SECTION (asm_out_file, SFNAMES_SECTION);
5408: ASM_OUTPUT_LABEL (asm_out_file, SFNAMES_BEGIN_LABEL);
5409: {
5410: register char *pwd;
5411: register unsigned len;
5412: register char *dirname;
5413:
5414: pwd = getpwd ();
5415: if (!pwd)
5416: pfatal_with_name ("getpwd");
5417: len = strlen (pwd);
5418: dirname = (char *) xmalloc (len + 2);
5419:
5420: strcpy (dirname, pwd);
5421: strcpy (dirname + len, "/");
5422: ASM_OUTPUT_DWARF_STRING (asm_out_file, dirname);
5423: free (dirname);
5424: }
5425: ASM_OUTPUT_POP_SECTION (asm_out_file);
5426:
5427: if (debug_info_level >= DINFO_LEVEL_VERBOSE)
5428: {
5429: /* Output a starting label for the .debug_macinfo section. This
5430: label will be referenced by the AT_mac_info attribute in the
5431: TAG_compile_unit DIE. */
5432:
5433: fputc ('\n', asm_out_file);
5434: ASM_OUTPUT_PUSH_SECTION (asm_out_file, MACINFO_SECTION);
5435: ASM_OUTPUT_LABEL (asm_out_file, MACINFO_BEGIN_LABEL);
5436: ASM_OUTPUT_POP_SECTION (asm_out_file);
5437: }
5438:
5439: /* Generate the initial entry for the .line section. */
5440:
5441: fputc ('\n', asm_out_file);
5442: ASM_OUTPUT_PUSH_SECTION (asm_out_file, LINE_SECTION);
5443: ASM_OUTPUT_LABEL (asm_out_file, LINE_BEGIN_LABEL);
5444: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, LINE_END_LABEL, LINE_BEGIN_LABEL);
5445: ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_BEGIN_LABEL);
5446: ASM_OUTPUT_POP_SECTION (asm_out_file);
5447:
5448: /* Generate the initial entry for the .debug_srcinfo section. */
5449:
5450: fputc ('\n', asm_out_file);
5451: ASM_OUTPUT_PUSH_SECTION (asm_out_file, SRCINFO_SECTION);
5452: ASM_OUTPUT_LABEL (asm_out_file, SRCINFO_BEGIN_LABEL);
5453: ASM_OUTPUT_DWARF_ADDR (asm_out_file, LINE_BEGIN_LABEL);
5454: ASM_OUTPUT_DWARF_ADDR (asm_out_file, SFNAMES_BEGIN_LABEL);
5455: ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_BEGIN_LABEL);
5456: ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_END_LABEL);
5457: #ifdef DWARF_TIMESTAMPS
5458: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, time (NULL));
5459: #else
5460: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, -1);
5461: #endif
5462: ASM_OUTPUT_POP_SECTION (asm_out_file);
5463:
5464: /* Generate the initial entry for the .debug_pubnames section. */
5465:
5466: fputc ('\n', asm_out_file);
5467: ASM_OUTPUT_PUSH_SECTION (asm_out_file, PUBNAMES_SECTION);
5468: ASM_OUTPUT_DWARF_ADDR (asm_out_file, DEBUG_BEGIN_LABEL);
5469: ASM_OUTPUT_POP_SECTION (asm_out_file);
5470:
5471: /* Generate the initial entry for the .debug_aranges section. */
5472:
5473: fputc ('\n', asm_out_file);
5474: ASM_OUTPUT_PUSH_SECTION (asm_out_file, ARANGES_SECTION);
5475: ASM_OUTPUT_DWARF_ADDR (asm_out_file, DEBUG_BEGIN_LABEL);
5476: ASM_OUTPUT_POP_SECTION (asm_out_file);
5477: }
5478:
5479: /* Setup first DIE number == 1. */
5480: NEXT_DIE_NUM = next_unused_dienum++;
5481:
5482: /* Generate the initial DIE for the .debug section. Note that the
5483: (string) value given in the AT_name attribute of the TAG_compile_unit
5484: DIE will (typically) be a relative pathname and that this pathname
5485: should be taken as being relative to the directory from which the
5486: compiler was invoked when the given (base) source file was compiled. */
5487:
5488: fputc ('\n', asm_out_file);
5489: ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SECTION);
5490: ASM_OUTPUT_LABEL (asm_out_file, DEBUG_BEGIN_LABEL);
5491: output_die (output_compile_unit_die, main_input_filename);
5492: ASM_OUTPUT_POP_SECTION (asm_out_file);
5493:
5494: fputc ('\n', asm_out_file);
5495: }
5496:
5497: /* Output stuff that dwarf requires at the end of every file. */
5498:
5499: void
5500: dwarfout_finish ()
5501: {
5502: char label[MAX_ARTIFICIAL_LABEL_BYTES];
5503:
5504: fputc ('\n', asm_out_file);
5505: ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SECTION);
5506:
5507: /* Mark the end of the chain of siblings which represent all file-scope
5508: declarations in this compilation unit. */
5509:
5510: /* The (null) DIE which represents the terminator for the (sibling linked)
5511: list of file-scope items is *special*. Normally, we would just call
5512: end_sibling_chain at this point in order to output a word with the
5513: value `4' and that word would act as the terminator for the list of
5514: DIEs describing file-scope items. Unfortunately, if we were to simply
5515: do that, the label that would follow this DIE in the .debug section
5516: (i.e. `..D2') would *not* be properly aligned (as it must be on some
5517: machines) to a 4 byte boundary.
5518:
5519: In order to force the label `..D2' to get aligned to a 4 byte boundary,
5520: the trick used is to insert extra (otherwise useless) padding bytes
5521: into the (null) DIE that we know must precede the ..D2 label in the
5522: .debug section. The amount of padding required can be anywhere between
5523: 0 and 3 bytes. The length word at the start of this DIE (i.e. the one
5524: with the padding) would normally contain the value 4, but now it will
5525: also have to include the padding bytes, so it will instead have some
5526: value in the range 4..7.
5527:
5528: Fortunately, the rules of Dwarf say that any DIE whose length word
5529: contains *any* value less than 8 should be treated as a null DIE, so
5530: this trick works out nicely. Clever, eh? Don't give me any credit
5531: (or blame). I didn't think of this scheme. I just conformed to it.
5532: */
5533:
5534: output_die (output_padded_null_die, (void *)0);
5535: dienum_pop ();
5536:
5537: sprintf (label, DIE_BEGIN_LABEL_FMT, NEXT_DIE_NUM);
5538: ASM_OUTPUT_LABEL (asm_out_file, label); /* should be ..D2 */
5539: ASM_OUTPUT_POP_SECTION (asm_out_file);
5540:
5541: /* Output a terminator label for the .text section. */
5542:
5543: fputc ('\n', asm_out_file);
5544: ASM_OUTPUT_PUSH_SECTION (asm_out_file, TEXT_SECTION);
5545: ASM_OUTPUT_LABEL (asm_out_file, TEXT_END_LABEL);
5546: ASM_OUTPUT_POP_SECTION (asm_out_file);
5547:
5548: /* Output a terminator label for the .data section. */
5549:
5550: fputc ('\n', asm_out_file);
5551: ASM_OUTPUT_PUSH_SECTION (asm_out_file, DATA_SECTION);
5552: ASM_OUTPUT_LABEL (asm_out_file, DATA_END_LABEL);
5553: ASM_OUTPUT_POP_SECTION (asm_out_file);
5554:
5555: #if 0 /* GNU C doesn't currently use .data1. */
5556: /* Output a terminator label for the .data1 section. */
5557:
5558: fputc ('\n', asm_out_file);
5559: ASM_OUTPUT_PUSH_SECTION (asm_out_file, DATA1_SECTION);
5560: ASM_OUTPUT_LABEL (asm_out_file, DATA1_END_LABEL);
5561: ASM_OUTPUT_POP_SECTION (asm_out_file);
5562: #endif
5563:
5564: /* Output a terminator label for the .rodata section. */
5565:
5566: fputc ('\n', asm_out_file);
5567: ASM_OUTPUT_PUSH_SECTION (asm_out_file, RODATA_SECTION);
5568: ASM_OUTPUT_LABEL (asm_out_file, RODATA_END_LABEL);
5569: ASM_OUTPUT_POP_SECTION (asm_out_file);
5570:
5571: #if 0 /* GNU C doesn't currently use .rodata1. */
5572: /* Output a terminator label for the .rodata1 section. */
5573:
5574: fputc ('\n', asm_out_file);
5575: ASM_OUTPUT_PUSH_SECTION (asm_out_file, RODATA1_SECTION);
5576: ASM_OUTPUT_LABEL (asm_out_file, RODATA1_END_LABEL);
5577: ASM_OUTPUT_POP_SECTION (asm_out_file);
5578: #endif
5579:
5580: /* Output a terminator label for the .bss section. */
5581:
5582: fputc ('\n', asm_out_file);
5583: ASM_OUTPUT_PUSH_SECTION (asm_out_file, BSS_SECTION);
5584: ASM_OUTPUT_LABEL (asm_out_file, BSS_END_LABEL);
5585: ASM_OUTPUT_POP_SECTION (asm_out_file);
5586:
5587: if (debug_info_level >= DINFO_LEVEL_NORMAL)
5588: {
5589: /* Output a terminating entry for the .line section. */
5590:
5591: fputc ('\n', asm_out_file);
5592: ASM_OUTPUT_PUSH_SECTION (asm_out_file, LINE_SECTION);
5593: ASM_OUTPUT_LABEL (asm_out_file, LINE_LAST_ENTRY_LABEL);
5594: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
5595: ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 0xffff);
5596: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, TEXT_END_LABEL, TEXT_BEGIN_LABEL);
5597: ASM_OUTPUT_LABEL (asm_out_file, LINE_END_LABEL);
5598: ASM_OUTPUT_POP_SECTION (asm_out_file);
5599:
5600: /* Output a terminating entry for the .debug_srcinfo section. */
5601:
5602: fputc ('\n', asm_out_file);
5603: ASM_OUTPUT_PUSH_SECTION (asm_out_file, SRCINFO_SECTION);
5604: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file,
5605: LINE_LAST_ENTRY_LABEL, LINE_BEGIN_LABEL);
5606: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, -1);
5607: ASM_OUTPUT_POP_SECTION (asm_out_file);
5608:
5609: if (debug_info_level >= DINFO_LEVEL_VERBOSE)
5610: {
5611: /* Output terminating entries for the .debug_macinfo section. */
5612:
5613: dwarfout_resume_previous_source_file (0);
5614:
5615: fputc ('\n', asm_out_file);
5616: ASM_OUTPUT_PUSH_SECTION (asm_out_file, MACINFO_SECTION);
5617: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
5618: ASM_OUTPUT_DWARF_STRING (asm_out_file, "");
5619: ASM_OUTPUT_POP_SECTION (asm_out_file);
5620: }
5621:
5622: /* Generate the terminating entry for the .debug_pubnames section. */
5623:
5624: fputc ('\n', asm_out_file);
5625: ASM_OUTPUT_PUSH_SECTION (asm_out_file, PUBNAMES_SECTION);
5626: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
5627: ASM_OUTPUT_DWARF_STRING (asm_out_file, "");
5628: ASM_OUTPUT_POP_SECTION (asm_out_file);
5629:
5630: /* Generate the terminating entries for the .debug_aranges section.
5631:
5632: Note that we want to do this only *after* we have output the end
5633: labels (for the various program sections) which we are going to
5634: refer to here. This allows us to work around a bug in the m68k
5635: svr4 assembler. That assembler gives bogus assembly-time errors
5636: if (within any given section) you try to take the difference of
5637: two relocatable symbols, both of which are located within some
5638: other section, and if one (or both?) of the symbols involved is
5639: being forward-referenced. By generating the .debug_aranges
5640: entries at this late point in the assembly output, we skirt the
5641: issue simply by avoiding forward-references.
5642: */
5643:
5644: fputc ('\n', asm_out_file);
5645: ASM_OUTPUT_PUSH_SECTION (asm_out_file, ARANGES_SECTION);
5646:
5647: ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_BEGIN_LABEL);
5648: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, TEXT_END_LABEL, TEXT_BEGIN_LABEL);
5649:
5650: ASM_OUTPUT_DWARF_ADDR (asm_out_file, DATA_BEGIN_LABEL);
5651: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, DATA_END_LABEL, DATA_BEGIN_LABEL);
5652:
5653: #if 0 /* GNU C doesn't currently use .data1. */
5654: ASM_OUTPUT_DWARF_ADDR (asm_out_file, DATA1_BEGIN_LABEL);
5655: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, DATA1_END_LABEL,
5656: DATA1_BEGIN_LABEL);
5657: #endif
5658:
5659: ASM_OUTPUT_DWARF_ADDR (asm_out_file, RODATA_BEGIN_LABEL);
5660: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, RODATA_END_LABEL,
5661: RODATA_BEGIN_LABEL);
5662:
5663: #if 0 /* GNU C doesn't currently use .rodata1. */
5664: ASM_OUTPUT_DWARF_ADDR (asm_out_file, RODATA1_BEGIN_LABEL);
5665: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, RODATA1_END_LABEL,
5666: RODATA1_BEGIN_LABEL);
5667: #endif
5668:
5669: ASM_OUTPUT_DWARF_ADDR (asm_out_file, BSS_BEGIN_LABEL);
5670: ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, BSS_END_LABEL, BSS_BEGIN_LABEL);
5671:
5672: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
5673: ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
5674:
5675: ASM_OUTPUT_POP_SECTION (asm_out_file);
5676: }
5677: }
5678:
5679: #endif /* DWARF_DEBUGGING_INFO */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.