1/* Output Dwarf2 format symbol table information from the GNU C compiler.
|
2 Copyright (C) 1992, 93, 95, 96, 97, 1998 Free Software Foundation, Inc.
|
| 2 Copyright (C) 1992, 93, 95-98, 1999 Free Software Foundation, Inc. |
3 Contributed by Gary Funck (gary@intrepid.com).
4 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
5 Extensively modified by Jason Merrill (jason@cygnus.com).
6
7This file is part of GNU CC.
8
9GNU CC is free software; you can redistribute it and/or modify
10it under the terms of the GNU General Public License as published by
11the Free Software Foundation; either version 2, or (at your option)
12any later version.
13
14GNU CC is distributed in the hope that it will be useful,
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17GNU General Public License for more details.
18
19You should have received a copy of the GNU General Public License
20along with GNU CC; see the file COPYING. If not, write to
|
21the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
|
21the Free Software Foundation, 59 Temple Place - Suite 330,
22Boston, MA 02111-1307, USA. */ |
23
24/* The first part of this file deals with the DWARF 2 frame unwind
25 information, which is also used by the GCC efficient exception handling
26 mechanism. The second part, controlled only by an #ifdef
27 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
28 information. */
29
30#include "config.h"
31#include "system.h"
32#include "defaults.h"
33#include "tree.h"
34#include "flags.h"
35#include "rtl.h"
36#include "hard-reg-set.h"
37#include "regs.h"
38#include "insn-config.h"
39#include "reload.h"
40#include "output.h"
41#include "expr.h"
42#include "except.h"
43#include "dwarf2.h"
44#include "dwarf2out.h"
45#include "toplev.h"
46#include "dyn-string.h"
47
48/* We cannot use <assert.h> in GCC source, since that would include
49 GCC's assert.h, which may not be compatible with the host compiler. */
50#undef assert
51#ifdef NDEBUG
52# define assert(e)
53#else
54# define assert(e) do { if (! (e)) abort (); } while (0)
55#endif
56
57/* Decide whether we want to emit frame unwind information for the current
58 translation unit. */
59
60int
61dwarf2out_do_frame ()
62{
63 return (write_symbols == DWARF2_DEBUG
64#ifdef DWARF2_FRAME_INFO
65 || DWARF2_FRAME_INFO
66#endif
67#ifdef DWARF2_UNWIND_INFO
68 || (flag_exceptions && ! exceptions_via_longjmp)
69#endif
70 );
71}
72
73#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
74
|
74#ifndef __GNUC__
75#define inline
76#endif
77
|
75/* How to start an assembler comment. */
76#ifndef ASM_COMMENT_START
77#define ASM_COMMENT_START ";#"
78#endif
79
80typedef struct dw_cfi_struct *dw_cfi_ref;
81typedef struct dw_fde_struct *dw_fde_ref;
82typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
83
84/* Call frames are described using a sequence of Call Frame
85 Information instructions. The register number, offset
86 and address fields are provided as possible operands;
87 their use is selected by the opcode field. */
88
89typedef union dw_cfi_oprnd_struct
90{
91 unsigned long dw_cfi_reg_num;
92 long int dw_cfi_offset;
93 char *dw_cfi_addr;
94}
95dw_cfi_oprnd;
96
97typedef struct dw_cfi_struct
98{
99 dw_cfi_ref dw_cfi_next;
100 enum dwarf_call_frame_info dw_cfi_opc;
101 dw_cfi_oprnd dw_cfi_oprnd1;
102 dw_cfi_oprnd dw_cfi_oprnd2;
103}
104dw_cfi_node;
105
106/* All call frame descriptions (FDE's) in the GCC generated DWARF
107 refer to a single Common Information Entry (CIE), defined at
108 the beginning of the .debug_frame section. This used of a single
109 CIE obviates the need to keep track of multiple CIE's
110 in the DWARF generation routines below. */
111
112typedef struct dw_fde_struct
113{
114 char *dw_fde_begin;
115 char *dw_fde_current_label;
116 char *dw_fde_end;
117 dw_cfi_ref dw_fde_cfi;
118}
119dw_fde_node;
120
121/* Maximum size (in bytes) of an artificially generated label. */
122#define MAX_ARTIFICIAL_LABEL_BYTES 30
123
124/* Make sure we know the sizes of the various types dwarf can describe. These
125 are only defaults. If the sizes are different for your target, you should
126 override these values by defining the appropriate symbols in your tm.h
127 file. */
128
129#ifndef CHAR_TYPE_SIZE
130#define CHAR_TYPE_SIZE BITS_PER_UNIT
131#endif
132#ifndef PTR_SIZE
133#define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
134#endif
135
136/* The size in bytes of a DWARF field indicating an offset or length
137 relative to a debug info section, specified to be 4 bytes in the DWARF-2
138 specification. The SGI/MIPS ABI defines it to be the same as PTR_SIZE. */
139
140#ifndef DWARF_OFFSET_SIZE
141#define DWARF_OFFSET_SIZE 4
142#endif
143
144#define DWARF_VERSION 2
145
146/* Round SIZE up to the nearest BOUNDARY. */
147#define DWARF_ROUND(SIZE,BOUNDARY) \
148 (((SIZE) + (BOUNDARY) - 1) & ~((BOUNDARY) - 1))
149
150/* Offsets recorded in opcodes are a multiple of this alignment factor. */
151#ifdef STACK_GROWS_DOWNWARD
152#define DWARF_CIE_DATA_ALIGNMENT (-UNITS_PER_WORD)
153#else
154#define DWARF_CIE_DATA_ALIGNMENT UNITS_PER_WORD
155#endif
156
157/* A pointer to the base of a table that contains frame description
158 information for each routine. */
159static dw_fde_ref fde_table;
160
161/* Number of elements currently allocated for fde_table. */
162static unsigned fde_table_allocated;
163
164/* Number of elements in fde_table currently in use. */
165static unsigned fde_table_in_use;
166
167/* Size (in elements) of increments by which we may expand the
168 fde_table. */
169#define FDE_TABLE_INCREMENT 256
170
171/* A list of call frame insns for the CIE. */
172static dw_cfi_ref cie_cfi_head;
173
174/* The number of the current function definition for which debugging
175 information is being generated. These numbers range from 1 up to the
176 maximum number of function definitions contained within the current
177 compilation unit. These numbers are used to create unique label id's
178 unique to each function definition. */
179static unsigned current_funcdef_number = 0;
180
181/* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
182 attribute that accelerates the lookup of the FDE associated
183 with the subprogram. This variable holds the table index of the FDE
184 associated with the current function (body) definition. */
185static unsigned current_funcdef_fde;
186
187/* Forward declarations for functions defined in this file. */
188
189static char *stripattributes PROTO((char *));
190static char *dwarf_cfi_name PROTO((unsigned));
191static dw_cfi_ref new_cfi PROTO((void));
192static void add_cfi PROTO((dw_cfi_ref *, dw_cfi_ref));
193static unsigned long size_of_uleb128 PROTO((unsigned long));
194static unsigned long size_of_sleb128 PROTO((long));
195static void output_uleb128 PROTO((unsigned long));
196static void output_sleb128 PROTO((long));
197static void add_fde_cfi PROTO((char *, dw_cfi_ref));
198static void lookup_cfa_1 PROTO((dw_cfi_ref, unsigned long *,
199 long *));
200static void lookup_cfa PROTO((unsigned long *, long *));
201static void reg_save PROTO((char *, unsigned, unsigned,
202 long));
203static void initial_return_save PROTO((rtx));
204static void output_cfi PROTO((dw_cfi_ref, dw_fde_ref));
205static void output_call_frame_info PROTO((int));
206static unsigned reg_number PROTO((rtx));
207static void dwarf2out_stack_adjust PROTO((rtx));
208
209/* Definitions of defaults for assembler-dependent names of various
210 pseudo-ops and section names.
211 Theses may be overridden in the tm.h file (if necessary) for a particular
212 assembler. */
213
214#ifdef OBJECT_FORMAT_ELF
215#ifndef UNALIGNED_SHORT_ASM_OP
216#define UNALIGNED_SHORT_ASM_OP ".2byte"
217#endif
218#ifndef UNALIGNED_INT_ASM_OP
219#define UNALIGNED_INT_ASM_OP ".4byte"
220#endif
221#ifndef UNALIGNED_DOUBLE_INT_ASM_OP
222#define UNALIGNED_DOUBLE_INT_ASM_OP ".8byte"
223#endif
224#endif /* OBJECT_FORMAT_ELF */
225
226#ifndef ASM_BYTE_OP
227#define ASM_BYTE_OP ".byte"
228#endif
229
230/* Data and reference forms for relocatable data. */
231#define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
232#define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
233
234/* Pseudo-op for defining a new section. */
235#ifndef SECTION_ASM_OP
236#define SECTION_ASM_OP ".section"
237#endif
238
239/* The default format used by the ASM_OUTPUT_SECTION macro (see below) to
240 print the SECTION_ASM_OP and the section name. The default here works for
241 almost all svr4 assemblers, except for the sparc, where the section name
242 must be enclosed in double quotes. (See sparcv4.h). */
243#ifndef SECTION_FORMAT
244#ifdef PUSHSECTION_FORMAT
245#define SECTION_FORMAT PUSHSECTION_FORMAT
246#else
247#define SECTION_FORMAT "\t%s\t%s\n"
248#endif
249#endif
250
251#ifndef FRAME_SECTION
252#define FRAME_SECTION ".debug_frame"
253#endif
254
255#ifndef FUNC_BEGIN_LABEL
256#define FUNC_BEGIN_LABEL "LFB"
257#endif
258#ifndef FUNC_END_LABEL
259#define FUNC_END_LABEL "LFE"
260#endif
261#define CIE_AFTER_SIZE_LABEL "LSCIE"
262#define CIE_END_LABEL "LECIE"
263#define CIE_LENGTH_LABEL "LLCIE"
264#define FDE_AFTER_SIZE_LABEL "LSFDE"
265#define FDE_END_LABEL "LEFDE"
266#define FDE_LENGTH_LABEL "LLFDE"
267
268/* Definitions of defaults for various types of primitive assembly language
269 output operations. These may be overridden from within the tm.h file,
270 but typically, that is unnecessary. */
271
272#ifndef ASM_OUTPUT_SECTION
273#define ASM_OUTPUT_SECTION(FILE, SECTION) \
274 fprintf ((FILE), SECTION_FORMAT, SECTION_ASM_OP, SECTION)
275#endif
276
277#ifndef ASM_OUTPUT_DWARF_DATA1
278#define ASM_OUTPUT_DWARF_DATA1(FILE,VALUE) \
279 fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) (VALUE))
280#endif
281
282#ifndef ASM_OUTPUT_DWARF_DELTA1
283#define ASM_OUTPUT_DWARF_DELTA1(FILE,LABEL1,LABEL2) \
284 do { fprintf ((FILE), "\t%s\t", ASM_BYTE_OP); \
285 assemble_name (FILE, LABEL1); \
286 fprintf (FILE, "-"); \
287 assemble_name (FILE, LABEL2); \
288 } while (0)
289#endif
290
291#ifdef UNALIGNED_INT_ASM_OP
292
293#ifndef UNALIGNED_OFFSET_ASM_OP
294#define UNALIGNED_OFFSET_ASM_OP \
295 (DWARF_OFFSET_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
296#endif
297
298#ifndef UNALIGNED_WORD_ASM_OP
299#define UNALIGNED_WORD_ASM_OP \
300 (PTR_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
301#endif
302
303#ifndef ASM_OUTPUT_DWARF_DELTA2
304#define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
305 do { fprintf ((FILE), "\t%s\t", UNALIGNED_SHORT_ASM_OP); \
306 assemble_name (FILE, LABEL1); \
307 fprintf (FILE, "-"); \
308 assemble_name (FILE, LABEL2); \
309 } while (0)
310#endif
311
312#ifndef ASM_OUTPUT_DWARF_DELTA4
313#define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
314 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
315 assemble_name (FILE, LABEL1); \
316 fprintf (FILE, "-"); \
317 assemble_name (FILE, LABEL2); \
318 } while (0)
319#endif
320
321#ifndef ASM_OUTPUT_DWARF_DELTA
322#define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \
323 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \
324 assemble_name (FILE, LABEL1); \
325 fprintf (FILE, "-"); \
326 assemble_name (FILE, LABEL2); \
327 } while (0)
328#endif
329
330#ifndef ASM_OUTPUT_DWARF_ADDR_DELTA
331#define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \
332 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \
333 assemble_name (FILE, LABEL1); \
334 fprintf (FILE, "-"); \
335 assemble_name (FILE, LABEL2); \
336 } while (0)
337#endif
338
339#ifndef ASM_OUTPUT_DWARF_ADDR
340#define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
341 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \
342 assemble_name (FILE, LABEL); \
343 } while (0)
344#endif
345
|
346/* ??? This macro takes an RTX in dwarfout.c and a string in dwarf2out.c.
347 We resolve the conflict by creating a new macro ASM_OUTPUT_DWARF2_ADDR_CONST
348 for ports that want to support both DWARF1 and DWARF2. This needs a better
349 solution. See also the comments in sparc/sp64-elf.h. */
350#ifdef ASM_OUTPUT_DWARF2_ADDR_CONST
351#undef ASM_OUTPUT_DWARF_ADDR_CONST
352#define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,ADDR) \
353 ASM_OUTPUT_DWARF2_ADDR_CONST (FILE, ADDR)
354#endif
355 |
356#ifndef ASM_OUTPUT_DWARF_ADDR_CONST
357#define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,ADDR) \
358 fprintf ((FILE), "\t%s\t%s", UNALIGNED_WORD_ASM_OP, (ADDR))
359#endif
360
361#ifndef ASM_OUTPUT_DWARF_OFFSET4
362#define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \
363 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
364 assemble_name (FILE, LABEL); \
365 } while (0)
366#endif
367
368#ifndef ASM_OUTPUT_DWARF_OFFSET
369#define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \
370 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \
371 assemble_name (FILE, LABEL); \
372 } while (0)
373#endif
374
375#ifndef ASM_OUTPUT_DWARF_DATA2
376#define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \
377 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_SHORT_ASM_OP, (unsigned) (VALUE))
378#endif
379
380#ifndef ASM_OUTPUT_DWARF_DATA4
381#define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
382 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_INT_ASM_OP, (unsigned) (VALUE))
383#endif
384
385#ifndef ASM_OUTPUT_DWARF_DATA
386#define ASM_OUTPUT_DWARF_DATA(FILE,VALUE) \
387 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_OFFSET_ASM_OP, \
388 (unsigned long) (VALUE))
389#endif
390
391#ifndef ASM_OUTPUT_DWARF_ADDR_DATA
392#define ASM_OUTPUT_DWARF_ADDR_DATA(FILE,VALUE) \
393 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_WORD_ASM_OP, \
394 (unsigned long) (VALUE))
395#endif
396
397#ifndef ASM_OUTPUT_DWARF_DATA8
398#define ASM_OUTPUT_DWARF_DATA8(FILE,HIGH_VALUE,LOW_VALUE) \
399 do { \
400 if (WORDS_BIG_ENDIAN) \
401 { \
402 fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (HIGH_VALUE));\
403 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (LOW_VALUE));\
404 } \
405 else \
406 { \
407 fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (LOW_VALUE)); \
408 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (HIGH_VALUE)); \
409 } \
410 } while (0)
411#endif
412
413#else /* UNALIGNED_INT_ASM_OP */
414
415/* We don't have unaligned support, let's hope the normal output works for
416 .debug_frame. */
417
418#define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
419 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, LABEL), PTR_SIZE, 1)
420
421#define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \
422 assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1)
423
424#define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \
425 assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1)
426
427#define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
428 assemble_integer (gen_rtx_MINUS (HImode, \
429 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
430 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
431 2, 1)
432
433#define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
434 assemble_integer (gen_rtx_MINUS (SImode, \
435 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
436 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
437 4, 1)
438
439#define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \
440 assemble_integer (gen_rtx_MINUS (Pmode, \
441 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
442 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
443 PTR_SIZE, 1)
444
445#define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \
446 ASM_OUTPUT_DWARF_DELTA4 (FILE,LABEL1,LABEL2)
447
448#define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
449 assemble_integer (GEN_INT (VALUE), 4, 1)
450
451#endif /* UNALIGNED_INT_ASM_OP */
452
453#ifdef SET_ASM_OP
454#ifndef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
455#define ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL(FILE, SY, HI, LO) \
456 do { \
457 fprintf (FILE, "\t%s\t", SET_ASM_OP); \
458 assemble_name (FILE, SY); \
459 fputc (',', FILE); \
460 assemble_name (FILE, HI); \
461 fputc ('-', FILE); \
462 assemble_name (FILE, LO); \
463 } while (0)
464#endif
465#endif /* SET_ASM_OP */
466
467/* This is similar to the default ASM_OUTPUT_ASCII, except that no trailing
468 newline is produced. When flag_debug_asm is asserted, we add commentary
469 at the end of the line, so we must avoid output of a newline here. */
470#ifndef ASM_OUTPUT_DWARF_STRING
471#define ASM_OUTPUT_DWARF_STRING(FILE,P) \
472 do { \
473 register int slen = strlen(P); \
474 register char *p = (P); \
475 register int i; \
476 fprintf (FILE, "\t.ascii \""); \
477 for (i = 0; i < slen; i++) \
478 { \
479 register int c = p[i]; \
480 if (c == '\"' || c == '\\') \
481 putc ('\\', FILE); \
482 if (c >= ' ' && c < 0177) \
483 putc (c, FILE); \
484 else \
485 { \
486 fprintf (FILE, "\\%o", c); \
487 } \
488 } \
489 fprintf (FILE, "\\0\""); \
490 } \
491 while (0)
492#endif
493
494/* The DWARF 2 CFA column which tracks the return address. Normally this
495 is the column for PC, or the first column after all of the hard
496 registers. */
497#ifndef DWARF_FRAME_RETURN_COLUMN
498#ifdef PC_REGNUM
499#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
500#else
501#define DWARF_FRAME_RETURN_COLUMN FIRST_PSEUDO_REGISTER
502#endif
503#endif
504
505/* The mapping from gcc register number to DWARF 2 CFA column number. By
506 default, we just provide columns for all registers. */
507#ifndef DWARF_FRAME_REGNUM
508#define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
509#endif
510
511/* Hook used by __throw. */
512
513rtx
514expand_builtin_dwarf_fp_regnum ()
515{
516 return GEN_INT (DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM));
517}
518
519/* The offset from the incoming value of %sp to the top of the stack frame
520 for the current function. */
521#ifndef INCOMING_FRAME_SP_OFFSET
522#define INCOMING_FRAME_SP_OFFSET 0
523#endif
524
525/* Return a pointer to a copy of the section string name S with all
526 attributes stripped off, and an asterisk prepended (for assemble_name). */
527
528static inline char *
529stripattributes (s)
530 char *s;
531{
532 char *stripped = xmalloc (strlen (s) + 2);
533 char *p = stripped;
534
535 *p++ = '*';
536
537 while (*s && *s != ',')
538 *p++ = *s++;
539
540 *p = '\0';
541 return stripped;
542}
543
544/* Return the register number described by a given RTL node. */
545
546static unsigned
547reg_number (rtl)
548 register rtx rtl;
549{
550 register unsigned regno = REGNO (rtl);
551
552 if (regno >= FIRST_PSEUDO_REGISTER)
553 {
554 warning ("internal regno botch: regno = %d\n", regno);
555 regno = 0;
556 }
557
558 regno = DBX_REGISTER_NUMBER (regno);
559 return regno;
560}
561
562struct reg_size_range
563{
564 int beg;
565 int end;
566 int size;
567};
568
569/* Given a register number in REG_TREE, return an rtx for its size in bytes.
570 We do this in kind of a roundabout way, by building up a list of
571 register size ranges and seeing where our register falls in one of those
572 ranges. We need to do it this way because REG_TREE is not a constant,
573 and the target macros were not designed to make this task easy. */
574
575rtx
576expand_builtin_dwarf_reg_size (reg_tree, target)
577 tree reg_tree;
578 rtx target;
579{
580 enum machine_mode mode;
581 int size;
582 struct reg_size_range ranges[5];
583 tree t, t2;
584
585 int i = 0;
586 int n_ranges = 0;
587 int last_size = -1;
588
589 for (; i < FIRST_PSEUDO_REGISTER; ++i)
590 {
591 /* The return address is out of order on the MIPS, and we don't use
592 copy_reg for it anyway, so we don't care here how large it is. */
593 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
594 continue;
595
596 mode = reg_raw_mode[i];
597
598 /* CCmode is arbitrarily given a size of 4 bytes. It is more useful
599 to use the same size as word_mode, since that reduces the number
600 of ranges we need. It should not matter, since the result should
601 never be used for a condition code register anyways. */
602 if (GET_MODE_CLASS (mode) == MODE_CC)
603 mode = word_mode;
604
605 size = GET_MODE_SIZE (mode);
606
607 /* If this register is not valid in the specified mode and
608 we have a previous size, use that for the size of this
609 register to avoid making junk tiny ranges. */
610 if (! HARD_REGNO_MODE_OK (i, mode) && last_size != -1)
611 size = last_size;
612
613 if (size != last_size)
614 {
615 ranges[n_ranges].beg = i;
616 ranges[n_ranges].size = last_size = size;
617 ++n_ranges;
618 if (n_ranges >= 5)
619 abort ();
620 }
621 ranges[n_ranges-1].end = i;
622 }
623
624 /* The usual case: fp regs surrounded by general regs. */
625 if (n_ranges == 3 && ranges[0].size == ranges[2].size)
626 {
627 if ((DWARF_FRAME_REGNUM (ranges[1].end)
628 - DWARF_FRAME_REGNUM (ranges[1].beg))
629 != ranges[1].end - ranges[1].beg)
630 abort ();
631 t = fold (build (GE_EXPR, integer_type_node, reg_tree,
632 build_int_2 (DWARF_FRAME_REGNUM (ranges[1].beg), 0)));
633 t2 = fold (build (LE_EXPR, integer_type_node, reg_tree,
634 build_int_2 (DWARF_FRAME_REGNUM (ranges[1].end), 0)));
635 t = fold (build (TRUTH_ANDIF_EXPR, integer_type_node, t, t2));
636 t = fold (build (COND_EXPR, integer_type_node, t,
637 build_int_2 (ranges[1].size, 0),
638 build_int_2 (ranges[0].size, 0)));
639 }
640 else
641 {
|
642 /* Initialize last_end to be larger than any possible
643 DWARF_FRAME_REGNUM. */
644 int last_end = 0x7fffffff; |
645 --n_ranges;
646 t = build_int_2 (ranges[n_ranges].size, 0);
|
637 size = DWARF_FRAME_REGNUM (ranges[n_ranges].beg);
638 for (; n_ranges--; )
|
| 647 do |
648 {
|
640 if ((DWARF_FRAME_REGNUM (ranges[n_ranges].end)
641 - DWARF_FRAME_REGNUM (ranges[n_ranges].beg))
642 != ranges[n_ranges].end - ranges[n_ranges].beg)
|
649 int beg = DWARF_FRAME_REGNUM (ranges[n_ranges].beg);
650 int end = DWARF_FRAME_REGNUM (ranges[n_ranges].end);
651 if (beg < 0)
652 continue;
653 if (end >= last_end) |
654 abort ();
|
644 if (DWARF_FRAME_REGNUM (ranges[n_ranges].beg) >= size)
|
655 last_end = end;
656 if (end - beg != ranges[n_ranges].end - ranges[n_ranges].beg) |
657 abort ();
|
646 size = DWARF_FRAME_REGNUM (ranges[n_ranges].beg);
|
658 t2 = fold (build (LE_EXPR, integer_type_node, reg_tree,
|
648 build_int_2 (DWARF_FRAME_REGNUM
649 (ranges[n_ranges].end), 0)));
|
| 659 build_int_2 (end, 0))); |
660 t = fold (build (COND_EXPR, integer_type_node, t2,
661 build_int_2 (ranges[n_ranges].size, 0), t));
662 }
|
| 663 while (--n_ranges >= 0); |
664 }
665 return expand_expr (t, target, Pmode, 0);
666}
667
668/* Convert a DWARF call frame info. operation to its string name */
669
670static char *
671dwarf_cfi_name (cfi_opc)
672 register unsigned cfi_opc;
673{
674 switch (cfi_opc)
675 {
676 case DW_CFA_advance_loc:
677 return "DW_CFA_advance_loc";
678 case DW_CFA_offset:
679 return "DW_CFA_offset";
680 case DW_CFA_restore:
681 return "DW_CFA_restore";
682 case DW_CFA_nop:
683 return "DW_CFA_nop";
684 case DW_CFA_set_loc:
685 return "DW_CFA_set_loc";
686 case DW_CFA_advance_loc1:
687 return "DW_CFA_advance_loc1";
688 case DW_CFA_advance_loc2:
689 return "DW_CFA_advance_loc2";
690 case DW_CFA_advance_loc4:
691 return "DW_CFA_advance_loc4";
692 case DW_CFA_offset_extended:
693 return "DW_CFA_offset_extended";
694 case DW_CFA_restore_extended:
695 return "DW_CFA_restore_extended";
696 case DW_CFA_undefined:
697 return "DW_CFA_undefined";
698 case DW_CFA_same_value:
699 return "DW_CFA_same_value";
700 case DW_CFA_register:
701 return "DW_CFA_register";
702 case DW_CFA_remember_state:
703 return "DW_CFA_remember_state";
704 case DW_CFA_restore_state:
705 return "DW_CFA_restore_state";
706 case DW_CFA_def_cfa:
707 return "DW_CFA_def_cfa";
708 case DW_CFA_def_cfa_register:
709 return "DW_CFA_def_cfa_register";
710 case DW_CFA_def_cfa_offset:
711 return "DW_CFA_def_cfa_offset";
712
713 /* SGI/MIPS specific */
714 case DW_CFA_MIPS_advance_loc8:
715 return "DW_CFA_MIPS_advance_loc8";
716
717 /* GNU extensions */
718 case DW_CFA_GNU_window_save:
719 return "DW_CFA_GNU_window_save";
720 case DW_CFA_GNU_args_size:
721 return "DW_CFA_GNU_args_size";
722
723 default:
724 return "DW_CFA_<unknown>";
725 }
726}
727
728/* Return a pointer to a newly allocated Call Frame Instruction. */
729
730static inline dw_cfi_ref
731new_cfi ()
732{
733 register dw_cfi_ref cfi = (dw_cfi_ref) xmalloc (sizeof (dw_cfi_node));
734
735 cfi->dw_cfi_next = NULL;
736 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
737 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
738
739 return cfi;
740}
741
742/* Add a Call Frame Instruction to list of instructions. */
743
744static inline void
745add_cfi (list_head, cfi)
746 register dw_cfi_ref *list_head;
747 register dw_cfi_ref cfi;
748{
749 register dw_cfi_ref *p;
750
751 /* Find the end of the chain. */
752 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
753 ;
754
755 *p = cfi;
756}
757
758/* Generate a new label for the CFI info to refer to. */
759
760char *
761dwarf2out_cfi_label ()
762{
763 static char label[20];
764 static unsigned long label_num = 0;
765
766 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", label_num++);
767 ASM_OUTPUT_LABEL (asm_out_file, label);
768
769 return label;
770}
771
772/* Add CFI to the current fde at the PC value indicated by LABEL if specified,
773 or to the CIE if LABEL is NULL. */
774
775static void
776add_fde_cfi (label, cfi)
777 register char *label;
778 register dw_cfi_ref cfi;
779{
780 if (label)
781 {
782 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
783
784 if (*label == 0)
785 label = dwarf2out_cfi_label ();
786
787 if (fde->dw_fde_current_label == NULL
788 || strcmp (label, fde->dw_fde_current_label) != 0)
789 {
790 register dw_cfi_ref xcfi;
791
792 fde->dw_fde_current_label = label = xstrdup (label);
793
794 /* Set the location counter to the new label. */
795 xcfi = new_cfi ();
796 xcfi->dw_cfi_opc = DW_CFA_advance_loc4;
797 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
798 add_cfi (&fde->dw_fde_cfi, xcfi);
799 }
800
801 add_cfi (&fde->dw_fde_cfi, cfi);
802 }
803
804 else
805 add_cfi (&cie_cfi_head, cfi);
806}
807
808/* Subroutine of lookup_cfa. */
809
810static inline void
811lookup_cfa_1 (cfi, regp, offsetp)
812 register dw_cfi_ref cfi;
813 register unsigned long *regp;
814 register long *offsetp;
815{
816 switch (cfi->dw_cfi_opc)
817 {
818 case DW_CFA_def_cfa_offset:
819 *offsetp = cfi->dw_cfi_oprnd1.dw_cfi_offset;
820 break;
821 case DW_CFA_def_cfa_register:
822 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
823 break;
824 case DW_CFA_def_cfa:
825 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
826 *offsetp = cfi->dw_cfi_oprnd2.dw_cfi_offset;
827 break;
828 default:
829 break;
830 }
831}
832
833/* Find the previous value for the CFA. */
834
835static void
836lookup_cfa (regp, offsetp)
837 register unsigned long *regp;
838 register long *offsetp;
839{
840 register dw_cfi_ref cfi;
841
842 *regp = (unsigned long) -1;
843 *offsetp = 0;
844
845 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
846 lookup_cfa_1 (cfi, regp, offsetp);
847
848 if (fde_table_in_use)
849 {
850 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
851 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
852 lookup_cfa_1 (cfi, regp, offsetp);
853 }
854}
855
856/* The current rule for calculating the DWARF2 canonical frame address. */
857static unsigned long cfa_reg;
858static long cfa_offset;
859
860/* The register used for saving registers to the stack, and its offset
861 from the CFA. */
862static unsigned cfa_store_reg;
863static long cfa_store_offset;
864
865/* The running total of the size of arguments pushed onto the stack. */
866static long args_size;
867
868/* The last args_size we actually output. */
869static long old_args_size;
870
871/* Entry point to update the canonical frame address (CFA).
872 LABEL is passed to add_fde_cfi. The value of CFA is now to be
873 calculated from REG+OFFSET. */
874
875void
876dwarf2out_def_cfa (label, reg, offset)
877 register char *label;
878 register unsigned reg;
879 register long offset;
880{
881 register dw_cfi_ref cfi;
882 unsigned long old_reg;
883 long old_offset;
884
885 cfa_reg = reg;
886 cfa_offset = offset;
887 if (cfa_store_reg == reg)
888 cfa_store_offset = offset;
889
890 reg = DWARF_FRAME_REGNUM (reg);
891 lookup_cfa (&old_reg, &old_offset);
892
893 if (reg == old_reg && offset == old_offset)
894 return;
895
896 cfi = new_cfi ();
897
898 if (reg == old_reg)
899 {
900 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
901 cfi->dw_cfi_oprnd1.dw_cfi_offset = offset;
902 }
903
904#ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
905 else if (offset == old_offset && old_reg != (unsigned long) -1)
906 {
907 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
908 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
909 }
910#endif
911
912 else
913 {
914 cfi->dw_cfi_opc = DW_CFA_def_cfa;
915 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
916 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
917 }
918
919 add_fde_cfi (label, cfi);
920}
921
922/* Add the CFI for saving a register. REG is the CFA column number.
923 LABEL is passed to add_fde_cfi.
924 If SREG is -1, the register is saved at OFFSET from the CFA;
925 otherwise it is saved in SREG. */
926
927static void
928reg_save (label, reg, sreg, offset)
929 register char * label;
930 register unsigned reg;
931 register unsigned sreg;
932 register long offset;
933{
934 register dw_cfi_ref cfi = new_cfi ();
935
936 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
937
938 /* The following comparison is correct. -1 is used to indicate that
939 the value isn't a register number. */
940 if (sreg == (unsigned int) -1)
941 {
942 if (reg & ~0x3f)
943 /* The register number won't fit in 6 bits, so we have to use
944 the long form. */
945 cfi->dw_cfi_opc = DW_CFA_offset_extended;
946 else
947 cfi->dw_cfi_opc = DW_CFA_offset;
948
949 offset /= DWARF_CIE_DATA_ALIGNMENT;
950 if (offset < 0)
951 abort ();
952 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
953 }
954 else
955 {
956 cfi->dw_cfi_opc = DW_CFA_register;
957 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
958 }
959
960 add_fde_cfi (label, cfi);
961}
962
963/* Add the CFI for saving a register window. LABEL is passed to reg_save.
964 This CFI tells the unwinder that it needs to restore the window registers
965 from the previous frame's window save area.
966
967 ??? Perhaps we should note in the CIE where windows are saved (instead of
968 assuming 0(cfa)) and what registers are in the window. */
969
970void
971dwarf2out_window_save (label)
972 register char * label;
973{
974 register dw_cfi_ref cfi = new_cfi ();
975 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
976 add_fde_cfi (label, cfi);
977}
978
979/* Add a CFI to update the running total of the size of arguments
980 pushed onto the stack. */
981
982void
983dwarf2out_args_size (label, size)
984 char *label;
985 long size;
986{
987 register dw_cfi_ref cfi;
988
989 if (size == old_args_size)
990 return;
991 old_args_size = size;
992
993 cfi = new_cfi ();
994 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
995 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
996 add_fde_cfi (label, cfi);
997}
998
999/* Entry point for saving a register to the stack. REG is the GCC register
1000 number. LABEL and OFFSET are passed to reg_save. */
1001
1002void
1003dwarf2out_reg_save (label, reg, offset)
1004 register char * label;
1005 register unsigned reg;
1006 register long offset;
1007{
1008 reg_save (label, DWARF_FRAME_REGNUM (reg), -1, offset);
1009}
1010
1011/* Entry point for saving the return address in the stack.
1012 LABEL and OFFSET are passed to reg_save. */
1013
1014void
1015dwarf2out_return_save (label, offset)
1016 register char * label;
1017 register long offset;
1018{
1019 reg_save (label, DWARF_FRAME_RETURN_COLUMN, -1, offset);
1020}
1021
1022/* Entry point for saving the return address in a register.
1023 LABEL and SREG are passed to reg_save. */
1024
1025void
1026dwarf2out_return_reg (label, sreg)
1027 register char * label;
1028 register unsigned sreg;
1029{
1030 reg_save (label, DWARF_FRAME_RETURN_COLUMN, sreg, 0);
1031}
1032
1033/* Record the initial position of the return address. RTL is
1034 INCOMING_RETURN_ADDR_RTX. */
1035
1036static void
1037initial_return_save (rtl)
1038 register rtx rtl;
1039{
|
1029 unsigned reg = -1;
|
| 1040 unsigned int reg = (unsigned int) -1; |
1041 long offset = 0;
1042
1043 switch (GET_CODE (rtl))
1044 {
1045 case REG:
1046 /* RA is in a register. */
1047 reg = reg_number (rtl);
1048 break;
1049 case MEM:
1050 /* RA is on the stack. */
1051 rtl = XEXP (rtl, 0);
1052 switch (GET_CODE (rtl))
1053 {
1054 case REG:
1055 if (REGNO (rtl) != STACK_POINTER_REGNUM)
1056 abort ();
1057 offset = 0;
1058 break;
1059 case PLUS:
1060 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
1061 abort ();
1062 offset = INTVAL (XEXP (rtl, 1));
1063 break;
1064 case MINUS:
1065 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
1066 abort ();
1067 offset = -INTVAL (XEXP (rtl, 1));
1068 break;
1069 default:
1070 abort ();
1071 }
1072 break;
1073 case PLUS:
1074 /* The return address is at some offset from any value we can
1075 actually load. For instance, on the SPARC it is in %i7+8. Just
1076 ignore the offset for now; it doesn't matter for unwinding frames. */
1077 if (GET_CODE (XEXP (rtl, 1)) != CONST_INT)
1078 abort ();
1079 initial_return_save (XEXP (rtl, 0));
1080 return;
1081 default:
1082 abort ();
1083 }
1084
1085 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa_offset);
1086}
1087
1088/* Check INSN to see if it looks like a push or a stack adjustment, and
1089 make a note of it if it does. EH uses this information to find out how
1090 much extra space it needs to pop off the stack. */
1091
1092static void
1093dwarf2out_stack_adjust (insn)
1094 rtx insn;
1095{
1096 long offset;
1097 char *label;
1098
1099 if (! asynchronous_exceptions && GET_CODE (insn) == CALL_INSN)
1100 {
1101 /* Extract the size of the args from the CALL rtx itself. */
1102
1103 insn = PATTERN (insn);
1104 if (GET_CODE (insn) == PARALLEL)
1105 insn = XVECEXP (insn, 0, 0);
1106 if (GET_CODE (insn) == SET)
1107 insn = SET_SRC (insn);
1108 assert (GET_CODE (insn) == CALL);
1109 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1110 return;
1111 }
1112
1113 /* If only calls can throw, and we have a frame pointer,
1114 save up adjustments until we see the CALL_INSN. */
1115 else if (! asynchronous_exceptions
1116 && cfa_reg != STACK_POINTER_REGNUM)
1117 return;
1118
1119 if (GET_CODE (insn) == BARRIER)
1120 {
1121 /* When we see a BARRIER, we know to reset args_size to 0. Usually
1122 the compiler will have already emitted a stack adjustment, but
1123 doesn't bother for calls to noreturn functions. */
1124#ifdef STACK_GROWS_DOWNWARD
1125 offset = -args_size;
1126#else
1127 offset = args_size;
1128#endif
1129 }
1130 else if (GET_CODE (PATTERN (insn)) == SET)
1131 {
1132 rtx src, dest;
1133 enum rtx_code code;
1134
1135 insn = PATTERN (insn);
1136 src = SET_SRC (insn);
1137 dest = SET_DEST (insn);
1138
1139 if (dest == stack_pointer_rtx)
1140 {
1141 /* (set (reg sp) (plus (reg sp) (const_int))) */
1142 code = GET_CODE (src);
1143 if (! (code == PLUS || code == MINUS)
1144 || XEXP (src, 0) != stack_pointer_rtx
1145 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1146 return;
1147
1148 offset = INTVAL (XEXP (src, 1));
1149 }
1150 else if (GET_CODE (dest) == MEM)
1151 {
1152 /* (set (mem (pre_dec (reg sp))) (foo)) */
1153 src = XEXP (dest, 0);
1154 code = GET_CODE (src);
1155
1156 if (! (code == PRE_DEC || code == PRE_INC)
1157 || XEXP (src, 0) != stack_pointer_rtx)
1158 return;
1159
1160 offset = GET_MODE_SIZE (GET_MODE (dest));
1161 }
1162 else
1163 return;
1164
1165 if (code == PLUS || code == PRE_INC)
1166 offset = -offset;
1167 }
1168 else
1169 return;
1170
1171 if (offset == 0)
1172 return;
1173
1174 if (cfa_reg == STACK_POINTER_REGNUM)
1175 cfa_offset += offset;
1176
1177#ifndef STACK_GROWS_DOWNWARD
1178 offset = -offset;
1179#endif
1180 args_size += offset;
1181 if (args_size < 0)
1182 args_size = 0;
1183
1184 label = dwarf2out_cfi_label ();
1185 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1186 dwarf2out_args_size (label, args_size);
1187}
1188
|
1178/* Record call frame debugging information for INSN, which either
|
1189/* A temporary register used in adjusting SP or setting up the store_reg. */
1190static unsigned cfa_temp_reg;
1191
1192/* A temporary value used in adjusting SP or setting up the store_reg. */
1193static long cfa_temp_value;
1194
1195/* Record call frame debugging information for an expression, which either |
1196 sets SP or FP (adjusting how we calculate the frame address) or saves a
|
1180 register to the stack. If INSN is NULL_RTX, initialize our state. */
|
| 1197 register to the stack. */ |
1198
|
1182void
1183dwarf2out_frame_debug (insn)
1184 rtx insn;
|
1199static void
1200dwarf2out_frame_debug_expr (expr, label)
1201 rtx expr;
1202 char *label; |
1203{
|
1186 char *label;
|
1204 rtx src, dest;
1205 long offset;
|
1206
1207 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1208 the PARALLEL independantly. The first element is always processed if
1209 it is a SET. This is for backward compatability. Other elements
1210 are processed only if they are SETs and the RTX_FRAME_RELATED_P
1211 flag is set in them. */ |
1212
|
1190 /* A temporary register used in adjusting SP or setting up the store_reg. */
1191 static unsigned cfa_temp_reg;
1192 static long cfa_temp_value;
|
1213 if (GET_CODE (expr) == PARALLEL)
1214 {
1215 int par_index;
1216 int limit = XVECLEN (expr, 0); |
1217
|
1194 if (insn == NULL_RTX)
1195 {
1196 /* Set up state for generating call frame debug info. */
1197 lookup_cfa (&cfa_reg, &cfa_offset);
1198 if (cfa_reg != DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM))
1199 abort ();
1200 cfa_reg = STACK_POINTER_REGNUM;
1201 cfa_store_reg = cfa_reg;
1202 cfa_store_offset = cfa_offset;
1203 cfa_temp_reg = -1;
1204 cfa_temp_value = 0;
|
1218 for (par_index = 0; par_index < limit; par_index++)
1219 {
1220 rtx x = XVECEXP (expr, 0, par_index);
1221
1222 if (GET_CODE (x) == SET &&
1223 (RTX_FRAME_RELATED_P (x) || par_index == 0))
1224 dwarf2out_frame_debug_expr (x, label);
1225 } |
1226 return;
1227 }
|
1207
1208 if (! RTX_FRAME_RELATED_P (insn))
1209 {
1210 dwarf2out_stack_adjust (insn);
1211 return;
1212 }
1213
1214 label = dwarf2out_cfi_label ();
1215
1216 insn = PATTERN (insn);
1217 /* Assume that in a PARALLEL prologue insn, only the first elt is
1218 significant. Currently this is true. */
1219 if (GET_CODE (insn) == PARALLEL)
1220 insn = XVECEXP (insn, 0, 0);
1221 if (GET_CODE (insn) != SET)
|
1228
1229 if (GET_CODE (expr) != SET) |
1230 abort ();
1231
|
1224 src = SET_SRC (insn);
1225 dest = SET_DEST (insn);
|
1232 src = SET_SRC (expr);
1233 dest = SET_DEST (expr); |
1234
1235 switch (GET_CODE (dest))
1236 {
1237 case REG:
1238 /* Update the CFA rule wrt SP or FP. Make sure src is
|
1231 relative to the current CFA register. */
|
| 1239 relative to the current CFA register. */ |
1240 switch (GET_CODE (src))
|
1233 {
1234 /* Setting FP from SP. */
1235 case REG:
1236 if (cfa_reg != REGNO (src))
1237 abort ();
1238 if (REGNO (dest) != STACK_POINTER_REGNUM
1239 && !(frame_pointer_needed
1240 && REGNO (dest) == HARD_FRAME_POINTER_REGNUM))
1241 abort ();
1242 cfa_reg = REGNO (dest);
1243 break;
|
1241 {
1242 /* Setting FP from SP. */
1243 case REG:
1244 if (cfa_reg != (unsigned) REGNO (src))
1245 abort ();
1246 if (REGNO (dest) != STACK_POINTER_REGNUM
1247 && !(frame_pointer_needed
1248 && REGNO (dest) == HARD_FRAME_POINTER_REGNUM))
1249 abort ();
1250 cfa_reg = REGNO (dest);
1251 break; |
1252
|
1245 case PLUS:
1246 case MINUS:
1247 if (dest == stack_pointer_rtx)
1248 {
1249 /* Adjusting SP. */
1250 switch (GET_CODE (XEXP (src, 1)))
1251 {
1252 case CONST_INT:
1253 offset = INTVAL (XEXP (src, 1));
1254 break;
1255 case REG:
1256 if (REGNO (XEXP (src, 1)) != cfa_temp_reg)
1257 abort ();
1258 offset = cfa_temp_value;
1259 break;
1260 default:
1261 abort ();
1262 }
|
1253 case PLUS:
1254 case MINUS:
1255 if (dest == stack_pointer_rtx)
1256 {
1257 /* Adjusting SP. */
1258 switch (GET_CODE (XEXP (src, 1)))
1259 {
1260 case CONST_INT:
1261 offset = INTVAL (XEXP (src, 1));
1262 break;
1263 case REG:
1264 if ((unsigned) REGNO (XEXP (src, 1)) != cfa_temp_reg)
1265 abort ();
1266 offset = cfa_temp_value;
1267 break;
1268 default:
1269 abort ();
1270 } |
1271
|
1264 if (XEXP (src, 0) == hard_frame_pointer_rtx)
1265 {
1266 /* Restoring SP from FP in the epilogue. */
1267 if (cfa_reg != HARD_FRAME_POINTER_REGNUM)
1268 abort ();
1269 cfa_reg = STACK_POINTER_REGNUM;
1270 }
1271 else if (XEXP (src, 0) != stack_pointer_rtx)
1272 abort ();
|
1272 if (XEXP (src, 0) == hard_frame_pointer_rtx)
1273 {
1274 /* Restoring SP from FP in the epilogue. */
1275 if (cfa_reg != (unsigned) HARD_FRAME_POINTER_REGNUM)
1276 abort ();
1277 cfa_reg = STACK_POINTER_REGNUM;
1278 }
1279 else if (XEXP (src, 0) != stack_pointer_rtx)
1280 abort (); |
1281
|
1274 if (GET_CODE (src) == PLUS)
1275 offset = -offset;
1276 if (cfa_reg == STACK_POINTER_REGNUM)
1277 cfa_offset += offset;
1278 if (cfa_store_reg == STACK_POINTER_REGNUM)
1279 cfa_store_offset += offset;
1280 }
|
1282 if (GET_CODE (src) == PLUS)
1283 offset = -offset;
1284 if (cfa_reg == STACK_POINTER_REGNUM)
1285 cfa_offset += offset;
1286 if (cfa_store_reg == STACK_POINTER_REGNUM)
1287 cfa_store_offset += offset;
1288 } |
1289 else if (dest == hard_frame_pointer_rtx)
1290 {
|
1283 /* Either setting the FP from an offset of the SP,
1284 or adjusting the FP */
1285 if (! frame_pointer_needed
1286 || REGNO (dest) != HARD_FRAME_POINTER_REGNUM)
1287 abort ();
|
1291 /* Either setting the FP from an offset of the SP,
1292 or adjusting the FP */
1293 if (! frame_pointer_needed
1294 || REGNO (dest) != HARD_FRAME_POINTER_REGNUM)
1295 abort (); |
1296
|
1289 if (XEXP (src, 0) == stack_pointer_rtx
1290 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1291 {
1292 if (cfa_reg != STACK_POINTER_REGNUM)
1293 abort ();
1294 offset = INTVAL (XEXP (src, 1));
1295 if (GET_CODE (src) == PLUS)
1296 offset = -offset;
1297 cfa_offset += offset;
1298 cfa_reg = HARD_FRAME_POINTER_REGNUM;
1299 }
1300 else if (XEXP (src, 0) == hard_frame_pointer_rtx
1301 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1302 {
1303 if (cfa_reg != HARD_FRAME_POINTER_REGNUM)
1304 abort ();
1305 offset = INTVAL (XEXP (src, 1));
1306 if (GET_CODE (src) == PLUS)
1307 offset = -offset;
1308 cfa_offset += offset;
1309 }
|
1297 if (XEXP (src, 0) == stack_pointer_rtx
1298 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1299 {
1300 if (cfa_reg != STACK_POINTER_REGNUM)
1301 abort ();
1302 offset = INTVAL (XEXP (src, 1));
1303 if (GET_CODE (src) == PLUS)
1304 offset = -offset;
1305 cfa_offset += offset;
1306 cfa_reg = HARD_FRAME_POINTER_REGNUM;
1307 }
1308 else if (XEXP (src, 0) == hard_frame_pointer_rtx
1309 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1310 {
1311 if (cfa_reg != (unsigned) HARD_FRAME_POINTER_REGNUM)
1312 abort ();
1313 offset = INTVAL (XEXP (src, 1));
1314 if (GET_CODE (src) == PLUS)
1315 offset = -offset;
1316 cfa_offset += offset;
1317 } |
1318
|
1311 else
1312 abort();
|
1319 else
1320 abort(); |
1321 }
|
1314 else
1315 {
1316 if (GET_CODE (src) != PLUS
1317 || XEXP (src, 1) != stack_pointer_rtx)
1318 abort ();
1319 if (GET_CODE (XEXP (src, 0)) != REG
1320 || REGNO (XEXP (src, 0)) != cfa_temp_reg)
1321 abort ();
1322 if (cfa_reg != STACK_POINTER_REGNUM)
1323 abort ();
1324 cfa_store_reg = REGNO (dest);
1325 cfa_store_offset = cfa_offset - cfa_temp_value;
1326 }
1327 break;
|
1322 else
1323 {
1324 if (GET_CODE (src) != PLUS
1325 || XEXP (src, 1) != stack_pointer_rtx)
1326 abort ();
1327 if (GET_CODE (XEXP (src, 0)) != REG
1328 || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp_reg)
1329 abort ();
1330 if (cfa_reg != STACK_POINTER_REGNUM)
1331 abort ();
1332 cfa_store_reg = REGNO (dest);
1333 cfa_store_offset = cfa_offset - cfa_temp_value;
1334 }
1335 break; |
1336
|
1329 case CONST_INT:
1330 cfa_temp_reg = REGNO (dest);
1331 cfa_temp_value = INTVAL (src);
1332 break;
|
1337 case CONST_INT:
1338 cfa_temp_reg = REGNO (dest);
1339 cfa_temp_value = INTVAL (src);
1340 break; |
1341
|
1334 case IOR:
1335 if (GET_CODE (XEXP (src, 0)) != REG
1336 || REGNO (XEXP (src, 0)) != cfa_temp_reg
1337 || REGNO (dest) != cfa_temp_reg
1338 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1339 abort ();
1340 cfa_temp_value |= INTVAL (XEXP (src, 1));
1341 break;
|
1342 case IOR:
1343 if (GET_CODE (XEXP (src, 0)) != REG
1344 || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp_reg
1345 || (unsigned) REGNO (dest) != cfa_temp_reg
1346 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1347 abort ();
1348 cfa_temp_value |= INTVAL (XEXP (src, 1));
1349 break; |
1350
|
1343 default:
1344 abort ();
1345 }
|
1351 default:
1352 abort ();
1353 } |
1354 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
|
1347 break;
|
| 1355 break; |
1356
|
1349 case MEM:
1350 /* Saving a register to the stack. Make sure dest is relative to the
1351 CFA register. */
1352 if (GET_CODE (src) != REG)
1353 abort ();
1354 switch (GET_CODE (XEXP (dest, 0)))
1355 {
1356 /* With a push. */
1357 case PRE_INC:
1358 case PRE_DEC:
1359 offset = GET_MODE_SIZE (GET_MODE (dest));
1360 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
1361 offset = -offset;
|
1357 case MEM:
1358 /* Saving a register to the stack. Make sure dest is relative to the
1359 CFA register. */
1360 if (GET_CODE (src) != REG)
1361 abort ();
1362 switch (GET_CODE (XEXP (dest, 0)))
1363 {
1364 /* With a push. */
1365 case PRE_INC:
1366 case PRE_DEC:
1367 offset = GET_MODE_SIZE (GET_MODE (dest));
1368 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
1369 offset = -offset; |
1370
|
1363 if (REGNO (XEXP (XEXP (dest, 0), 0)) != STACK_POINTER_REGNUM
1364 || cfa_store_reg != STACK_POINTER_REGNUM)
1365 abort ();
1366 cfa_store_offset += offset;
1367 if (cfa_reg == STACK_POINTER_REGNUM)
1368 cfa_offset = cfa_store_offset;
|
1371 if (REGNO (XEXP (XEXP (dest, 0), 0)) != STACK_POINTER_REGNUM
1372 || cfa_store_reg != STACK_POINTER_REGNUM)
1373 abort ();
1374 cfa_store_offset += offset;
1375 if (cfa_reg == STACK_POINTER_REGNUM)
1376 cfa_offset = cfa_store_offset; |
1377
|
1370 offset = -cfa_store_offset;
1371 break;
|
1378 offset = -cfa_store_offset;
1379 break; |
1380
|
1373 /* With an offset. */
1374 case PLUS:
1375 case MINUS:
1376 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1377 if (GET_CODE (src) == MINUS)
1378 offset = -offset;
|
1381 /* With an offset. */
1382 case PLUS:
1383 case MINUS:
1384 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1385 if (GET_CODE (XEXP (dest, 0)) == MINUS)
1386 offset = -offset; |
1387
|
1380 if (cfa_store_reg != REGNO (XEXP (XEXP (dest, 0), 0)))
1381 abort ();
1382 offset -= cfa_store_offset;
1383 break;
|
1388 if (cfa_store_reg != (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)))
1389 abort ();
1390 offset -= cfa_store_offset;
1391 break; |
1392
|
1385 default:
1386 abort ();
1387 }
1388 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1389 dwarf2out_reg_save (label, REGNO (src), offset);
1390 break;
|
1393 /* Without an offset. */
1394 case REG:
1395 if (cfa_store_reg != (unsigned) REGNO (XEXP (dest, 0)))
1396 abort();
1397 offset = -cfa_store_offset;
1398 break; |
1399
|
1392 default:
1393 abort ();
|
1400 default:
1401 abort ();
1402 }
1403 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1404 dwarf2out_reg_save (label, REGNO (src), offset);
1405 break;
1406
1407 default:
1408 abort ();
1409 }
1410}
1411
1412
1413/* Record call frame debugging information for INSN, which either
1414 sets SP or FP (adjusting how we calculate the frame address) or saves a
1415 register to the stack. If INSN is NULL_RTX, initialize our state. */
1416
1417void
1418dwarf2out_frame_debug (insn)
1419 rtx insn;
1420{
1421 char *label;
1422 rtx src;
1423
1424 if (insn == NULL_RTX)
1425 {
1426 /* Set up state for generating call frame debug info. */
1427 lookup_cfa (&cfa_reg, &cfa_offset);
1428 if (cfa_reg != DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM))
1429 abort ();
1430 cfa_reg = STACK_POINTER_REGNUM;
1431 cfa_store_reg = cfa_reg;
1432 cfa_store_offset = cfa_offset;
1433 cfa_temp_reg = -1;
1434 cfa_temp_value = 0;
1435 return; |
1436 }
|
1437
1438 if (! RTX_FRAME_RELATED_P (insn))
1439 {
1440 dwarf2out_stack_adjust (insn);
1441 return;
1442 }
1443
1444 label = dwarf2out_cfi_label ();
1445
1446 src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1447 if (src)
1448 insn = XEXP (src, 0);
1449 else
1450 insn = PATTERN (insn);
1451
1452 dwarf2out_frame_debug_expr (insn, label); |
1453}
1454
1455/* Return the size of an unsigned LEB128 quantity. */
1456
1457static inline unsigned long
1458size_of_uleb128 (value)
1459 register unsigned long value;
1460{
1461 register unsigned long size = 0;
1462 register unsigned byte;
1463
1464 do
1465 {
1466 byte = (value & 0x7f);
1467 value >>= 7;
1468 size += 1;
1469 }
1470 while (value != 0);
1471
1472 return size;
1473}
1474
1475/* Return the size of a signed LEB128 quantity. */
1476
1477static inline unsigned long
1478size_of_sleb128 (value)
1479 register long value;
1480{
1481 register unsigned long size = 0;
1482 register unsigned byte;
1483
1484 do
1485 {
1486 byte = (value & 0x7f);
1487 value >>= 7;
1488 size += 1;
1489 }
1490 while (!(((value == 0) && ((byte & 0x40) == 0))
1491 || ((value == -1) && ((byte & 0x40) != 0))));
1492
1493 return size;
1494}
1495
1496/* Output an unsigned LEB128 quantity. */
1497
1498static void
1499output_uleb128 (value)
1500 register unsigned long value;
1501{
1502 unsigned long save_value = value;
1503
1504 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
1505 do
1506 {
1507 register unsigned byte = (value & 0x7f);
1508 value >>= 7;
1509 if (value != 0)
1510 /* More bytes to follow. */
1511 byte |= 0x80;
1512
1513 fprintf (asm_out_file, "0x%x", byte);
1514 if (value != 0)
1515 fprintf (asm_out_file, ",");
1516 }
1517 while (value != 0);
1518
1519 if (flag_debug_asm)
1520 fprintf (asm_out_file, "\t%s ULEB128 0x%lx", ASM_COMMENT_START, save_value);
1521}
1522
1523/* Output an signed LEB128 quantity. */
1524
1525static void
1526output_sleb128 (value)
1527 register long value;
1528{
1529 register int more;
1530 register unsigned byte;
1531 long save_value = value;
1532
1533 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
1534 do
1535 {
1536 byte = (value & 0x7f);
1537 /* arithmetic shift */
1538 value >>= 7;
1539 more = !((((value == 0) && ((byte & 0x40) == 0))
1540 || ((value == -1) && ((byte & 0x40) != 0))));
1541 if (more)
1542 byte |= 0x80;
1543
1544 fprintf (asm_out_file, "0x%x", byte);
1545 if (more)
1546 fprintf (asm_out_file, ",");
1547 }
1548
1549 while (more);
1550 if (flag_debug_asm)
1551 fprintf (asm_out_file, "\t%s SLEB128 %ld", ASM_COMMENT_START, save_value);
1552}
1553
1554/* Output a Call Frame Information opcode and its operand(s). */
1555
1556static void
1557output_cfi (cfi, fde)
1558 register dw_cfi_ref cfi;
1559 register dw_fde_ref fde;
1560{
1561 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
1562 {
1563 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1564 cfi->dw_cfi_opc
1565 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f));
1566 if (flag_debug_asm)
1567 fprintf (asm_out_file, "\t%s DW_CFA_advance_loc 0x%lx",
1568 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
1569 fputc ('\n', asm_out_file);
1570 }
1571
1572 else if (cfi->dw_cfi_opc == DW_CFA_offset)
1573 {
1574 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1575 cfi->dw_cfi_opc
1576 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
1577 if (flag_debug_asm)
1578 fprintf (asm_out_file, "\t%s DW_CFA_offset, column 0x%lx",
1579 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1580
1581 fputc ('\n', asm_out_file);
1582 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset);
1583 fputc ('\n', asm_out_file);
1584 }
1585 else if (cfi->dw_cfi_opc == DW_CFA_restore)
1586 {
1587 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1588 cfi->dw_cfi_opc
1589 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
1590 if (flag_debug_asm)
1591 fprintf (asm_out_file, "\t%s DW_CFA_restore, column 0x%lx",
1592 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1593
1594 fputc ('\n', asm_out_file);
1595 }
1596 else
1597 {
1598 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, cfi->dw_cfi_opc);
1599 if (flag_debug_asm)
1600 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START,
1601 dwarf_cfi_name (cfi->dw_cfi_opc));
1602
1603 fputc ('\n', asm_out_file);
1604 switch (cfi->dw_cfi_opc)
1605 {
1606 case DW_CFA_set_loc:
1607 ASM_OUTPUT_DWARF_ADDR (asm_out_file, cfi->dw_cfi_oprnd1.dw_cfi_addr);
1608 fputc ('\n', asm_out_file);
1609 break;
1610 case DW_CFA_advance_loc1:
1611 ASM_OUTPUT_DWARF_DELTA1 (asm_out_file,
1612 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1613 fde->dw_fde_current_label);
1614 fputc ('\n', asm_out_file);
1615 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1616 break;
1617 case DW_CFA_advance_loc2:
1618 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file,
1619 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1620 fde->dw_fde_current_label);
1621 fputc ('\n', asm_out_file);
1622 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1623 break;
1624 case DW_CFA_advance_loc4:
1625 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file,
1626 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1627 fde->dw_fde_current_label);
1628 fputc ('\n', asm_out_file);
1629 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1630 break;
1631#ifdef MIPS_DEBUGGING_INFO
1632 case DW_CFA_MIPS_advance_loc8:
1633 /* TODO: not currently implemented. */
1634 abort ();
1635 break;
1636#endif
1637 case DW_CFA_offset_extended:
1638 case DW_CFA_def_cfa:
1639 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1640 fputc ('\n', asm_out_file);
1641 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset);
1642 fputc ('\n', asm_out_file);
1643 break;
1644 case DW_CFA_restore_extended:
1645 case DW_CFA_undefined:
1646 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1647 fputc ('\n', asm_out_file);
1648 break;
1649 case DW_CFA_same_value:
1650 case DW_CFA_def_cfa_register:
1651 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1652 fputc ('\n', asm_out_file);
1653 break;
1654 case DW_CFA_register:
1655 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1656 fputc ('\n', asm_out_file);
1657 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_reg_num);
1658 fputc ('\n', asm_out_file);
1659 break;
1660 case DW_CFA_def_cfa_offset:
1661 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset);
1662 fputc ('\n', asm_out_file);
1663 break;
1664 case DW_CFA_GNU_window_save:
1665 break;
1666 case DW_CFA_GNU_args_size:
1667 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset);
1668 fputc ('\n', asm_out_file);
1669 break;
1670 default:
1671 break;
1672 }
1673 }
1674}
1675
1676#if !defined (EH_FRAME_SECTION)
1677#if defined (EH_FRAME_SECTION_ASM_OP)
1678#define EH_FRAME_SECTION() eh_frame_section();
1679#else
1680#if defined (ASM_OUTPUT_SECTION_NAME)
1681#define EH_FRAME_SECTION() \
1682 do { \
1683 named_section (NULL_TREE, ".eh_frame", 0); \
1684 } while (0)
1685#endif
1686#endif
1687#endif
1688
1689/* If we aren't using crtstuff to run ctors, don't use it for EH. */
1690#if !defined (HAS_INIT_SECTION) && !defined (INIT_SECTION_ASM_OP)
1691#undef EH_FRAME_SECTION
1692#endif
1693
1694/* Output the call frame information used to used to record information
1695 that relates to calculating the frame pointer, and records the
1696 location of saved registers. */
1697
1698static void
1699output_call_frame_info (for_eh)
1700 int for_eh;
1701{
1702 register unsigned long i;
1703 register dw_fde_ref fde;
1704 register dw_cfi_ref cfi;
1705 char l1[20], l2[20];
1706#ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1707 char ld[20];
1708#endif
1709
1710 /* Do we want to include a pointer to the exception table? */
1711 int eh_ptr = for_eh && exception_table_p ();
1712
1713 fputc ('\n', asm_out_file);
1714
1715 /* We're going to be generating comments, so turn on app. */
1716 if (flag_debug_asm)
1717 app_enable ();
1718
1719 if (for_eh)
1720 {
1721#ifdef EH_FRAME_SECTION
1722 EH_FRAME_SECTION ();
1723#else
1724 tree label = get_file_function_name ('F');
1725
|
1668 data_section ();
|
| 1726 force_data_section (); |
1727 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1728 ASM_GLOBALIZE_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
1729 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
1730#endif
1731 assemble_label ("__FRAME_BEGIN__");
1732 }
1733 else
1734 ASM_OUTPUT_SECTION (asm_out_file, FRAME_SECTION);
1735
1736 /* Output the CIE. */
1737 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
1738 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
1739#ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1740 ASM_GENERATE_INTERNAL_LABEL (ld, CIE_LENGTH_LABEL, for_eh);
1741 if (for_eh)
1742 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld);
1743 else
1744 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld);
1745#else
1746 if (for_eh)
1747 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1);
1748 else
1749 ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1);
1750#endif
1751 if (flag_debug_asm)
1752 fprintf (asm_out_file, "\t%s Length of Common Information Entry",
1753 ASM_COMMENT_START);
1754
1755 fputc ('\n', asm_out_file);
1756 ASM_OUTPUT_LABEL (asm_out_file, l1);
1757
1758 if (for_eh)
1759 /* Now that the CIE pointer is PC-relative for EH,
1760 use 0 to identify the CIE. */
1761 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
1762 else
1763 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID);
1764
1765 if (flag_debug_asm)
1766 fprintf (asm_out_file, "\t%s CIE Identifier Tag", ASM_COMMENT_START);
1767
1768 fputc ('\n', asm_out_file);
1769 if (! for_eh && DWARF_OFFSET_SIZE == 8)
1770 {
1771 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID);
1772 fputc ('\n', asm_out_file);
1773 }
1774
1775 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_CIE_VERSION);
1776 if (flag_debug_asm)
1777 fprintf (asm_out_file, "\t%s CIE Version", ASM_COMMENT_START);
1778
1779 fputc ('\n', asm_out_file);
1780 if (eh_ptr)
1781 {
1782 /* The CIE contains a pointer to the exception region info for the
1783 frame. Make the augmentation string three bytes (including the
1784 trailing null) so the pointer is 4-byte aligned. The Solaris ld
1785 can't handle unaligned relocs. */
1786 if (flag_debug_asm)
1787 {
1788 ASM_OUTPUT_DWARF_STRING (asm_out_file, "eh");
1789 fprintf (asm_out_file, "\t%s CIE Augmentation", ASM_COMMENT_START);
1790 }
1791 else
1792 {
1793 ASM_OUTPUT_ASCII (asm_out_file, "eh", 3);
1794 }
1795 fputc ('\n', asm_out_file);
1796
1797 ASM_OUTPUT_DWARF_ADDR (asm_out_file, "__EXCEPTION_TABLE__");
1798 if (flag_debug_asm)
1799 fprintf (asm_out_file, "\t%s pointer to exception region info",
1800 ASM_COMMENT_START);
1801 }
1802 else
1803 {
1804 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
1805 if (flag_debug_asm)
1806 fprintf (asm_out_file, "\t%s CIE Augmentation (none)",
1807 ASM_COMMENT_START);
1808 }
1809
1810 fputc ('\n', asm_out_file);
1811 output_uleb128 (1);
1812 if (flag_debug_asm)
1813 fprintf (asm_out_file, " (CIE Code Alignment Factor)");
1814
1815 fputc ('\n', asm_out_file);
1816 output_sleb128 (DWARF_CIE_DATA_ALIGNMENT);
1817 if (flag_debug_asm)
1818 fprintf (asm_out_file, " (CIE Data Alignment Factor)");
1819
1820 fputc ('\n', asm_out_file);
1821 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_FRAME_RETURN_COLUMN);
1822 if (flag_debug_asm)
1823 fprintf (asm_out_file, "\t%s CIE RA Column", ASM_COMMENT_START);
1824
1825 fputc ('\n', asm_out_file);
1826
1827 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
1828 output_cfi (cfi, NULL);
1829
1830 /* Pad the CIE out to an address sized boundary. */
1831 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1832 ASM_OUTPUT_LABEL (asm_out_file, l2);
1833#ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1834 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file, ld, l2, l1);
1835 if (flag_debug_asm)
1836 fprintf (asm_out_file, "\t%s CIE Length Symbol", ASM_COMMENT_START);
1837 fputc ('\n', asm_out_file);
1838#endif
1839
1840 /* Loop through all of the FDE's. */
1841 for (i = 0; i < fde_table_in_use; ++i)
1842 {
1843 fde = &fde_table[i];
1844
1845 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i*2);
1846 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i*2);
1847#ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1848 ASM_GENERATE_INTERNAL_LABEL (ld, FDE_LENGTH_LABEL, for_eh + i*2);
1849 if (for_eh)
1850 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld);
1851 else
1852 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld);
1853#else
1854 if (for_eh)
1855 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1);
1856 else
1857 ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1);
1858#endif
1859 if (flag_debug_asm)
1860 fprintf (asm_out_file, "\t%s FDE Length", ASM_COMMENT_START);
1861 fputc ('\n', asm_out_file);
1862 ASM_OUTPUT_LABEL (asm_out_file, l1);
1863
|
1864 /* ??? This always emits a 4 byte offset when for_eh is true, but it
1865 emits a target dependent sized offset when for_eh is not true.
1866 This inconsistency may confuse gdb. The only case where we need a
1867 non-4 byte offset is for the Irix6 N64 ABI, so we may lose SGI
1868 compatibility if we emit a 4 byte offset. We need a 4 byte offset
1869 though in order to be compatible with the dwarf_fde struct in frame.c.
1870 If the for_eh case is changed, then the struct in frame.c has
1871 to be adjusted appropriately. */ |
1872 if (for_eh)
|
1807 ASM_OUTPUT_DWARF_DELTA (asm_out_file, l1, "__FRAME_BEGIN__");
|
| 1873 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l1, "__FRAME_BEGIN__"); |
1874 else
1875 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (FRAME_SECTION));
1876 if (flag_debug_asm)
1877 fprintf (asm_out_file, "\t%s FDE CIE offset", ASM_COMMENT_START);
1878
1879 fputc ('\n', asm_out_file);
1880 ASM_OUTPUT_DWARF_ADDR (asm_out_file, fde->dw_fde_begin);
1881 if (flag_debug_asm)
1882 fprintf (asm_out_file, "\t%s FDE initial location", ASM_COMMENT_START);
1883
1884 fputc ('\n', asm_out_file);
1885 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file,
1886 fde->dw_fde_end, fde->dw_fde_begin);
1887 if (flag_debug_asm)
1888 fprintf (asm_out_file, "\t%s FDE address range", ASM_COMMENT_START);
1889
1890 fputc ('\n', asm_out_file);
1891
1892 /* Loop through the Call Frame Instructions associated with
1893 this FDE. */
1894 fde->dw_fde_current_label = fde->dw_fde_begin;
1895 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
1896 output_cfi (cfi, fde);
1897
1898 /* Pad the FDE out to an address sized boundary. */
1899 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1900 ASM_OUTPUT_LABEL (asm_out_file, l2);
1901#ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1902 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file, ld, l2, l1);
1903 if (flag_debug_asm)
1904 fprintf (asm_out_file, "\t%s FDE Length Symbol", ASM_COMMENT_START);
1905 fputc ('\n', asm_out_file);
1906#endif
1907 }
1908#ifndef EH_FRAME_SECTION
1909 if (for_eh)
1910 {
1911 /* Emit terminating zero for table. */
1912 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
1913 fputc ('\n', asm_out_file);
1914 }
1915#endif
1916#ifdef MIPS_DEBUGGING_INFO
1917 /* Work around Irix 6 assembler bug whereby labels at the end of a section
1918 get a value of 0. Putting .align 0 after the label fixes it. */
1919 ASM_OUTPUT_ALIGN (asm_out_file, 0);
1920#endif
1921
1922 /* Turn off app to make assembly quicker. */
1923 if (flag_debug_asm)
1924 app_disable ();
1925}
1926
1927/* Output a marker (i.e. a label) for the beginning of a function, before
1928 the prologue. */
1929
1930void
1931dwarf2out_begin_prologue ()
1932{
1933 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1934 register dw_fde_ref fde;
1935
1936 ++current_funcdef_number;
1937
1938 function_section (current_function_decl);
1939 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
1940 current_funcdef_number);
1941 ASM_OUTPUT_LABEL (asm_out_file, label);
1942
1943 /* Expand the fde table if necessary. */
1944 if (fde_table_in_use == fde_table_allocated)
1945 {
1946 fde_table_allocated += FDE_TABLE_INCREMENT;
1947 fde_table
1948 = (dw_fde_ref) xrealloc (fde_table,
1949 fde_table_allocated * sizeof (dw_fde_node));
1950 }
1951
1952 /* Record the FDE associated with this function. */
1953 current_funcdef_fde = fde_table_in_use;
1954
1955 /* Add the new FDE at the end of the fde_table. */
1956 fde = &fde_table[fde_table_in_use++];
1957 fde->dw_fde_begin = xstrdup (label);
1958 fde->dw_fde_current_label = NULL;
1959 fde->dw_fde_end = NULL;
1960 fde->dw_fde_cfi = NULL;
1961
1962 args_size = old_args_size = 0;
1963}
1964
1965/* Output a marker (i.e. a label) for the absolute end of the generated code
1966 for a function definition. This gets called *after* the epilogue code has
1967 been generated. */
1968
1969void
1970dwarf2out_end_epilogue ()
1971{
1972 dw_fde_ref fde;
1973 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1974
1975 /* Output a label to mark the endpoint of the code generated for this
1976 function. */
1977 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL, current_funcdef_number);
1978 ASM_OUTPUT_LABEL (asm_out_file, label);
1979 fde = &fde_table[fde_table_in_use - 1];
1980 fde->dw_fde_end = xstrdup (label);
1981}
1982
1983void
1984dwarf2out_frame_init ()
1985{
1986 /* Allocate the initial hunk of the fde_table. */
1987 fde_table
1988 = (dw_fde_ref) xmalloc (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
1989 bzero ((char *) fde_table, FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
1990 fde_table_allocated = FDE_TABLE_INCREMENT;
1991 fde_table_in_use = 0;
1992
1993 /* Generate the CFA instructions common to all FDE's. Do it now for the
1994 sake of lookup_cfa. */
1995
1996#ifdef DWARF2_UNWIND_INFO
1997 /* On entry, the Canonical Frame Address is at SP. */
1998 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
1999 initial_return_save (INCOMING_RETURN_ADDR_RTX);
2000#endif
2001}
2002
2003void
2004dwarf2out_frame_finish ()
2005{
2006 /* Output call frame information. */
2007#ifdef MIPS_DEBUGGING_INFO
2008 if (write_symbols == DWARF2_DEBUG)
2009 output_call_frame_info (0);
2010 if (flag_exceptions && ! exceptions_via_longjmp)
2011 output_call_frame_info (1);
2012#else
2013 if (write_symbols == DWARF2_DEBUG
2014 || (flag_exceptions && ! exceptions_via_longjmp))
2015 output_call_frame_info (1);
2016#endif
2017}
2018
2019#endif /* .debug_frame support */
2020
2021/* And now, the support for symbolic debugging information. */
2022#ifdef DWARF2_DEBUGGING_INFO
2023
2024extern char *getpwd PROTO((void));
2025
2026/* NOTE: In the comments in this file, many references are made to
2027 "Debugging Information Entries". This term is abbreviated as `DIE'
2028 throughout the remainder of this file. */
2029
2030/* An internal representation of the DWARF output is built, and then
2031 walked to generate the DWARF debugging info. The walk of the internal
2032 representation is done after the entire program has been compiled.
2033 The types below are used to describe the internal representation. */
2034
2035/* Each DIE may have a series of attribute/value pairs. Values
2036 can take on several forms. The forms that are used in this
2037 implementation are listed below. */
2038
2039typedef enum
2040{
2041 dw_val_class_addr,
2042 dw_val_class_loc,
2043 dw_val_class_const,
2044 dw_val_class_unsigned_const,
2045 dw_val_class_long_long,
2046 dw_val_class_float,
2047 dw_val_class_flag,
2048 dw_val_class_die_ref,
2049 dw_val_class_fde_ref,
2050 dw_val_class_lbl_id,
|
1985 dw_val_class_section_offset,
|
| 2051 dw_val_class_lbl_offset, |
2052 dw_val_class_str
2053}
2054dw_val_class;
2055
2056/* Various DIE's use offsets relative to the beginning of the
2057 .debug_info section to refer to each other. */
2058
2059typedef long int dw_offset;
2060
2061/* Define typedefs here to avoid circular dependencies. */
2062
2063typedef struct die_struct *dw_die_ref;
2064typedef struct dw_attr_struct *dw_attr_ref;
2065typedef struct dw_val_struct *dw_val_ref;
2066typedef struct dw_line_info_struct *dw_line_info_ref;
2067typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
2068typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
2069typedef struct pubname_struct *pubname_ref;
2070typedef dw_die_ref *arange_ref;
2071
2072/* Describe a double word constant value. */
2073
2074typedef struct dw_long_long_struct
2075{
2076 unsigned long hi;
2077 unsigned long low;
2078}
2079dw_long_long_const;
2080
2081/* Describe a floating point constant value. */
2082
2083typedef struct dw_fp_struct
2084{
2085 long *array;
2086 unsigned length;
2087}
2088dw_float_const;
2089
2090/* Each entry in the line_info_table maintains the file and
2091 line number associated with the label generated for that
2092 entry. The label gives the PC value associated with
2093 the line number entry. */
2094
2095typedef struct dw_line_info_struct
2096{
2097 unsigned long dw_file_num;
2098 unsigned long dw_line_num;
2099}
2100dw_line_info_entry;
2101
2102/* Line information for functions in separate sections; each one gets its
2103 own sequence. */
2104typedef struct dw_separate_line_info_struct
2105{
2106 unsigned long dw_file_num;
2107 unsigned long dw_line_num;
2108 unsigned long function;
2109}
2110dw_separate_line_info_entry;
2111
2112/* The dw_val_node describes an attribute's value, as it is
2113 represented internally. */
2114
2115typedef struct dw_val_struct
2116{
2117 dw_val_class val_class;
2118 union
2119 {
2120 char *val_addr;
2121 dw_loc_descr_ref val_loc;
2122 long int val_int;
2123 long unsigned val_unsigned;
2124 dw_long_long_const val_long_long;
2125 dw_float_const val_float;
2126 dw_die_ref val_die_ref;
2127 unsigned val_fde_index;
2128 char *val_str;
2129 char *val_lbl_id;
|
2064 char *val_section;
|
2130 unsigned char val_flag;
2131 }
2132 v;
2133}
2134dw_val_node;
2135
2136/* Locations in memory are described using a sequence of stack machine
2137 operations. */
2138
2139typedef struct dw_loc_descr_struct
2140{
2141 dw_loc_descr_ref dw_loc_next;
2142 enum dwarf_location_atom dw_loc_opc;
2143 dw_val_node dw_loc_oprnd1;
2144 dw_val_node dw_loc_oprnd2;
2145}
2146dw_loc_descr_node;
2147
2148/* Each DIE attribute has a field specifying the attribute kind,
2149 a link to the next attribute in the chain, and an attribute value.
2150 Attributes are typically linked below the DIE they modify. */
2151
2152typedef struct dw_attr_struct
2153{
2154 enum dwarf_attribute dw_attr;
2155 dw_attr_ref dw_attr_next;
2156 dw_val_node dw_attr_val;
2157}
2158dw_attr_node;
2159
2160/* The Debugging Information Entry (DIE) structure */
2161
2162typedef struct die_struct
2163{
2164 enum dwarf_tag die_tag;
2165 dw_attr_ref die_attr;
2166 dw_attr_ref die_attr_last;
2167 dw_die_ref die_parent;
2168 dw_die_ref die_child;
2169 dw_die_ref die_child_last;
2170 dw_die_ref die_sib;
2171 dw_offset die_offset;
2172 unsigned long die_abbrev;
2173}
2174die_node;
2175
2176/* The pubname structure */
2177
2178typedef struct pubname_struct
2179{
2180 dw_die_ref die;
2181 char * name;
2182}
2183pubname_entry;
2184
2185/* The limbo die list structure. */
2186typedef struct limbo_die_struct
2187{
2188 dw_die_ref die;
2189 struct limbo_die_struct *next;
2190}
2191limbo_die_node;
2192
2193/* How to start an assembler comment. */
2194#ifndef ASM_COMMENT_START
2195#define ASM_COMMENT_START ";#"
2196#endif
2197
2198/* Define a macro which returns non-zero for a TYPE_DECL which was
2199 implicitly generated for a tagged type.
2200
2201 Note that unlike the gcc front end (which generates a NULL named
2202 TYPE_DECL node for each complete tagged type, each array type, and
2203 each function type node created) the g++ front end generates a
2204 _named_ TYPE_DECL node for each tagged type node created.
2205 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2206 generate a DW_TAG_typedef DIE for them. */
2207
2208#define TYPE_DECL_IS_STUB(decl) \
2209 (DECL_NAME (decl) == NULL_TREE \
2210 || (DECL_ARTIFICIAL (decl) \
2211 && is_tagged_type (TREE_TYPE (decl)) \
2212 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
2213 /* This is necessary for stub decls that \
2214 appear in nested inline functions. */ \
2215 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2216 && (decl_ultimate_origin (decl) \
2217 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2218
2219/* Information concerning the compilation unit's programming
2220 language, and compiler version. */
2221
2222extern int flag_traditional;
2223extern char *version_string;
2224extern char *language_string;
2225
2226/* Fixed size portion of the DWARF compilation unit header. */
2227#define DWARF_COMPILE_UNIT_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 3)
2228
2229/* Fixed size portion of debugging line information prolog. */
2230#define DWARF_LINE_PROLOG_HEADER_SIZE 5
2231
2232/* Fixed size portion of public names info. */
2233#define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2234
2235/* Fixed size portion of the address range info. */
2236#define DWARF_ARANGES_HEADER_SIZE \
2237 (DWARF_ROUND (2 * DWARF_OFFSET_SIZE + 4, PTR_SIZE * 2) - DWARF_OFFSET_SIZE)
2238
2239/* Define the architecture-dependent minimum instruction length (in bytes).
2240 In this implementation of DWARF, this field is used for information
2241 purposes only. Since GCC generates assembly language, we have
2242 no a priori knowledge of how many instruction bytes are generated
2243 for each source line, and therefore can use only the DW_LNE_set_address
2244 and DW_LNS_fixed_advance_pc line information commands. */
2245
2246#ifndef DWARF_LINE_MIN_INSTR_LENGTH
2247#define DWARF_LINE_MIN_INSTR_LENGTH 4
2248#endif
2249
2250/* Minimum line offset in a special line info. opcode.
2251 This value was chosen to give a reasonable range of values. */
2252#define DWARF_LINE_BASE -10
2253
2254/* First special line opcde - leave room for the standard opcodes. */
2255#define DWARF_LINE_OPCODE_BASE 10
2256
2257/* Range of line offsets in a special line info. opcode. */
2258#define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
2259
2260/* Flag that indicates the initial value of the is_stmt_start flag.
2261 In the present implementation, we do not mark any lines as
2262 the beginning of a source statement, because that information
2263 is not made available by the GCC front-end. */
2264#define DWARF_LINE_DEFAULT_IS_STMT_START 1
2265
2266/* This location is used by calc_die_sizes() to keep track
2267 the offset of each DIE within the .debug_info section. */
2268static unsigned long next_die_offset;
2269
2270/* Record the root of the DIE's built for the current compilation unit. */
2271static dw_die_ref comp_unit_die;
2272
2273/* A list of DIEs with a NULL parent waiting to be relocated. */
2274static limbo_die_node *limbo_die_list = 0;
2275
2276/* Pointer to an array of filenames referenced by this compilation unit. */
2277static char **file_table;
2278
2279/* Total number of entries in the table (i.e. array) pointed to by
2280 `file_table'. This is the *total* and includes both used and unused
2281 slots. */
2282static unsigned file_table_allocated;
2283
2284/* Number of entries in the file_table which are actually in use. */
2285static unsigned file_table_in_use;
2286
2287/* Size (in elements) of increments by which we may expand the filename
2288 table. */
2289#define FILE_TABLE_INCREMENT 64
2290
2291/* Local pointer to the name of the main input file. Initialized in
2292 dwarf2out_init. */
2293static char *primary_filename;
2294
2295/* For Dwarf output, we must assign lexical-blocks id numbers in the order in
2296 which their beginnings are encountered. We output Dwarf debugging info
2297 that refers to the beginnings and ends of the ranges of code for each
2298 lexical block. The labels themselves are generated in final.c, which
2299 assigns numbers to the blocks in the same way. */
2300static unsigned next_block_number = 2;
2301
2302/* A pointer to the base of a table of references to DIE's that describe
2303 declarations. The table is indexed by DECL_UID() which is a unique
2304 number identifying each decl. */
2305static dw_die_ref *decl_die_table;
2306
2307/* Number of elements currently allocated for the decl_die_table. */
2308static unsigned decl_die_table_allocated;
2309
2310/* Number of elements in decl_die_table currently in use. */
2311static unsigned decl_die_table_in_use;
2312
2313/* Size (in elements) of increments by which we may expand the
2314 decl_die_table. */
2315#define DECL_DIE_TABLE_INCREMENT 256
2316
2317/* Structure used for the decl_scope table. scope is the current declaration
2318 scope, and previous is the entry that is the parent of this scope. This
2319 is usually but not always the immediately preceeding entry. */
2320
2321typedef struct decl_scope_struct
2322{
2323 tree scope;
2324 int previous;
2325}
2326decl_scope_node;
2327
2328/* A pointer to the base of a table of references to declaration
2329 scopes. This table is a display which tracks the nesting
2330 of declaration scopes at the current scope and containing
2331 scopes. This table is used to find the proper place to
2332 define type declaration DIE's. */
2333static decl_scope_node *decl_scope_table;
2334
2335/* Number of elements currently allocated for the decl_scope_table. */
2336static int decl_scope_table_allocated;
2337
2338/* Current level of nesting of declaration scopes. */
2339static int decl_scope_depth;
2340
2341/* Size (in elements) of increments by which we may expand the
2342 decl_scope_table. */
2343#define DECL_SCOPE_TABLE_INCREMENT 64
2344
2345/* A pointer to the base of a list of references to DIE's that
2346 are uniquely identified by their tag, presence/absence of
2347 children DIE's, and list of attribute/value pairs. */
2348static dw_die_ref *abbrev_die_table;
2349
2350/* Number of elements currently allocated for abbrev_die_table. */
2351static unsigned abbrev_die_table_allocated;
2352
2353/* Number of elements in type_die_table currently in use. */
2354static unsigned abbrev_die_table_in_use;
2355
2356/* Size (in elements) of increments by which we may expand the
2357 abbrev_die_table. */
2358#define ABBREV_DIE_TABLE_INCREMENT 256
2359
2360/* A pointer to the base of a table that contains line information
2361 for each source code line in .text in the compilation unit. */
2362static dw_line_info_ref line_info_table;
2363
2364/* Number of elements currently allocated for line_info_table. */
2365static unsigned line_info_table_allocated;
2366
2367/* Number of elements in separate_line_info_table currently in use. */
2368static unsigned separate_line_info_table_in_use;
2369
2370/* A pointer to the base of a table that contains line information
2371 for each source code line outside of .text in the compilation unit. */
2372static dw_separate_line_info_ref separate_line_info_table;
2373
2374/* Number of elements currently allocated for separate_line_info_table. */
2375static unsigned separate_line_info_table_allocated;
2376
2377/* Number of elements in line_info_table currently in use. */
2378static unsigned line_info_table_in_use;
2379
2380/* Size (in elements) of increments by which we may expand the
2381 line_info_table. */
2382#define LINE_INFO_TABLE_INCREMENT 1024
2383
2384/* A pointer to the base of a table that contains a list of publicly
2385 accessible names. */
2386static pubname_ref pubname_table;
2387
2388/* Number of elements currently allocated for pubname_table. */
2389static unsigned pubname_table_allocated;
2390
2391/* Number of elements in pubname_table currently in use. */
2392static unsigned pubname_table_in_use;
2393
2394/* Size (in elements) of increments by which we may expand the
2395 pubname_table. */
2396#define PUBNAME_TABLE_INCREMENT 64
2397
2398/* A pointer to the base of a table that contains a list of publicly
2399 accessible names. */
2400static arange_ref arange_table;
2401
2402/* Number of elements currently allocated for arange_table. */
2403static unsigned arange_table_allocated;
2404
2405/* Number of elements in arange_table currently in use. */
2406static unsigned arange_table_in_use;
2407
2408/* Size (in elements) of increments by which we may expand the
2409 arange_table. */
2410#define ARANGE_TABLE_INCREMENT 64
2411
2412/* A pointer to the base of a list of pending types which we haven't
2413 generated DIEs for yet, but which we will have to come back to
2414 later on. */
2415
2416static tree *pending_types_list;
2417
2418/* Number of elements currently allocated for the pending_types_list. */
2419static unsigned pending_types_allocated;
2420
2421/* Number of elements of pending_types_list currently in use. */
2422static unsigned pending_types;
2423
2424/* Size (in elements) of increments by which we may expand the pending
2425 types list. Actually, a single hunk of space of this size should
2426 be enough for most typical programs. */
2427#define PENDING_TYPES_INCREMENT 64
2428
|
2429/* A pointer to the base of a list of incomplete types which might be
2430 completed at some later time. */
2431
2432static tree *incomplete_types_list;
2433
2434/* Number of elements currently allocated for the incomplete_types_list. */
2435static unsigned incomplete_types_allocated;
2436
2437/* Number of elements of incomplete_types_list currently in use. */
2438static unsigned incomplete_types;
2439
2440/* Size (in elements) of increments by which we may expand the incomplete
2441 types list. Actually, a single hunk of space of this size should
2442 be enough for most typical programs. */
2443#define INCOMPLETE_TYPES_INCREMENT 64
2444 |
2445/* Record whether the function being analyzed contains inlined functions. */
2446static int current_function_has_inlines;
2447#if 0 && defined (MIPS_DEBUGGING_INFO)
2448static int comp_unit_has_inlines;
2449#endif
2450
2451/* A pointer to the ..._DECL node which we have most recently been working
2452 on. We keep this around just in case something about it looks screwy and
2453 we want to tell the user what the source coordinates for the actual
2454 declaration are. */
2455static tree dwarf_last_decl;
2456
2457/* Forward declarations for functions defined in this file. */
2458
2459static void addr_const_to_string PROTO((dyn_string_t, rtx));
2460static char *addr_to_string PROTO((rtx));
2461static int is_pseudo_reg PROTO((rtx));
2462static tree type_main_variant PROTO((tree));
2463static int is_tagged_type PROTO((tree));
2464static char *dwarf_tag_name PROTO((unsigned));
2465static char *dwarf_attr_name PROTO((unsigned));
2466static char *dwarf_form_name PROTO((unsigned));
2467static char *dwarf_stack_op_name PROTO((unsigned));
2468#if 0
2469static char *dwarf_type_encoding_name PROTO((unsigned));
2470#endif
2471static tree decl_ultimate_origin PROTO((tree));
2472static tree block_ultimate_origin PROTO((tree));
2473static tree decl_class_context PROTO((tree));
2474static void add_dwarf_attr PROTO((dw_die_ref, dw_attr_ref));
2475static void add_AT_flag PROTO((dw_die_ref,
2476 enum dwarf_attribute,
2477 unsigned));
2478static void add_AT_int PROTO((dw_die_ref,
2479 enum dwarf_attribute, long));
2480static void add_AT_unsigned PROTO((dw_die_ref,
2481 enum dwarf_attribute,
2482 unsigned long));
2483static void add_AT_long_long PROTO((dw_die_ref,
2484 enum dwarf_attribute,
2485 unsigned long, unsigned long));
2486static void add_AT_float PROTO((dw_die_ref,
2487 enum dwarf_attribute,
2488 unsigned, long *));
2489static void add_AT_string PROTO((dw_die_ref,
2490 enum dwarf_attribute, char *));
2491static void add_AT_die_ref PROTO((dw_die_ref,
2492 enum dwarf_attribute,
2493 dw_die_ref));
2494static void add_AT_fde_ref PROTO((dw_die_ref,
2495 enum dwarf_attribute,
2496 unsigned));
2497static void add_AT_loc PROTO((dw_die_ref,
2498 enum dwarf_attribute,
2499 dw_loc_descr_ref));
2500static void add_AT_addr PROTO((dw_die_ref,
2501 enum dwarf_attribute, char *));
2502static void add_AT_lbl_id PROTO((dw_die_ref,
2503 enum dwarf_attribute, char *));
|
2423static void add_AT_section_offset PROTO((dw_die_ref,
|
| 2504static void add_AT_lbl_offset PROTO((dw_die_ref, |
2505 enum dwarf_attribute, char *));
2506static int is_extern_subr_die PROTO((dw_die_ref));
2507static dw_attr_ref get_AT PROTO((dw_die_ref,
2508 enum dwarf_attribute));
2509static char *get_AT_low_pc PROTO((dw_die_ref));
2510static char *get_AT_hi_pc PROTO((dw_die_ref));
2511static char *get_AT_string PROTO((dw_die_ref,
2512 enum dwarf_attribute));
2513static int get_AT_flag PROTO((dw_die_ref,
2514 enum dwarf_attribute));
2515static unsigned get_AT_unsigned PROTO((dw_die_ref,
2516 enum dwarf_attribute));
2517static int is_c_family PROTO((void));
2518static int is_fortran PROTO((void));
2519static void remove_AT PROTO((dw_die_ref,
2520 enum dwarf_attribute));
2521static void remove_children PROTO((dw_die_ref));
2522static void add_child_die PROTO((dw_die_ref, dw_die_ref));
2523static dw_die_ref new_die PROTO((enum dwarf_tag, dw_die_ref));
2524static dw_die_ref lookup_type_die PROTO((tree));
2525static void equate_type_number_to_die PROTO((tree, dw_die_ref));
2526static dw_die_ref lookup_decl_die PROTO((tree));
2527static void equate_decl_number_to_die PROTO((tree, dw_die_ref));
2528static dw_loc_descr_ref new_loc_descr PROTO((enum dwarf_location_atom,
2529 unsigned long, unsigned long));
2530static void add_loc_descr PROTO((dw_loc_descr_ref *,
2531 dw_loc_descr_ref));
2532static void print_spaces PROTO((FILE *));
2533static void print_die PROTO((dw_die_ref, FILE *));
2534static void print_dwarf_line_table PROTO((FILE *));
2535static void add_sibling_attributes PROTO((dw_die_ref));
2536static void build_abbrev_table PROTO((dw_die_ref));
2537static unsigned long size_of_string PROTO((char *));
2538static unsigned long size_of_loc_descr PROTO((dw_loc_descr_ref));
2539static unsigned long size_of_locs PROTO((dw_loc_descr_ref));
2540static int constant_size PROTO((long unsigned));
2541static unsigned long size_of_die PROTO((dw_die_ref));
2542static void calc_die_sizes PROTO((dw_die_ref));
2543static unsigned long size_of_line_prolog PROTO((void));
2544static unsigned long size_of_line_info PROTO((void));
2545static unsigned long size_of_pubnames PROTO((void));
2546static unsigned long size_of_aranges PROTO((void));
2547static enum dwarf_form value_format PROTO((dw_val_ref));
2548static void output_value_format PROTO((dw_val_ref));
2549static void output_abbrev_section PROTO((void));
2550static void output_loc_operands PROTO((dw_loc_descr_ref));
2551static unsigned long sibling_offset PROTO((dw_die_ref));
2552static void output_die PROTO((dw_die_ref));
2553static void output_compilation_unit_header PROTO((void));
2554static char *dwarf2_name PROTO((tree, int));
2555static void add_pubname PROTO((tree, dw_die_ref));
2556static void output_pubnames PROTO((void));
2557static void add_arange PROTO((tree, dw_die_ref));
2558static void output_aranges PROTO((void));
2559static void output_line_info PROTO((void));
2560static int is_body_block PROTO((tree));
2561static dw_die_ref base_type_die PROTO((tree));
2562static tree root_type PROTO((tree));
2563static int is_base_type PROTO((tree));
2564static dw_die_ref modified_type_die PROTO((tree, int, int, dw_die_ref));
2565static int type_is_enum PROTO((tree));
2566static dw_loc_descr_ref reg_loc_descriptor PROTO((rtx));
2567static dw_loc_descr_ref based_loc_descr PROTO((unsigned, long));
2568static int is_based_loc PROTO((rtx));
2569static dw_loc_descr_ref mem_loc_descriptor PROTO((rtx));
2570static dw_loc_descr_ref concat_loc_descriptor PROTO((rtx, rtx));
2571static dw_loc_descr_ref loc_descriptor PROTO((rtx));
2572static unsigned ceiling PROTO((unsigned, unsigned));
2573static tree field_type PROTO((tree));
2574static unsigned simple_type_align_in_bits PROTO((tree));
2575static unsigned simple_type_size_in_bits PROTO((tree));
2576static unsigned field_byte_offset PROTO((tree));
2577static void add_AT_location_description PROTO((dw_die_ref,
2578 enum dwarf_attribute, rtx));
2579static void add_data_member_location_attribute PROTO((dw_die_ref, tree));
2580static void add_const_value_attribute PROTO((dw_die_ref, rtx));
2581static void add_location_or_const_value_attribute PROTO((dw_die_ref, tree));
2582static void add_name_attribute PROTO((dw_die_ref, char *));
2583static void add_bound_info PROTO((dw_die_ref,
2584 enum dwarf_attribute, tree));
2585static void add_subscript_info PROTO((dw_die_ref, tree));
2586static void add_byte_size_attribute PROTO((dw_die_ref, tree));
2587static void add_bit_offset_attribute PROTO((dw_die_ref, tree));
2588static void add_bit_size_attribute PROTO((dw_die_ref, tree));
2589static void add_prototyped_attribute PROTO((dw_die_ref, tree));
2590static void add_abstract_origin_attribute PROTO((dw_die_ref, tree));
2591static void add_pure_or_virtual_attribute PROTO((dw_die_ref, tree));
2592static void add_src_coords_attributes PROTO((dw_die_ref, tree));
2593static void add_name_and_src_coords_attributes PROTO((dw_die_ref, tree));
2594static void push_decl_scope PROTO((tree));
2595static dw_die_ref scope_die_for PROTO((tree, dw_die_ref));
2596static void pop_decl_scope PROTO((void));
2597static void add_type_attribute PROTO((dw_die_ref, tree, int, int,
2598 dw_die_ref));
2599static char *type_tag PROTO((tree));
2600static tree member_declared_type PROTO((tree));
2601#if 0
2602static char *decl_start_label PROTO((tree));
2603#endif
2604static void gen_array_type_die PROTO((tree, dw_die_ref));
2605static void gen_set_type_die PROTO((tree, dw_die_ref));
2606#if 0
2607static void gen_entry_point_die PROTO((tree, dw_die_ref));
2608#endif
2609static void pend_type PROTO((tree));
2610static void output_pending_types_for_scope PROTO((dw_die_ref));
2611static void gen_inlined_enumeration_type_die PROTO((tree, dw_die_ref));
2612static void gen_inlined_structure_type_die PROTO((tree, dw_die_ref));
2613static void gen_inlined_union_type_die PROTO((tree, dw_die_ref));
2614static void gen_enumeration_type_die PROTO((tree, dw_die_ref));
2615static dw_die_ref gen_formal_parameter_die PROTO((tree, dw_die_ref));
2616static void gen_unspecified_parameters_die PROTO((tree, dw_die_ref));
2617static void gen_formal_types_die PROTO((tree, dw_die_ref));
2618static void gen_subprogram_die PROTO((tree, dw_die_ref));
2619static void gen_variable_die PROTO((tree, dw_die_ref));
2620static void gen_label_die PROTO((tree, dw_die_ref));
2621static void gen_lexical_block_die PROTO((tree, dw_die_ref, int));
2622static void gen_inlined_subroutine_die PROTO((tree, dw_die_ref, int));
2623static void gen_field_die PROTO((tree, dw_die_ref));
2624static void gen_ptr_to_mbr_type_die PROTO((tree, dw_die_ref));
2625static void gen_compile_unit_die PROTO((char *));
2626static void gen_string_type_die PROTO((tree, dw_die_ref));
2627static void gen_inheritance_die PROTO((tree, dw_die_ref));
2628static void gen_member_die PROTO((tree, dw_die_ref));
2629static void gen_struct_or_union_type_die PROTO((tree, dw_die_ref));
2630static void gen_subroutine_type_die PROTO((tree, dw_die_ref));
2631static void gen_typedef_die PROTO((tree, dw_die_ref));
2632static void gen_type_die PROTO((tree, dw_die_ref));
2633static void gen_tagged_type_instantiation_die PROTO((tree, dw_die_ref));
2634static void gen_block_die PROTO((tree, dw_die_ref, int));
2635static void decls_for_scope PROTO((tree, dw_die_ref, int));
2636static int is_redundant_typedef PROTO((tree));
2637static void gen_decl_die PROTO((tree, dw_die_ref));
2638static unsigned lookup_filename PROTO((char *));
2639
2640/* Section names used to hold DWARF debugging information. */
2641#ifndef DEBUG_INFO_SECTION
2642#define DEBUG_INFO_SECTION ".debug_info"
2643#endif
2644#ifndef ABBREV_SECTION
2645#define ABBREV_SECTION ".debug_abbrev"
2646#endif
2647#ifndef ARANGES_SECTION
2648#define ARANGES_SECTION ".debug_aranges"
2649#endif
2650#ifndef DW_MACINFO_SECTION
2651#define DW_MACINFO_SECTION ".debug_macinfo"
2652#endif
2653#ifndef DEBUG_LINE_SECTION
2654#define DEBUG_LINE_SECTION ".debug_line"
2655#endif
2656#ifndef LOC_SECTION
2657#define LOC_SECTION ".debug_loc"
2658#endif
2659#ifndef PUBNAMES_SECTION
2660#define PUBNAMES_SECTION ".debug_pubnames"
2661#endif
2662#ifndef STR_SECTION
2663#define STR_SECTION ".debug_str"
2664#endif
2665
2666/* Standard ELF section names for compiled code and data. */
2667#ifndef TEXT_SECTION
2668#define TEXT_SECTION ".text"
2669#endif
2670#ifndef DATA_SECTION
2671#define DATA_SECTION ".data"
2672#endif
2673#ifndef BSS_SECTION
2674#define BSS_SECTION ".bss"
2675#endif
2676
|
2677/* Labels we insert at beginning sections we can reference instead of
2678 the section names themselves. */ |
2679
|
2680#ifndef TEXT_SECTION_LABEL
2681#define TEXT_SECTION_LABEL "Ltext"
2682#endif
2683#ifndef DEBUG_LINE_SECTION_LABEL
2684#define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
2685#endif
2686#ifndef DEBUG_INFO_SECTION_LABEL
2687#define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
2688#endif
2689#ifndef ABBREV_SECTION_LABEL
2690#define ABBREV_SECTION_LABEL "Ldebug_abbrev"
2691#endif
2692
2693 |
2694/* Definitions of defaults for formats and names of various special
2695 (artificial) labels which may be generated within this file (when the -g
2696 options is used and DWARF_DEBUGGING_INFO is in effect.
2697 If necessary, these may be overridden from within the tm.h file, but
2698 typically, overriding these defaults is unnecessary. */
2699
2700static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
|
2701static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2702static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2703static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2704static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; |
2705
2706#ifndef TEXT_END_LABEL
2707#define TEXT_END_LABEL "Letext"
2708#endif
2709#ifndef DATA_END_LABEL
2710#define DATA_END_LABEL "Ledata"
2711#endif
2712#ifndef BSS_END_LABEL
2713#define BSS_END_LABEL "Lebss"
2714#endif
2715#ifndef INSN_LABEL_FMT
2716#define INSN_LABEL_FMT "LI%u_"
2717#endif
2718#ifndef BLOCK_BEGIN_LABEL
2719#define BLOCK_BEGIN_LABEL "LBB"
2720#endif
2721#ifndef BLOCK_END_LABEL
2722#define BLOCK_END_LABEL "LBE"
2723#endif
2724#ifndef BODY_BEGIN_LABEL
2725#define BODY_BEGIN_LABEL "Lbb"
2726#endif
2727#ifndef BODY_END_LABEL
2728#define BODY_END_LABEL "Lbe"
2729#endif
2730#ifndef LINE_CODE_LABEL
2731#define LINE_CODE_LABEL "LM"
2732#endif
2733#ifndef SEPARATE_LINE_CODE_LABEL
2734#define SEPARATE_LINE_CODE_LABEL "LSM"
2735#endif
2736
2737/* Convert a reference to the assembler name of a C-level name. This
2738 macro has the same effect as ASM_OUTPUT_LABELREF, but copies to
2739 a string rather than writing to a file. */
2740#ifndef ASM_NAME_TO_STRING
|
2640#define ASM_NAME_TO_STRING(STR, NAME) \
2641 do { \
2642 if ((NAME)[0] == '*') \
2643 dyn_string_append (STR, NAME + 1); \
2644 else \
2645 dyn_string_append (STR, NAME); \
2646 } \
|
2741#define ASM_NAME_TO_STRING(STR, NAME) \
2742 do { \
2743 if ((NAME)[0] == '*') \
2744 dyn_string_append (STR, NAME + 1); \
2745 else \
2746 { \
2747 char *newstr; \
2748 STRIP_NAME_ENCODING (newstr, NAME); \
2749 dyn_string_append (STR, user_label_prefix); \
2750 dyn_string_append (STR, newstr); \
2751 } \
2752 } \ |
2753 while (0)
2754#endif
2755
2756/* Convert an integer constant expression into assembler syntax. Addition
2757 and subtraction are the only arithmetic that may appear in these
2758 expressions. This is an adaptation of output_addr_const in final.c.
2759 Here, the target of the conversion is a string buffer. We can't use
2760 output_addr_const directly, because it writes to a file. */
2761
2762static void
2763addr_const_to_string (str, x)
2764 dyn_string_t str;
2765 rtx x;
2766{
2767 char buf1[256];
2768
2769restart:
2770 switch (GET_CODE (x))
2771 {
2772 case PC:
2773 if (flag_pic)
2774 dyn_string_append (str, ",");
2775 else
2776 abort ();
2777 break;
2778
2779 case SYMBOL_REF:
2780 ASM_NAME_TO_STRING (str, XSTR (x, 0));
2781 break;
2782
2783 case LABEL_REF:
2784 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (XEXP (x, 0)));
2785 ASM_NAME_TO_STRING (str, buf1);
2786 break;
2787
2788 case CODE_LABEL:
2789 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (x));
2790 ASM_NAME_TO_STRING (str, buf1);
2791 break;
2792
2793 case CONST_INT:
2794 sprintf (buf1, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
2795 dyn_string_append (str, buf1);
2796 break;
2797
2798 case CONST:
2799 /* This used to output parentheses around the expression, but that does
2800 not work on the 386 (either ATT or BSD assembler). */
2801 addr_const_to_string (str, XEXP (x, 0));
2802 break;
2803
2804 case CONST_DOUBLE:
2805 if (GET_MODE (x) == VOIDmode)
2806 {
2807 /* We can use %d if the number is one word and positive. */
2808 if (CONST_DOUBLE_HIGH (x))
2809 sprintf (buf1, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
2810 CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x));
2811 else if (CONST_DOUBLE_LOW (x) < 0)
2812 sprintf (buf1, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x));
2813 else
2814 sprintf (buf1, HOST_WIDE_INT_PRINT_DEC,
2815 CONST_DOUBLE_LOW (x));
2816 dyn_string_append (str, buf1);
2817 }
2818 else
2819 /* We can't handle floating point constants; PRINT_OPERAND must
2820 handle them. */
2821 output_operand_lossage ("floating constant misused");
2822 break;
2823
2824 case PLUS:
2825 /* Some assemblers need integer constants to appear last (eg masm). */
2826 if (GET_CODE (XEXP (x, 0)) == CONST_INT)
2827 {
2828 addr_const_to_string (str, XEXP (x, 1));
2829 if (INTVAL (XEXP (x, 0)) >= 0)
2830 dyn_string_append (str, "+");
2831
2832 addr_const_to_string (str, XEXP (x, 0));
2833 }
2834 else
2835 {
2836 addr_const_to_string (str, XEXP (x, 0));
2837 if (INTVAL (XEXP (x, 1)) >= 0)
2838 dyn_string_append (str, "+");
2839
2840 addr_const_to_string (str, XEXP (x, 1));
2841 }
2842 break;
2843
2844 case MINUS:
2845 /* Avoid outputting things like x-x or x+5-x, since some assemblers
2846 can't handle that. */
2847 x = simplify_subtraction (x);
2848 if (GET_CODE (x) != MINUS)
2849 goto restart;
2850
2851 addr_const_to_string (str, XEXP (x, 0));
2852 dyn_string_append (str, "-");
2853 if (GET_CODE (XEXP (x, 1)) == CONST_INT
2854 && INTVAL (XEXP (x, 1)) < 0)
2855 {
2856 dyn_string_append (str, ASM_OPEN_PAREN);
2857 addr_const_to_string (str, XEXP (x, 1));
2858 dyn_string_append (str, ASM_CLOSE_PAREN);
2859 }
2860 else
2861 addr_const_to_string (str, XEXP (x, 1));
2862 break;
2863
2864 case ZERO_EXTEND:
2865 case SIGN_EXTEND:
2866 addr_const_to_string (str, XEXP (x, 0));
2867 break;
2868
2869 default:
2870 output_operand_lossage ("invalid expression as operand");
2871 }
2872}
2873
2874/* Convert an address constant to a string, and return a pointer to
2875 a copy of the result, located on the heap. */
2876
2877static char *
2878addr_to_string (x)
2879 rtx x;
2880{
2881 dyn_string_t ds = dyn_string_new (256);
2882 char *s;
2883
2884 addr_const_to_string (ds, x);
2885
2886 /* Return the dynamically allocated string, but free the
2887 dyn_string_t itself. */
2888 s = ds->s;
2889 free (ds);
2890 return s;
2891}
2892
2893/* Test if rtl node points to a pseudo register. */
2894
2895static inline int
2896is_pseudo_reg (rtl)
2897 register rtx rtl;
2898{
2899 return (((GET_CODE (rtl) == REG) && (REGNO (rtl) >= FIRST_PSEUDO_REGISTER))
2900 || ((GET_CODE (rtl) == SUBREG)
2901 && (REGNO (XEXP (rtl, 0)) >= FIRST_PSEUDO_REGISTER)));
2902}
2903
2904/* Return a reference to a type, with its const and volatile qualifiers
2905 removed. */
2906
2907static inline tree
2908type_main_variant (type)
2909 register tree type;
2910{
2911 type = TYPE_MAIN_VARIANT (type);
2912
2913 /* There really should be only one main variant among any group of variants
2914 of a given type (and all of the MAIN_VARIANT values for all members of
2915 the group should point to that one type) but sometimes the C front-end
2916 messes this up for array types, so we work around that bug here. */
2917
2918 if (TREE_CODE (type) == ARRAY_TYPE)
2919 while (type != TYPE_MAIN_VARIANT (type))
2920 type = TYPE_MAIN_VARIANT (type);
2921
2922 return type;
2923}
2924
2925/* Return non-zero if the given type node represents a tagged type. */
2926
2927static inline int
2928is_tagged_type (type)
2929 register tree type;
2930{
2931 register enum tree_code code = TREE_CODE (type);
2932
2933 return (code == RECORD_TYPE || code == UNION_TYPE
2934 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
2935}
2936
2937/* Convert a DIE tag into its string name. */
2938
2939static char *
2940dwarf_tag_name (tag)
2941 register unsigned tag;
2942{
2943 switch (tag)
2944 {
2945 case DW_TAG_padding:
2946 return "DW_TAG_padding";
2947 case DW_TAG_array_type:
2948 return "DW_TAG_array_type";
2949 case DW_TAG_class_type:
2950 return "DW_TAG_class_type";
2951 case DW_TAG_entry_point:
2952 return "DW_TAG_entry_point";
2953 case DW_TAG_enumeration_type:
2954 return "DW_TAG_enumeration_type";
2955 case DW_TAG_formal_parameter:
2956 return "DW_TAG_formal_parameter";
2957 case DW_TAG_imported_declaration:
2958 return "DW_TAG_imported_declaration";
2959 case DW_TAG_label:
2960 return "DW_TAG_label";
2961 case DW_TAG_lexical_block:
2962 return "DW_TAG_lexical_block";
2963 case DW_TAG_member:
2964 return "DW_TAG_member";
2965 case DW_TAG_pointer_type:
2966 return "DW_TAG_pointer_type";
2967 case DW_TAG_reference_type:
2968 return "DW_TAG_reference_type";
2969 case DW_TAG_compile_unit:
2970 return "DW_TAG_compile_unit";
2971 case DW_TAG_string_type:
2972 return "DW_TAG_string_type";
2973 case DW_TAG_structure_type:
2974 return "DW_TAG_structure_type";
2975 case DW_TAG_subroutine_type:
2976 return "DW_TAG_subroutine_type";
2977 case DW_TAG_typedef:
2978 return "DW_TAG_typedef";
2979 case DW_TAG_union_type:
2980 return "DW_TAG_union_type";
2981 case DW_TAG_unspecified_parameters:
2982 return "DW_TAG_unspecified_parameters";
2983 case DW_TAG_variant:
2984 return "DW_TAG_variant";
2985 case DW_TAG_common_block:
2986 return "DW_TAG_common_block";
2987 case DW_TAG_common_inclusion:
2988 return "DW_TAG_common_inclusion";
2989 case DW_TAG_inheritance:
2990 return "DW_TAG_inheritance";
2991 case DW_TAG_inlined_subroutine:
2992 return "DW_TAG_inlined_subroutine";
2993 case DW_TAG_module:
2994 return "DW_TAG_module";
2995 case DW_TAG_ptr_to_member_type:
2996 return "DW_TAG_ptr_to_member_type";
2997 case DW_TAG_set_type:
2998 return "DW_TAG_set_type";
2999 case DW_TAG_subrange_type:
3000 return "DW_TAG_subrange_type";
3001 case DW_TAG_with_stmt:
3002 return "DW_TAG_with_stmt";
3003 case DW_TAG_access_declaration:
3004 return "DW_TAG_access_declaration";
3005 case DW_TAG_base_type:
3006 return "DW_TAG_base_type";
3007 case DW_TAG_catch_block:
3008 return "DW_TAG_catch_block";
3009 case DW_TAG_const_type:
3010 return "DW_TAG_const_type";
3011 case DW_TAG_constant:
3012 return "DW_TAG_constant";
3013 case DW_TAG_enumerator:
3014 return "DW_TAG_enumerator";
3015 case DW_TAG_file_type:
3016 return "DW_TAG_file_type";
3017 case DW_TAG_friend:
3018 return "DW_TAG_friend";
3019 case DW_TAG_namelist:
3020 return "DW_TAG_namelist";
3021 case DW_TAG_namelist_item:
3022 return "DW_TAG_namelist_item";
3023 case DW_TAG_packed_type:
3024 return "DW_TAG_packed_type";
3025 case DW_TAG_subprogram:
3026 return "DW_TAG_subprogram";
3027 case DW_TAG_template_type_param:
3028 return "DW_TAG_template_type_param";
3029 case DW_TAG_template_value_param:
3030 return "DW_TAG_template_value_param";
3031 case DW_TAG_thrown_type:
3032 return "DW_TAG_thrown_type";
3033 case DW_TAG_try_block:
3034 return "DW_TAG_try_block";
3035 case DW_TAG_variant_part:
3036 return "DW_TAG_variant_part";
3037 case DW_TAG_variable:
3038 return "DW_TAG_variable";
3039 case DW_TAG_volatile_type:
3040 return "DW_TAG_volatile_type";
3041 case DW_TAG_MIPS_loop:
3042 return "DW_TAG_MIPS_loop";
3043 case DW_TAG_format_label:
3044 return "DW_TAG_format_label";
3045 case DW_TAG_function_template:
3046 return "DW_TAG_function_template";
3047 case DW_TAG_class_template:
3048 return "DW_TAG_class_template";
3049 default:
3050 return "DW_TAG_<unknown>";
3051 }
3052}
3053
3054/* Convert a DWARF attribute code into its string name. */
3055
3056static char *
3057dwarf_attr_name (attr)
3058 register unsigned attr;
3059{
3060 switch (attr)
3061 {
3062 case DW_AT_sibling:
3063 return "DW_AT_sibling";
3064 case DW_AT_location:
3065 return "DW_AT_location";
3066 case DW_AT_name:
3067 return "DW_AT_name";
3068 case DW_AT_ordering:
3069 return "DW_AT_ordering";
3070 case DW_AT_subscr_data:
3071 return "DW_AT_subscr_data";
3072 case DW_AT_byte_size:
3073 return "DW_AT_byte_size";
3074 case DW_AT_bit_offset:
3075 return "DW_AT_bit_offset";
3076 case DW_AT_bit_size:
3077 return "DW_AT_bit_size";
3078 case DW_AT_element_list:
3079 return "DW_AT_element_list";
3080 case DW_AT_stmt_list:
3081 return "DW_AT_stmt_list";
3082 case DW_AT_low_pc:
3083 return "DW_AT_low_pc";
3084 case DW_AT_high_pc:
3085 return "DW_AT_high_pc";
3086 case DW_AT_language:
3087 return "DW_AT_language";
3088 case DW_AT_member:
3089 return "DW_AT_member";
3090 case DW_AT_discr:
3091 return "DW_AT_discr";
3092 case DW_AT_discr_value:
3093 return "DW_AT_discr_value";
3094 case DW_AT_visibility:
3095 return "DW_AT_visibility";
3096 case DW_AT_import:
3097 return "DW_AT_import";
3098 case DW_AT_string_length:
3099 return "DW_AT_string_length";
3100 case DW_AT_common_reference:
3101 return "DW_AT_common_reference";
3102 case DW_AT_comp_dir:
3103 return "DW_AT_comp_dir";
3104 case DW_AT_const_value:
3105 return "DW_AT_const_value";
3106 case DW_AT_containing_type:
3107 return "DW_AT_containing_type";
3108 case DW_AT_default_value:
3109 return "DW_AT_default_value";
3110 case DW_AT_inline:
3111 return "DW_AT_inline";
3112 case DW_AT_is_optional:
3113 return "DW_AT_is_optional";
3114 case DW_AT_lower_bound:
3115 return "DW_AT_lower_bound";
3116 case DW_AT_producer:
3117 return "DW_AT_producer";
3118 case DW_AT_prototyped:
3119 return "DW_AT_prototyped";
3120 case DW_AT_return_addr:
3121 return "DW_AT_return_addr";
3122 case DW_AT_start_scope:
3123 return "DW_AT_start_scope";
3124 case DW_AT_stride_size:
3125 return "DW_AT_stride_size";
3126 case DW_AT_upper_bound:
3127 return "DW_AT_upper_bound";
3128 case DW_AT_abstract_origin:
3129 return "DW_AT_abstract_origin";
3130 case DW_AT_accessibility:
3131 return "DW_AT_accessibility";
3132 case DW_AT_address_class:
3133 return "DW_AT_address_class";
3134 case DW_AT_artificial:
3135 return "DW_AT_artificial";
3136 case DW_AT_base_types:
3137 return "DW_AT_base_types";
3138 case DW_AT_calling_convention:
3139 return "DW_AT_calling_convention";
3140 case DW_AT_count:
3141 return "DW_AT_count";
3142 case DW_AT_data_member_location:
3143 return "DW_AT_data_member_location";
3144 case DW_AT_decl_column:
3145 return "DW_AT_decl_column";
3146 case DW_AT_decl_file:
3147 return "DW_AT_decl_file";
3148 case DW_AT_decl_line:
3149 return "DW_AT_decl_line";
3150 case DW_AT_declaration:
3151 return "DW_AT_declaration";
3152 case DW_AT_discr_list:
3153 return "DW_AT_discr_list";
3154 case DW_AT_encoding:
3155 return "DW_AT_encoding";
3156 case DW_AT_external:
3157 return "DW_AT_external";
3158 case DW_AT_frame_base:
3159 return "DW_AT_frame_base";
3160 case DW_AT_friend:
3161 return "DW_AT_friend";
3162 case DW_AT_identifier_case:
3163 return "DW_AT_identifier_case";
3164 case DW_AT_macro_info:
3165 return "DW_AT_macro_info";
3166 case DW_AT_namelist_items:
3167 return "DW_AT_namelist_items";
3168 case DW_AT_priority:
3169 return "DW_AT_priority";
3170 case DW_AT_segment:
3171 return "DW_AT_segment";
3172 case DW_AT_specification:
3173 return "DW_AT_specification";
3174 case DW_AT_static_link:
3175 return "DW_AT_static_link";
3176 case DW_AT_type:
3177 return "DW_AT_type";
3178 case DW_AT_use_location:
3179 return "DW_AT_use_location";
3180 case DW_AT_variable_parameter:
3181 return "DW_AT_variable_parameter";
3182 case DW_AT_virtuality:
3183 return "DW_AT_virtuality";
3184 case DW_AT_vtable_elem_location:
3185 return "DW_AT_vtable_elem_location";
3186
3187 case DW_AT_MIPS_fde:
3188 return "DW_AT_MIPS_fde";
3189 case DW_AT_MIPS_loop_begin:
3190 return "DW_AT_MIPS_loop_begin";
3191 case DW_AT_MIPS_tail_loop_begin:
3192 return "DW_AT_MIPS_tail_loop_begin";
3193 case DW_AT_MIPS_epilog_begin:
3194 return "DW_AT_MIPS_epilog_begin";
3195 case DW_AT_MIPS_loop_unroll_factor:
3196 return "DW_AT_MIPS_loop_unroll_factor";
3197 case DW_AT_MIPS_software_pipeline_depth:
3198 return "DW_AT_MIPS_software_pipeline_depth";
3199 case DW_AT_MIPS_linkage_name:
3200 return "DW_AT_MIPS_linkage_name";
3201 case DW_AT_MIPS_stride:
3202 return "DW_AT_MIPS_stride";
3203 case DW_AT_MIPS_abstract_name:
3204 return "DW_AT_MIPS_abstract_name";
3205 case DW_AT_MIPS_clone_origin:
3206 return "DW_AT_MIPS_clone_origin";
3207 case DW_AT_MIPS_has_inlines:
3208 return "DW_AT_MIPS_has_inlines";
3209
3210 case DW_AT_sf_names:
3211 return "DW_AT_sf_names";
3212 case DW_AT_src_info:
3213 return "DW_AT_src_info";
3214 case DW_AT_mac_info:
3215 return "DW_AT_mac_info";
3216 case DW_AT_src_coords:
3217 return "DW_AT_src_coords";
3218 case DW_AT_body_begin:
3219 return "DW_AT_body_begin";
3220 case DW_AT_body_end:
3221 return "DW_AT_body_end";
3222 default:
3223 return "DW_AT_<unknown>";
3224 }
3225}
3226
3227/* Convert a DWARF value form code into its string name. */
3228
3229static char *
3230dwarf_form_name (form)
3231 register unsigned form;
3232{
3233 switch (form)
3234 {
3235 case DW_FORM_addr:
3236 return "DW_FORM_addr";
3237 case DW_FORM_block2:
3238 return "DW_FORM_block2";
3239 case DW_FORM_block4:
3240 return "DW_FORM_block4";
3241 case DW_FORM_data2:
3242 return "DW_FORM_data2";
3243 case DW_FORM_data4:
3244 return "DW_FORM_data4";
3245 case DW_FORM_data8:
3246 return "DW_FORM_data8";
3247 case DW_FORM_string:
3248 return "DW_FORM_string";
3249 case DW_FORM_block:
3250 return "DW_FORM_block";
3251 case DW_FORM_block1:
3252 return "DW_FORM_block1";
3253 case DW_FORM_data1:
3254 return "DW_FORM_data1";
3255 case DW_FORM_flag:
3256 return "DW_FORM_flag";
3257 case DW_FORM_sdata:
3258 return "DW_FORM_sdata";
3259 case DW_FORM_strp:
3260 return "DW_FORM_strp";
3261 case DW_FORM_udata:
3262 return "DW_FORM_udata";
3263 case DW_FORM_ref_addr:
3264 return "DW_FORM_ref_addr";
3265 case DW_FORM_ref1:
3266 return "DW_FORM_ref1";
3267 case DW_FORM_ref2:
3268 return "DW_FORM_ref2";
3269 case DW_FORM_ref4:
3270 return "DW_FORM_ref4";
3271 case DW_FORM_ref8:
3272 return "DW_FORM_ref8";
3273 case DW_FORM_ref_udata:
3274 return "DW_FORM_ref_udata";
3275 case DW_FORM_indirect:
3276 return "DW_FORM_indirect";
3277 default:
3278 return "DW_FORM_<unknown>";
3279 }
3280}
3281
3282/* Convert a DWARF stack opcode into its string name. */
3283
3284static char *
3285dwarf_stack_op_name (op)
3286 register unsigned op;
3287{
3288 switch (op)
3289 {
3290 case DW_OP_addr:
3291 return "DW_OP_addr";
3292 case DW_OP_deref:
3293 return "DW_OP_deref";
3294 case DW_OP_const1u:
3295 return "DW_OP_const1u";
3296 case DW_OP_const1s:
3297 return "DW_OP_const1s";
3298 case DW_OP_const2u:
3299 return "DW_OP_const2u";
3300 case DW_OP_const2s:
3301 return "DW_OP_const2s";
3302 case DW_OP_const4u:
3303 return "DW_OP_const4u";
3304 case DW_OP_const4s:
3305 return "DW_OP_const4s";
3306 case DW_OP_const8u:
3307 return "DW_OP_const8u";
3308 case DW_OP_const8s:
3309 return "DW_OP_const8s";
3310 case DW_OP_constu:
3311 return "DW_OP_constu";
3312 case DW_OP_consts:
3313 return "DW_OP_consts";
3314 case DW_OP_dup:
3315 return "DW_OP_dup";
3316 case DW_OP_drop:
3317 return "DW_OP_drop";
3318 case DW_OP_over:
3319 return "DW_OP_over";
3320 case DW_OP_pick:
3321 return "DW_OP_pick";
3322 case DW_OP_swap:
3323 return "DW_OP_swap";
3324 case DW_OP_rot:
3325 return "DW_OP_rot";
3326 case DW_OP_xderef:
3327 return "DW_OP_xderef";
3328 case DW_OP_abs:
3329 return "DW_OP_abs";
3330 case DW_OP_and:
3331 return "DW_OP_and";
3332 case DW_OP_div:
3333 return "DW_OP_div";
3334 case DW_OP_minus:
3335 return "DW_OP_minus";
3336 case DW_OP_mod:
3337 return "DW_OP_mod";
3338 case DW_OP_mul:
3339 return "DW_OP_mul";
3340 case DW_OP_neg:
3341 return "DW_OP_neg";
3342 case DW_OP_not:
3343 return "DW_OP_not";
3344 case DW_OP_or:
3345 return "DW_OP_or";
3346 case DW_OP_plus:
3347 return "DW_OP_plus";
3348 case DW_OP_plus_uconst:
3349 return "DW_OP_plus_uconst";
3350 case DW_OP_shl:
3351 return "DW_OP_shl";
3352 case DW_OP_shr:
3353 return "DW_OP_shr";
3354 case DW_OP_shra:
3355 return "DW_OP_shra";
3356 case DW_OP_xor:
3357 return "DW_OP_xor";
3358 case DW_OP_bra:
3359 return "DW_OP_bra";
3360 case DW_OP_eq:
3361 return "DW_OP_eq";
3362 case DW_OP_ge:
3363 return "DW_OP_ge";
3364 case DW_OP_gt:
3365 return "DW_OP_gt";
3366 case DW_OP_le:
3367 return "DW_OP_le";
3368 case DW_OP_lt:
3369 return "DW_OP_lt";
3370 case DW_OP_ne:
3371 return "DW_OP_ne";
3372 case DW_OP_skip:
3373 return "DW_OP_skip";
3374 case DW_OP_lit0:
3375 return "DW_OP_lit0";
3376 case DW_OP_lit1:
3377 return "DW_OP_lit1";
3378 case DW_OP_lit2:
3379 return "DW_OP_lit2";
3380 case DW_OP_lit3:
3381 return "DW_OP_lit3";
3382 case DW_OP_lit4:
3383 return "DW_OP_lit4";
3384 case DW_OP_lit5:
3385 return "DW_OP_lit5";
3386 case DW_OP_lit6:
3387 return "DW_OP_lit6";
3388 case DW_OP_lit7:
3389 return "DW_OP_lit7";
3390 case DW_OP_lit8:
3391 return "DW_OP_lit8";
3392 case DW_OP_lit9:
3393 return "DW_OP_lit9";
3394 case DW_OP_lit10:
3395 return "DW_OP_lit10";
3396 case DW_OP_lit11:
3397 return "DW_OP_lit11";
3398 case DW_OP_lit12:
3399 return "DW_OP_lit12";
3400 case DW_OP_lit13:
3401 return "DW_OP_lit13";
3402 case DW_OP_lit14:
3403 return "DW_OP_lit14";
3404 case DW_OP_lit15:
3405 return "DW_OP_lit15";
3406 case DW_OP_lit16:
3407 return "DW_OP_lit16";
3408 case DW_OP_lit17:
3409 return "DW_OP_lit17";
3410 case DW_OP_lit18:
3411 return "DW_OP_lit18";
3412 case DW_OP_lit19:
3413 return "DW_OP_lit19";
3414 case DW_OP_lit20:
3415 return "DW_OP_lit20";
3416 case DW_OP_lit21:
3417 return "DW_OP_lit21";
3418 case DW_OP_lit22:
3419 return "DW_OP_lit22";
3420 case DW_OP_lit23:
3421 return "DW_OP_lit23";
3422 case DW_OP_lit24:
3423 return "DW_OP_lit24";
3424 case DW_OP_lit25:
3425 return "DW_OP_lit25";
3426 case DW_OP_lit26:
3427 return "DW_OP_lit26";
3428 case DW_OP_lit27:
3429 return "DW_OP_lit27";
3430 case DW_OP_lit28:
3431 return "DW_OP_lit28";
3432 case DW_OP_lit29:
3433 return "DW_OP_lit29";
3434 case DW_OP_lit30:
3435 return "DW_OP_lit30";
3436 case DW_OP_lit31:
3437 return "DW_OP_lit31";
3438 case DW_OP_reg0:
3439 return "DW_OP_reg0";
3440 case DW_OP_reg1:
3441 return "DW_OP_reg1";
3442 case DW_OP_reg2:
3443 return "DW_OP_reg2";
3444 case DW_OP_reg3:
3445 return "DW_OP_reg3";
3446 case DW_OP_reg4:
3447 return "DW_OP_reg4";
3448 case DW_OP_reg5:
3449 return "DW_OP_reg5";
3450 case DW_OP_reg6:
3451 return "DW_OP_reg6";
3452 case DW_OP_reg7:
3453 return "DW_OP_reg7";
3454 case DW_OP_reg8:
3455 return "DW_OP_reg8";
3456 case DW_OP_reg9:
3457 return "DW_OP_reg9";
3458 case DW_OP_reg10:
3459 return "DW_OP_reg10";
3460 case DW_OP_reg11:
3461 return "DW_OP_reg11";
3462 case DW_OP_reg12:
3463 return "DW_OP_reg12";
3464 case DW_OP_reg13:
3465 return "DW_OP_reg13";
3466 case DW_OP_reg14:
3467 return "DW_OP_reg14";
3468 case DW_OP_reg15:
3469 return "DW_OP_reg15";
3470 case DW_OP_reg16:
3471 return "DW_OP_reg16";
3472 case DW_OP_reg17:
3473 return "DW_OP_reg17";
3474 case DW_OP_reg18:
3475 return "DW_OP_reg18";
3476 case DW_OP_reg19:
3477 return "DW_OP_reg19";
3478 case DW_OP_reg20:
3479 return "DW_OP_reg20";
3480 case DW_OP_reg21:
3481 return "DW_OP_reg21";
3482 case DW_OP_reg22:
3483 return "DW_OP_reg22";
3484 case DW_OP_reg23:
3485 return "DW_OP_reg23";
3486 case DW_OP_reg24:
3487 return "DW_OP_reg24";
3488 case DW_OP_reg25:
3489 return "DW_OP_reg25";
3490 case DW_OP_reg26:
3491 return "DW_OP_reg26";
3492 case DW_OP_reg27:
3493 return "DW_OP_reg27";
3494 case DW_OP_reg28:
3495 return "DW_OP_reg28";
3496 case DW_OP_reg29:
3497 return "DW_OP_reg29";
3498 case DW_OP_reg30:
3499 return "DW_OP_reg30";
3500 case DW_OP_reg31:
3501 return "DW_OP_reg31";
3502 case DW_OP_breg0:
3503 return "DW_OP_breg0";
3504 case DW_OP_breg1:
3505 return "DW_OP_breg1";
3506 case DW_OP_breg2:
3507 return "DW_OP_breg2";
3508 case DW_OP_breg3:
3509 return "DW_OP_breg3";
3510 case DW_OP_breg4:
3511 return "DW_OP_breg4";
3512 case DW_OP_breg5:
3513 return "DW_OP_breg5";
3514 case DW_OP_breg6:
3515 return "DW_OP_breg6";
3516 case DW_OP_breg7:
3517 return "DW_OP_breg7";
3518 case DW_OP_breg8:
3519 return "DW_OP_breg8";
3520 case DW_OP_breg9:
3521 return "DW_OP_breg9";
3522 case DW_OP_breg10:
3523 return "DW_OP_breg10";
3524 case DW_OP_breg11:
3525 return "DW_OP_breg11";
3526 case DW_OP_breg12:
3527 return "DW_OP_breg12";
3528 case DW_OP_breg13:
3529 return "DW_OP_breg13";
3530 case DW_OP_breg14:
3531 return "DW_OP_breg14";
3532 case DW_OP_breg15:
3533 return "DW_OP_breg15";
3534 case DW_OP_breg16:
3535 return "DW_OP_breg16";
3536 case DW_OP_breg17:
3537 return "DW_OP_breg17";
3538 case DW_OP_breg18:
3539 return "DW_OP_breg18";
3540 case DW_OP_breg19:
3541 return "DW_OP_breg19";
3542 case DW_OP_breg20:
3543 return "DW_OP_breg20";
3544 case DW_OP_breg21:
3545 return "DW_OP_breg21";
3546 case DW_OP_breg22:
3547 return "DW_OP_breg22";
3548 case DW_OP_breg23:
3549 return "DW_OP_breg23";
3550 case DW_OP_breg24:
3551 return "DW_OP_breg24";
3552 case DW_OP_breg25:
3553 return "DW_OP_breg25";
3554 case DW_OP_breg26:
3555 return "DW_OP_breg26";
3556 case DW_OP_breg27:
3557 return "DW_OP_breg27";
3558 case DW_OP_breg28:
3559 return "DW_OP_breg28";
3560 case DW_OP_breg29:
3561 return "DW_OP_breg29";
3562 case DW_OP_breg30:
3563 return "DW_OP_breg30";
3564 case DW_OP_breg31:
3565 return "DW_OP_breg31";
3566 case DW_OP_regx:
3567 return "DW_OP_regx";
3568 case DW_OP_fbreg:
3569 return "DW_OP_fbreg";
3570 case DW_OP_bregx:
3571 return "DW_OP_bregx";
3572 case DW_OP_piece:
3573 return "DW_OP_piece";
3574 case DW_OP_deref_size:
3575 return "DW_OP_deref_size";
3576 case DW_OP_xderef_size:
3577 return "DW_OP_xderef_size";
3578 case DW_OP_nop:
3579 return "DW_OP_nop";
3580 default:
3581 return "OP_<unknown>";
3582 }
3583}
3584
3585/* Convert a DWARF type code into its string name. */
3586
3587#if 0
3588static char *
3589dwarf_type_encoding_name (enc)
3590 register unsigned enc;
3591{
3592 switch (enc)
3593 {
3594 case DW_ATE_address:
3595 return "DW_ATE_address";
3596 case DW_ATE_boolean:
3597 return "DW_ATE_boolean";
3598 case DW_ATE_complex_float:
3599 return "DW_ATE_complex_float";
3600 case DW_ATE_float:
3601 return "DW_ATE_float";
3602 case DW_ATE_signed:
3603 return "DW_ATE_signed";
3604 case DW_ATE_signed_char:
3605 return "DW_ATE_signed_char";
3606 case DW_ATE_unsigned:
3607 return "DW_ATE_unsigned";
3608 case DW_ATE_unsigned_char:
3609 return "DW_ATE_unsigned_char";
3610 default:
3611 return "DW_ATE_<unknown>";
3612 }
3613}
3614#endif
3615
3616/* Determine the "ultimate origin" of a decl. The decl may be an inlined
3617 instance of an inlined instance of a decl which is local to an inline
3618 function, so we have to trace all of the way back through the origin chain
3619 to find out what sort of node actually served as the original seed for the
3620 given block. */
3621
3622static tree
3623decl_ultimate_origin (decl)
3624 register tree decl;
3625{
|
3520 register tree immediate_origin = DECL_ABSTRACT_ORIGIN (decl);
|
3626#ifdef ENABLE_CHECKING
3627 if (DECL_FROM_INLINE (DECL_ORIGIN (decl)))
3628 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
3629 most distant ancestor, this should never happen. */
3630 abort ();
3631#endif |
3632
|
3522 if (immediate_origin == NULL_TREE)
3523 return NULL_TREE;
3524 else
3525 {
3526 register tree ret_val;
3527 register tree lookahead = immediate_origin;
3528
3529 do
3530 {
3531 ret_val = lookahead;
3532 lookahead = DECL_ABSTRACT_ORIGIN (ret_val);
3533 }
3534 while (lookahead != NULL && lookahead != ret_val);
3535
3536 return ret_val;
3537 }
|
| 3633 return DECL_ABSTRACT_ORIGIN (decl); |
3634}
3635
3636/* Determine the "ultimate origin" of a block. The block may be an inlined
3637 instance of an inlined instance of a block which is local to an inline
3638 function, so we have to trace all of the way back through the origin chain
3639 to find out what sort of node actually served as the original seed for the
3640 given block. */
3641
3642static tree
3643block_ultimate_origin (block)
3644 register tree block;
3645{
3646 register tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
3647
3648 if (immediate_origin == NULL_TREE)
3649 return NULL_TREE;
3650 else
3651 {
3652 register tree ret_val;
3653 register tree lookahead = immediate_origin;
3654
3655 do
3656 {
3657 ret_val = lookahead;
3658 lookahead = (TREE_CODE (ret_val) == BLOCK)
3659 ? BLOCK_ABSTRACT_ORIGIN (ret_val)
3660 : NULL;
3661 }
3662 while (lookahead != NULL && lookahead != ret_val);
3663
3664 return ret_val;
3665 }
3666}
3667
3668/* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
3669 of a virtual function may refer to a base class, so we check the 'this'
3670 parameter. */
3671
3672static tree
3673decl_class_context (decl)
3674 tree decl;
3675{
3676 tree context = NULL_TREE;
3677
3678 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
3679 context = DECL_CONTEXT (decl);
3680 else
3681 context = TYPE_MAIN_VARIANT
3682 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
3683
3684 if (context && TREE_CODE_CLASS (TREE_CODE (context)) != 't')
3685 context = NULL_TREE;
3686
3687 return context;
3688}
3689
3690/* Add an attribute/value pair to a DIE */
3691
3692static inline void
3693add_dwarf_attr (die, attr)
3694 register dw_die_ref die;
3695 register dw_attr_ref attr;
3696{
3697 if (die != NULL && attr != NULL)
3698 {
3699 if (die->die_attr == NULL)
3700 {
3701 die->die_attr = attr;
3702 die->die_attr_last = attr;
3703 }
3704 else
3705 {
3706 die->die_attr_last->dw_attr_next = attr;
3707 die->die_attr_last = attr;
3708 }
3709 }
3710}
3711
3712/* Add a flag value attribute to a DIE. */
3713
3714static inline void
3715add_AT_flag (die, attr_kind, flag)
3716 register dw_die_ref die;
3717 register enum dwarf_attribute attr_kind;
3718 register unsigned flag;
3719{
3720 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3721
3722 attr->dw_attr_next = NULL;
3723 attr->dw_attr = attr_kind;
3724 attr->dw_attr_val.val_class = dw_val_class_flag;
3725 attr->dw_attr_val.v.val_flag = flag;
3726 add_dwarf_attr (die, attr);
3727}
3728
3729/* Add a signed integer attribute value to a DIE. */
3730
3731static inline void
3732add_AT_int (die, attr_kind, int_val)
3733 register dw_die_ref die;
3734 register enum dwarf_attribute attr_kind;
3735 register long int int_val;
3736{
3737 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3738
3739 attr->dw_attr_next = NULL;
3740 attr->dw_attr = attr_kind;
3741 attr->dw_attr_val.val_class = dw_val_class_const;
3742 attr->dw_attr_val.v.val_int = int_val;
3743 add_dwarf_attr (die, attr);
3744}
3745
3746/* Add an unsigned integer attribute value to a DIE. */
3747
3748static inline void
3749add_AT_unsigned (die, attr_kind, unsigned_val)
3750 register dw_die_ref die;
3751 register enum dwarf_attribute attr_kind;
3752 register unsigned long unsigned_val;
3753{
3754 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3755
3756 attr->dw_attr_next = NULL;
3757 attr->dw_attr = attr_kind;
3758 attr->dw_attr_val.val_class = dw_val_class_unsigned_const;
3759 attr->dw_attr_val.v.val_unsigned = unsigned_val;
3760 add_dwarf_attr (die, attr);
3761}
3762
3763/* Add an unsigned double integer attribute value to a DIE. */
3764
3765static inline void
3766add_AT_long_long (die, attr_kind, val_hi, val_low)
3767 register dw_die_ref die;
3768 register enum dwarf_attribute attr_kind;
3769 register unsigned long val_hi;
3770 register unsigned long val_low;
3771{
3772 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3773
3774 attr->dw_attr_next = NULL;
3775 attr->dw_attr = attr_kind;
3776 attr->dw_attr_val.val_class = dw_val_class_long_long;
3777 attr->dw_attr_val.v.val_long_long.hi = val_hi;
3778 attr->dw_attr_val.v.val_long_long.low = val_low;
3779 add_dwarf_attr (die, attr);
3780}
3781
3782/* Add a floating point attribute value to a DIE and return it. */
3783
3784static inline void
3785add_AT_float (die, attr_kind, length, array)
3786 register dw_die_ref die;
3787 register enum dwarf_attribute attr_kind;
3788 register unsigned length;
3789 register long *array;
3790{
3791 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3792
3793 attr->dw_attr_next = NULL;
3794 attr->dw_attr = attr_kind;
3795 attr->dw_attr_val.val_class = dw_val_class_float;
3796 attr->dw_attr_val.v.val_float.length = length;
3797 attr->dw_attr_val.v.val_float.array = array;
3798 add_dwarf_attr (die, attr);
3799}
3800
3801/* Add a string attribute value to a DIE. */
3802
3803static inline void
3804add_AT_string (die, attr_kind, str)
3805 register dw_die_ref die;
3806 register enum dwarf_attribute attr_kind;
3807 register char *str;
3808{
3809 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3810
3811 attr->dw_attr_next = NULL;
3812 attr->dw_attr = attr_kind;
3813 attr->dw_attr_val.val_class = dw_val_class_str;
3814 attr->dw_attr_val.v.val_str = xstrdup (str);
3815 add_dwarf_attr (die, attr);
3816}
3817
3818/* Add a DIE reference attribute value to a DIE. */
3819
3820static inline void
3821add_AT_die_ref (die, attr_kind, targ_die)
3822 register dw_die_ref die;
3823 register enum dwarf_attribute attr_kind;
3824 register dw_die_ref targ_die;
3825{
3826 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3827
3828 attr->dw_attr_next = NULL;
3829 attr->dw_attr = attr_kind;
3830 attr->dw_attr_val.val_class = dw_val_class_die_ref;
3831 attr->dw_attr_val.v.val_die_ref = targ_die;
3832 add_dwarf_attr (die, attr);
3833}
3834
3835/* Add an FDE reference attribute value to a DIE. */
3836
3837static inline void
3838add_AT_fde_ref (die, attr_kind, targ_fde)
3839 register dw_die_ref die;
3840 register enum dwarf_attribute attr_kind;
3841 register unsigned targ_fde;
3842{
3843 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3844
3845 attr->dw_attr_next = NULL;
3846 attr->dw_attr = attr_kind;
3847 attr->dw_attr_val.val_class = dw_val_class_fde_ref;
3848 attr->dw_attr_val.v.val_fde_index = targ_fde;
3849 add_dwarf_attr (die, attr);
3850}
3851
3852/* Add a location description attribute value to a DIE. */
3853
3854static inline void
3855add_AT_loc (die, attr_kind, loc)
3856 register dw_die_ref die;
3857 register enum dwarf_attribute attr_kind;
3858 register dw_loc_descr_ref loc;
3859{
3860 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3861
3862 attr->dw_attr_next = NULL;
3863 attr->dw_attr = attr_kind;
3864 attr->dw_attr_val.val_class = dw_val_class_loc;
3865 attr->dw_attr_val.v.val_loc = loc;
3866 add_dwarf_attr (die, attr);
3867}
3868
3869/* Add an address constant attribute value to a DIE. */
3870
3871static inline void
3872add_AT_addr (die, attr_kind, addr)
3873 register dw_die_ref die;
3874 register enum dwarf_attribute attr_kind;
3875 char *addr;
3876{
3877 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3878
3879 attr->dw_attr_next = NULL;
3880 attr->dw_attr = attr_kind;
3881 attr->dw_attr_val.val_class = dw_val_class_addr;
3882 attr->dw_attr_val.v.val_addr = addr;
3883 add_dwarf_attr (die, attr);
3884}
3885
3886/* Add a label identifier attribute value to a DIE. */
3887
3888static inline void
3889add_AT_lbl_id (die, attr_kind, lbl_id)
3890 register dw_die_ref die;
3891 register enum dwarf_attribute attr_kind;
3892 register char *lbl_id;
3893{
3894 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3895
3896 attr->dw_attr_next = NULL;
3897 attr->dw_attr = attr_kind;
3898 attr->dw_attr_val.val_class = dw_val_class_lbl_id;
3899 attr->dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
3900 add_dwarf_attr (die, attr);
3901}
3902
3903/* Add a section offset attribute value to a DIE. */
3904
3905static inline void
|
3810add_AT_section_offset (die, attr_kind, section)
|
| 3906add_AT_lbl_offset (die, attr_kind, label) |
3907 register dw_die_ref die;
3908 register enum dwarf_attribute attr_kind;
|
3813 register char *section;
|
| 3909 register char *label; |
3910{
3911 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3912
3913 attr->dw_attr_next = NULL;
3914 attr->dw_attr = attr_kind;
|
3819 attr->dw_attr_val.val_class = dw_val_class_section_offset;
3820 attr->dw_attr_val.v.val_section = section;
|
3915 attr->dw_attr_val.val_class = dw_val_class_lbl_offset;
3916 attr->dw_attr_val.v.val_lbl_id = label; |
3917 add_dwarf_attr (die, attr);
3918
3919}
3920
3921/* Test if die refers to an external subroutine. */
3922
3923static inline int
3924is_extern_subr_die (die)
3925 register dw_die_ref die;
3926{
3927 register dw_attr_ref a;
3928 register int is_subr = FALSE;
3929 register int is_extern = FALSE;
3930
3931 if (die != NULL && die->die_tag == DW_TAG_subprogram)
3932 {
3933 is_subr = TRUE;
3934 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
3935 {
3936 if (a->dw_attr == DW_AT_external
3937 && a->dw_attr_val.val_class == dw_val_class_flag
3938 && a->dw_attr_val.v.val_flag != 0)
3939 {
3940 is_extern = TRUE;
3941 break;
3942 }
3943 }
3944 }
3945
3946 return is_subr && is_extern;
3947}
3948
3949/* Get the attribute of type attr_kind. */
3950
3951static inline dw_attr_ref
3952get_AT (die, attr_kind)
3953 register dw_die_ref die;
3954 register enum dwarf_attribute attr_kind;
3955{
3956 register dw_attr_ref a;
3957 register dw_die_ref spec = NULL;
3958
3959 if (die != NULL)
3960 {
3961 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
3962 {
3963 if (a->dw_attr == attr_kind)
3964 return a;
3965
3966 if (a->dw_attr == DW_AT_specification
3967 || a->dw_attr == DW_AT_abstract_origin)
3968 spec = a->dw_attr_val.v.val_die_ref;
3969 }
3970
3971 if (spec)
3972 return get_AT (spec, attr_kind);
3973 }
3974
3975 return NULL;
3976}
3977
3978/* Return the "low pc" attribute value, typically associated with
3979 a subprogram DIE. Return null if the "low pc" attribute is
3980 either not prsent, or if it cannot be represented as an
3981 assembler label identifier. */
3982
3983static inline char *
3984get_AT_low_pc (die)
3985 register dw_die_ref die;
3986{
3987 register dw_attr_ref a = get_AT (die, DW_AT_low_pc);
3988
3989 if (a && a->dw_attr_val.val_class == dw_val_class_lbl_id)
3990 return a->dw_attr_val.v.val_lbl_id;
3991
3992 return NULL;
3993}
3994
3995/* Return the "high pc" attribute value, typically associated with
3996 a subprogram DIE. Return null if the "high pc" attribute is
3997 either not prsent, or if it cannot be represented as an
3998 assembler label identifier. */
3999
4000static inline char *
4001get_AT_hi_pc (die)
4002 register dw_die_ref die;
4003{
4004 register dw_attr_ref a = get_AT (die, DW_AT_high_pc);
4005
4006 if (a && a->dw_attr_val.val_class == dw_val_class_lbl_id)
4007 return a->dw_attr_val.v.val_lbl_id;
4008
4009 return NULL;
4010}
4011
4012/* Return the value of the string attribute designated by ATTR_KIND, or
4013 NULL if it is not present. */
4014
4015static inline char *
4016get_AT_string (die, attr_kind)
4017 register dw_die_ref die;
4018 register enum dwarf_attribute attr_kind;
4019{
4020 register dw_attr_ref a = get_AT (die, attr_kind);
4021
4022 if (a && a->dw_attr_val.val_class == dw_val_class_str)
4023 return a->dw_attr_val.v.val_str;
4024
4025 return NULL;
4026}
4027
4028/* Return the value of the flag attribute designated by ATTR_KIND, or -1
4029 if it is not present. */
4030
4031static inline int
4032get_AT_flag (die, attr_kind)
4033 register dw_die_ref die;
4034 register enum dwarf_attribute attr_kind;
4035{
4036 register dw_attr_ref a = get_AT (die, attr_kind);
4037
4038 if (a && a->dw_attr_val.val_class == dw_val_class_flag)
4039 return a->dw_attr_val.v.val_flag;
4040
4041 return -1;
4042}
4043
4044/* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
4045 if it is not present. */
4046
4047static inline unsigned
4048get_AT_unsigned (die, attr_kind)
4049 register dw_die_ref die;
4050 register enum dwarf_attribute attr_kind;
4051{
4052 register dw_attr_ref a = get_AT (die, attr_kind);
4053
4054 if (a && a->dw_attr_val.val_class == dw_val_class_unsigned_const)
4055 return a->dw_attr_val.v.val_unsigned;
4056
4057 return 0;
4058}
4059
4060static inline int
4061is_c_family ()
4062{
4063 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
4064
4065 return (lang == DW_LANG_C || lang == DW_LANG_C89
4066 || lang == DW_LANG_C_plus_plus);
4067}
4068
4069static inline int
4070is_fortran ()
4071{
4072 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
4073
4074 return (lang == DW_LANG_Fortran77 || lang == DW_LANG_Fortran90);
4075}
4076
4077/* Remove the specified attribute if present. */
4078
4079static inline void
4080remove_AT (die, attr_kind)
4081 register dw_die_ref die;
4082 register enum dwarf_attribute attr_kind;
4083{
4084 register dw_attr_ref a;
4085 register dw_attr_ref removed = NULL;;
4086
4087 if (die != NULL)
4088 {
4089 if (die->die_attr->dw_attr == attr_kind)
4090 {
4091 removed = die->die_attr;
4092 if (die->die_attr_last == die->die_attr)
4093 die->die_attr_last = NULL;
4094
4095 die->die_attr = die->die_attr->dw_attr_next;
4096 }
4097
4098 else
4099 for (a = die->die_attr; a->dw_attr_next != NULL;
4100 a = a->dw_attr_next)
4101 if (a->dw_attr_next->dw_attr == attr_kind)
4102 {
4103 removed = a->dw_attr_next;
4104 if (die->die_attr_last == a->dw_attr_next)
4105 die->die_attr_last = a;
4106
4107 a->dw_attr_next = a->dw_attr_next->dw_attr_next;
4108 break;
4109 }
4110
4111 if (removed != 0)
4112 free (removed);
4113 }
4114}
4115
4116/* Discard the children of this DIE. */
4117
4118static inline void
4119remove_children (die)
4120 register dw_die_ref die;
4121{
4122 register dw_die_ref child_die = die->die_child;
4123
4124 die->die_child = NULL;
4125 die->die_child_last = NULL;
4126
4127 while (child_die != NULL)
4128 {
4129 register dw_die_ref tmp_die = child_die;
4130 register dw_attr_ref a;
4131
4132 child_die = child_die->die_sib;
4133
4134 for (a = tmp_die->die_attr; a != NULL; )
4135 {
4136 register dw_attr_ref tmp_a = a;
4137
4138 a = a->dw_attr_next;
4139 free (tmp_a);
4140 }
4141
4142 free (tmp_die);
4143 }
4144}
4145
4146/* Add a child DIE below its parent. */
4147
4148static inline void
4149add_child_die (die, child_die)
4150 register dw_die_ref die;
4151 register dw_die_ref child_die;
4152{
4153 if (die != NULL && child_die != NULL)
4154 {
4155 if (die == child_die)
4156 abort ();
4157 child_die->die_parent = die;
4158 child_die->die_sib = NULL;
4159
4160 if (die->die_child == NULL)
4161 {
4162 die->die_child = child_die;
4163 die->die_child_last = child_die;
4164 }
4165 else
4166 {
4167 die->die_child_last->die_sib = child_die;
4168 die->die_child_last = child_die;
4169 }
4170 }
4171}
4172
4173/* Return a pointer to a newly created DIE node. */
4174
4175static inline dw_die_ref
4176new_die (tag_value, parent_die)
4177 register enum dwarf_tag tag_value;
4178 register dw_die_ref parent_die;
4179{
4180 register dw_die_ref die = (dw_die_ref) xmalloc (sizeof (die_node));
4181
4182 die->die_tag = tag_value;
4183 die->die_abbrev = 0;
4184 die->die_offset = 0;
4185 die->die_child = NULL;
4186 die->die_parent = NULL;
4187 die->die_sib = NULL;
4188 die->die_child_last = NULL;
4189 die->die_attr = NULL;
4190 die->die_attr_last = NULL;
4191
4192 if (parent_die != NULL)
4193 add_child_die (parent_die, die);
4194 else
4195 {
4196 limbo_die_node *limbo_node;
4197
4198 limbo_node = (limbo_die_node *) xmalloc (sizeof (limbo_die_node));
4199 limbo_node->die = die;
4200 limbo_node->next = limbo_die_list;
4201 limbo_die_list = limbo_node;
4202 }
4203
4204 return die;
4205}
4206
4207/* Return the DIE associated with the given type specifier. */
4208
4209static inline dw_die_ref
4210lookup_type_die (type)
4211 register tree type;
4212{
4213 return (dw_die_ref) TYPE_SYMTAB_POINTER (type);
4214}
4215
4216/* Equate a DIE to a given type specifier. */
4217
4218static void
4219equate_type_number_to_die (type, type_die)
4220 register tree type;
4221 register dw_die_ref type_die;
4222{
4223 TYPE_SYMTAB_POINTER (type) = (char *) type_die;
4224}
4225
4226/* Return the DIE associated with a given declaration. */
4227
4228static inline dw_die_ref
4229lookup_decl_die (decl)
4230 register tree decl;
4231{
4232 register unsigned decl_id = DECL_UID (decl);
4233
4234 return (decl_id < decl_die_table_in_use
4235 ? decl_die_table[decl_id] : NULL);
4236}
4237
4238/* Equate a DIE to a particular declaration. */
4239
4240static void
4241equate_decl_number_to_die (decl, decl_die)
4242 register tree decl;
4243 register dw_die_ref decl_die;
4244{
4245 register unsigned decl_id = DECL_UID (decl);
4246 register unsigned num_allocated;
4247
4248 if (decl_id >= decl_die_table_allocated)
4249 {
4250 num_allocated
4251 = ((decl_id + 1 + DECL_DIE_TABLE_INCREMENT - 1)
4252 / DECL_DIE_TABLE_INCREMENT)
4253 * DECL_DIE_TABLE_INCREMENT;
4254
4255 decl_die_table
4256 = (dw_die_ref *) xrealloc (decl_die_table,
4257 sizeof (dw_die_ref) * num_allocated);
4258
4259 bzero ((char *) &decl_die_table[decl_die_table_allocated],
4260 (num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref));
4261 decl_die_table_allocated = num_allocated;
4262 }
4263
4264 if (decl_id >= decl_die_table_in_use)
4265 decl_die_table_in_use = (decl_id + 1);
4266
4267 decl_die_table[decl_id] = decl_die;
4268}
4269
4270/* Return a pointer to a newly allocated location description. Location
4271 descriptions are simple expression terms that can be strung
4272 together to form more complicated location (address) descriptions. */
4273
4274static inline dw_loc_descr_ref
4275new_loc_descr (op, oprnd1, oprnd2)
4276 register enum dwarf_location_atom op;
4277 register unsigned long oprnd1;
4278 register unsigned long oprnd2;
4279{
4280 register dw_loc_descr_ref descr
4281 = (dw_loc_descr_ref) xmalloc (sizeof (dw_loc_descr_node));
4282
4283 descr->dw_loc_next = NULL;
4284 descr->dw_loc_opc = op;
4285 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
4286 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
4287 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
4288 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
4289
4290 return descr;
4291}
4292
4293/* Add a location description term to a location description expression. */
4294
4295static inline void
4296add_loc_descr (list_head, descr)
4297 register dw_loc_descr_ref *list_head;
4298 register dw_loc_descr_ref descr;
4299{
4300 register dw_loc_descr_ref *d;
4301
4302 /* Find the end of the chain. */
4303 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
4304 ;
4305
4306 *d = descr;
4307}
4308
4309/* Keep track of the number of spaces used to indent the
4310 output of the debugging routines that print the structure of
4311 the DIE internal representation. */
4312static int print_indent;
4313
4314/* Indent the line the number of spaces given by print_indent. */
4315
4316static inline void
4317print_spaces (outfile)
4318 FILE *outfile;
4319{
4320 fprintf (outfile, "%*s", print_indent, "");
4321}
4322
4323/* Print the information associated with a given DIE, and its children.
4324 This routine is a debugging aid only. */
4325
4326static void
4327print_die (die, outfile)
4328 dw_die_ref die;
4329 FILE *outfile;
4330{
4331 register dw_attr_ref a;
4332 register dw_die_ref c;
4333
4334 print_spaces (outfile);
4335 fprintf (outfile, "DIE %4lu: %s\n",
4336 die->die_offset, dwarf_tag_name (die->die_tag));
4337 print_spaces (outfile);
4338 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
4339 fprintf (outfile, " offset: %lu\n", die->die_offset);
4340
4341 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
4342 {
4343 print_spaces (outfile);
4344 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
4345
4346 switch (a->dw_attr_val.val_class)
4347 {
4348 case dw_val_class_addr:
4349 fprintf (outfile, "address");
4350 break;
4351 case dw_val_class_loc:
4352 fprintf (outfile, "location descriptor");
4353 break;
4354 case dw_val_class_const:
4355 fprintf (outfile, "%ld", a->dw_attr_val.v.val_int);
4356 break;
4357 case dw_val_class_unsigned_const:
4358 fprintf (outfile, "%lu", a->dw_attr_val.v.val_unsigned);
4359 break;
4360 case dw_val_class_long_long:
4361 fprintf (outfile, "constant (%lu,%lu)",
4362 a->dw_attr_val.v.val_long_long.hi,
4363 a->dw_attr_val.v.val_long_long.low);
4364 break;
4365 case dw_val_class_float:
4366 fprintf (outfile, "floating-point constant");
4367 break;
4368 case dw_val_class_flag:
4369 fprintf (outfile, "%u", a->dw_attr_val.v.val_flag);
4370 break;
4371 case dw_val_class_die_ref:
4372 if (a->dw_attr_val.v.val_die_ref != NULL)
4373 fprintf (outfile, "die -> %lu",
4374 a->dw_attr_val.v.val_die_ref->die_offset);
4375 else
4376 fprintf (outfile, "die -> <null>");
4377 break;
4378 case dw_val_class_lbl_id:
|
| 4379 case dw_val_class_lbl_offset: |
4380 fprintf (outfile, "label: %s", a->dw_attr_val.v.val_lbl_id);
4381 break;
|
4285 case dw_val_class_section_offset:
4286 fprintf (outfile, "section: %s", a->dw_attr_val.v.val_section);
4287 break;
|
4382 case dw_val_class_str:
4383 if (a->dw_attr_val.v.val_str != NULL)
4384 fprintf (outfile, "\"%s\"", a->dw_attr_val.v.val_str);
4385 else
4386 fprintf (outfile, "<null>");
4387 break;
4388 default:
4389 break;
4390 }
4391
4392 fprintf (outfile, "\n");
4393 }
4394
4395 if (die->die_child != NULL)
4396 {
4397 print_indent += 4;
4398 for (c = die->die_child; c != NULL; c = c->die_sib)
4399 print_die (c, outfile);
4400
4401 print_indent -= 4;
4402 }
4403}
4404
4405/* Print the contents of the source code line number correspondence table.
4406 This routine is a debugging aid only. */
4407
4408static void
4409print_dwarf_line_table (outfile)
4410 FILE *outfile;
4411{
4412 register unsigned i;
4413 register dw_line_info_ref line_info;
4414
4415 fprintf (outfile, "\n\nDWARF source line information\n");
4416 for (i = 1; i < line_info_table_in_use; ++i)
4417 {
4418 line_info = &line_info_table[i];
4419 fprintf (outfile, "%5d: ", i);
4420 fprintf (outfile, "%-20s", file_table[line_info->dw_file_num]);
4421 fprintf (outfile, "%6ld", line_info->dw_line_num);
4422 fprintf (outfile, "\n");
4423 }
4424
4425 fprintf (outfile, "\n\n");
4426}
4427
4428/* Print the information collected for a given DIE. */
4429
4430void
4431debug_dwarf_die (die)
4432 dw_die_ref die;
4433{
4434 print_die (die, stderr);
4435}
4436
4437/* Print all DWARF information collected for the compilation unit.
4438 This routine is a debugging aid only. */
4439
4440void
4441debug_dwarf ()
4442{
4443 print_indent = 0;
4444 print_die (comp_unit_die, stderr);
4445 print_dwarf_line_table (stderr);
4446}
4447
4448/* Traverse the DIE, and add a sibling attribute if it may have the
4449 effect of speeding up access to siblings. To save some space,
4450 avoid generating sibling attributes for DIE's without children. */
4451
4452static void
4453add_sibling_attributes(die)
4454 register dw_die_ref die;
4455{
4456 register dw_die_ref c;
4457 register dw_attr_ref attr;
4458 if (die != comp_unit_die && die->die_child != NULL)
4459 {
4460 attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
4461 attr->dw_attr_next = NULL;
4462 attr->dw_attr = DW_AT_sibling;
4463 attr->dw_attr_val.val_class = dw_val_class_die_ref;
4464 attr->dw_attr_val.v.val_die_ref = die->die_sib;
4465
4466 /* Add the sibling link to the front of the attribute list. */
4467 attr->dw_attr_next = die->die_attr;
4468 if (die->die_attr == NULL)
4469 die->die_attr_last = attr;
4470
4471 die->die_attr = attr;
4472 }
4473
4474 for (c = die->die_child; c != NULL; c = c->die_sib)
4475 add_sibling_attributes (c);
4476}
4477
4478/* The format of each DIE (and its attribute value pairs)
4479 is encoded in an abbreviation table. This routine builds the
4480 abbreviation table and assigns a unique abbreviation id for
4481 each abbreviation entry. The children of each die are visited
4482 recursively. */
4483
4484static void
4485build_abbrev_table (die)
4486 register dw_die_ref die;
4487{
4488 register unsigned long abbrev_id;
4489 register unsigned long n_alloc;
4490 register dw_die_ref c;
4491 register dw_attr_ref d_attr, a_attr;
4492 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
4493 {
4494 register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
4495
4496 if (abbrev->die_tag == die->die_tag)
4497 {
4498 if ((abbrev->die_child != NULL) == (die->die_child != NULL))
4499 {
4500 a_attr = abbrev->die_attr;
4501 d_attr = die->die_attr;
4502
4503 while (a_attr != NULL && d_attr != NULL)
4504 {
4505 if ((a_attr->dw_attr != d_attr->dw_attr)
4506 || (value_format (&a_attr->dw_attr_val)
4507 != value_format (&d_attr->dw_attr_val)))
4508 break;
4509
4510 a_attr = a_attr->dw_attr_next;
4511 d_attr = d_attr->dw_attr_next;
4512 }
4513
4514 if (a_attr == NULL && d_attr == NULL)
4515 break;
4516 }
4517 }
4518 }
4519
4520 if (abbrev_id >= abbrev_die_table_in_use)
4521 {
4522 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
4523 {
4524 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
4525 abbrev_die_table
4526 = (dw_die_ref *) xrealloc (abbrev_die_table,
4527 sizeof (dw_die_ref) * n_alloc);
4528
4529 bzero ((char *) &abbrev_die_table[abbrev_die_table_allocated],
4530 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
4531 abbrev_die_table_allocated = n_alloc;
4532 }
4533
4534 ++abbrev_die_table_in_use;
4535 abbrev_die_table[abbrev_id] = die;
4536 }
4537
4538 die->die_abbrev = abbrev_id;
4539 for (c = die->die_child; c != NULL; c = c->die_sib)
4540 build_abbrev_table (c);
4541}
4542
4543/* Return the size of a string, including the null byte.
4544
4545 This used to treat backslashes as escapes, and hence they were not included
4546 in the count. However, that conflicts with what ASM_OUTPUT_ASCII does,
4547 which treats a backslash as a backslash, escaping it if necessary, and hence
4548 we must include them in the count. */
4549
4550static unsigned long
4551size_of_string (str)
4552 register char *str;
4553{
4554 return strlen (str) + 1;
4555}
4556
4557/* Return the size of a location descriptor. */
4558
4559static unsigned long
4560size_of_loc_descr (loc)
4561 register dw_loc_descr_ref loc;
4562{
4563 register unsigned long size = 1;
4564
4565 switch (loc->dw_loc_opc)
4566 {
4567 case DW_OP_addr:
4568 size += PTR_SIZE;
4569 break;
4570 case DW_OP_const1u:
4571 case DW_OP_const1s:
4572 size += 1;
4573 break;
4574 case DW_OP_const2u:
4575 case DW_OP_const2s:
4576 size += 2;
4577 break;
4578 case DW_OP_const4u:
4579 case DW_OP_const4s:
4580 size += 4;
4581 break;
4582 case DW_OP_const8u:
4583 case DW_OP_const8s:
4584 size += 8;
4585 break;
4586 case DW_OP_constu:
4587 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4588 break;
4589 case DW_OP_consts:
4590 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4591 break;
4592 case DW_OP_pick:
4593 size += 1;
4594 break;
4595 case DW_OP_plus_uconst:
4596 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4597 break;
4598 case DW_OP_skip:
4599 case DW_OP_bra:
4600 size += 2;
4601 break;
4602 case DW_OP_breg0:
4603 case DW_OP_breg1:
4604 case DW_OP_breg2:
4605 case DW_OP_breg3:
4606 case DW_OP_breg4:
4607 case DW_OP_breg5:
4608 case DW_OP_breg6:
4609 case DW_OP_breg7:
4610 case DW_OP_breg8:
4611 case DW_OP_breg9:
4612 case DW_OP_breg10:
4613 case DW_OP_breg11:
4614 case DW_OP_breg12:
4615 case DW_OP_breg13:
4616 case DW_OP_breg14:
4617 case DW_OP_breg15:
4618 case DW_OP_breg16:
4619 case DW_OP_breg17:
4620 case DW_OP_breg18:
4621 case DW_OP_breg19:
4622 case DW_OP_breg20:
4623 case DW_OP_breg21:
4624 case DW_OP_breg22:
4625 case DW_OP_breg23:
4626 case DW_OP_breg24:
4627 case DW_OP_breg25:
4628 case DW_OP_breg26:
4629 case DW_OP_breg27:
4630 case DW_OP_breg28:
4631 case DW_OP_breg29:
4632 case DW_OP_breg30:
4633 case DW_OP_breg31:
4634 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4635 break;
4636 case DW_OP_regx:
4637 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4638 break;
4639 case DW_OP_fbreg:
4640 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4641 break;
4642 case DW_OP_bregx:
4643 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4644 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
4645 break;
4646 case DW_OP_piece:
4647 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4648 break;
4649 case DW_OP_deref_size:
4650 case DW_OP_xderef_size:
4651 size += 1;
4652 break;
4653 default:
4654 break;
4655 }
4656
4657 return size;
4658}
4659
4660/* Return the size of a series of location descriptors. */
4661
4662static unsigned long
4663size_of_locs (loc)
4664 register dw_loc_descr_ref loc;
4665{
4666 register unsigned long size = 0;
4667
4668 for (; loc != NULL; loc = loc->dw_loc_next)
4669 size += size_of_loc_descr (loc);
4670
4671 return size;
4672}
4673
4674/* Return the power-of-two number of bytes necessary to represent VALUE. */
4675
4676static int
4677constant_size (value)
4678 long unsigned value;
4679{
4680 int log;
4681
4682 if (value == 0)
4683 log = 0;
4684 else
4685 log = floor_log2 (value);
4686
4687 log = log / 8;
4688 log = 1 << (floor_log2 (log) + 1);
4689
4690 return log;
4691}
4692
4693/* Return the size of a DIE, as it is represented in the
4694 .debug_info section. */
4695
4696static unsigned long
4697size_of_die (die)
4698 register dw_die_ref die;
4699{
4700 register unsigned long size = 0;
4701 register dw_attr_ref a;
4702
4703 size += size_of_uleb128 (die->die_abbrev);
4704 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
4705 {
4706 switch (a->dw_attr_val.val_class)
4707 {
4708 case dw_val_class_addr:
4709 size += PTR_SIZE;
4710 break;
4711 case dw_val_class_loc:
4712 {
4713 register unsigned long lsize
4714 = size_of_locs (a->dw_attr_val.v.val_loc);
4715
4716 /* Block length. */
4717 size += constant_size (lsize);
4718 size += lsize;
4719 }
4720 break;
4721 case dw_val_class_const:
4722 size += 4;
4723 break;
4724 case dw_val_class_unsigned_const:
4725 size += constant_size (a->dw_attr_val.v.val_unsigned);
4726 break;
4727 case dw_val_class_long_long:
4728 size += 1 + 8; /* block */
4729 break;
4730 case dw_val_class_float:
4731 size += 1 + a->dw_attr_val.v.val_float.length * 4; /* block */
4732 break;
4733 case dw_val_class_flag:
4734 size += 1;
4735 break;
4736 case dw_val_class_die_ref:
4737 size += DWARF_OFFSET_SIZE;
4738 break;
4739 case dw_val_class_fde_ref:
4740 size += DWARF_OFFSET_SIZE;
4741 break;
4742 case dw_val_class_lbl_id:
4743 size += PTR_SIZE;
4744 break;
|
4651 case dw_val_class_section_offset:
|
| 4745 case dw_val_class_lbl_offset: |
4746 size += DWARF_OFFSET_SIZE;
4747 break;
4748 case dw_val_class_str:
4749 size += size_of_string (a->dw_attr_val.v.val_str);
4750 break;
4751 default:
4752 abort ();
4753 }
4754 }
4755
4756 return size;
4757}
4758
4759/* Size the debugging information associated with a given DIE.
4760 Visits the DIE's children recursively. Updates the global
4761 variable next_die_offset, on each time through. Uses the
4762 current value of next_die_offset to update the die_offset
4763 field in each DIE. */
4764
4765static void
4766calc_die_sizes (die)
4767 dw_die_ref die;
4768{
4769 register dw_die_ref c;
4770 die->die_offset = next_die_offset;
4771 next_die_offset += size_of_die (die);
4772
4773 for (c = die->die_child; c != NULL; c = c->die_sib)
4774 calc_die_sizes (c);
4775
4776 if (die->die_child != NULL)
4777 /* Count the null byte used to terminate sibling lists. */
4778 next_die_offset += 1;
4779}
4780
4781/* Return the size of the line information prolog generated for the
4782 compilation unit. */
4783
4784static unsigned long
4785size_of_line_prolog ()
4786{
4787 register unsigned long size;
4788 register unsigned long ft_index;
4789
4790 size = DWARF_LINE_PROLOG_HEADER_SIZE;
4791
4792 /* Count the size of the table giving number of args for each
4793 standard opcode. */
4794 size += DWARF_LINE_OPCODE_BASE - 1;
4795
4796 /* Include directory table is empty (at present). Count only the
4797 null byte used to terminate the table. */
4798 size += 1;
4799
4800 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
4801 {
4802 /* File name entry. */
4803 size += size_of_string (file_table[ft_index]);
4804
4805 /* Include directory index. */
4806 size += size_of_uleb128 (0);
4807
4808 /* Modification time. */
4809 size += size_of_uleb128 (0);
4810
4811 /* File length in bytes. */
4812 size += size_of_uleb128 (0);
4813 }
4814
4815 /* Count the file table terminator. */
4816 size += 1;
4817 return size;
4818}
4819
4820/* Return the size of the line information generated for this
4821 compilation unit. */
4822
4823static unsigned long
4824size_of_line_info ()
4825{
4826 register unsigned long size;
4827 register unsigned long lt_index;
4828 register unsigned long current_line;
4829 register long line_offset;
4830 register long line_delta;
4831 register unsigned long current_file;
4832 register unsigned long function;
4833 unsigned long size_of_set_address;
4834
4835 /* Size of a DW_LNE_set_address instruction. */
4836 size_of_set_address = 1 + size_of_uleb128 (1 + PTR_SIZE) + 1 + PTR_SIZE;
4837
4838 /* Version number. */
4839 size = 2;
4840
4841 /* Prolog length specifier. */
4842 size += DWARF_OFFSET_SIZE;
4843
4844 /* Prolog. */
4845 size += size_of_line_prolog ();
4846
|
4753 /* Set address register instruction. */
4754 size += size_of_set_address;
4755
|
4847 current_file = 1;
4848 current_line = 1;
4849 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
4850 {
|
4760 register dw_line_info_ref line_info;
|
| 4851 register dw_line_info_ref line_info = &line_info_table[lt_index]; |
4852
|
4853 if (line_info->dw_line_num == current_line
4854 && line_info->dw_file_num == current_file)
4855 continue;
4856 |
4857 /* Advance pc instruction. */
4858 /* ??? See the DW_LNS_advance_pc comment in output_line_info. */
4859 if (0)
4860 size += 1 + 2;
4861 else
4862 size += size_of_set_address;
4863
|
4769 line_info = &line_info_table[lt_index];
|
4864 if (line_info->dw_file_num != current_file)
4865 {
4866 /* Set file number instruction. */
4867 size += 1;
4868 current_file = line_info->dw_file_num;
4869 size += size_of_uleb128 (current_file);
4870 }
4871
4872 if (line_info->dw_line_num != current_line)
4873 {
4874 line_offset = line_info->dw_line_num - current_line;
4875 line_delta = line_offset - DWARF_LINE_BASE;
4876 current_line = line_info->dw_line_num;
4877 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
4878 /* 1-byte special line number instruction. */
4879 size += 1;
4880 else
4881 {
4882 /* Advance line instruction. */
4883 size += 1;
4884 size += size_of_sleb128 (line_offset);
4885 /* Generate line entry instruction. */
4886 size += 1;
4887 }
4888 }
4889 }
4890
4891 /* Advance pc instruction. */
4892 if (0)
4893 size += 1 + 2;
4894 else
4895 size += size_of_set_address;
4896
4897 /* End of line number info. marker. */
4898 size += 1 + size_of_uleb128 (1) + 1;
4899
4900 function = 0;
4901 current_file = 1;
4902 current_line = 1;
4903 for (lt_index = 0; lt_index < separate_line_info_table_in_use; )
4904 {
4905 register dw_separate_line_info_ref line_info
4906 = &separate_line_info_table[lt_index];
|
4907
4908 if (line_info->dw_line_num == current_line
4909 && line_info->dw_file_num == current_file
4910 && line_info->function == function)
4911 goto cont;
4912 |
4913 if (function != line_info->function)
4914 {
4915 function = line_info->function;
4916 /* Set address register instruction. */
4917 size += size_of_set_address;
4918 }
4919 else
4920 {
4921 /* Advance pc instruction. */
4922 if (0)
4923 size += 1 + 2;
4924 else
4925 size += size_of_set_address;
4926 }
4927
4928 if (line_info->dw_file_num != current_file)
4929 {
4930 /* Set file number instruction. */
4931 size += 1;
4932 current_file = line_info->dw_file_num;
4933 size += size_of_uleb128 (current_file);
4934 }
4935
4936 if (line_info->dw_line_num != current_line)
4937 {
4938 line_offset = line_info->dw_line_num - current_line;
4939 line_delta = line_offset - DWARF_LINE_BASE;
4940 current_line = line_info->dw_line_num;
4941 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
4942 /* 1-byte special line number instruction. */
4943 size += 1;
4944 else
4945 {
4946 /* Advance line instruction. */
4947 size += 1;
4948 size += size_of_sleb128 (line_offset);
4949
4950 /* Generate line entry instruction. */
4951 size += 1;
4952 }
4953 }
4954
|
| 4955 cont: |
4956 ++lt_index;
4957
4958 /* If we're done with a function, end its sequence. */
4959 if (lt_index == separate_line_info_table_in_use
4960 || separate_line_info_table[lt_index].function != function)
4961 {
4962 current_file = 1;
4963 current_line = 1;
4964
4965 /* Advance pc instruction. */
4966 if (0)
4967 size += 1 + 2;
4968 else
4969 size += size_of_set_address;
4970
4971 /* End of line number info. marker. */
4972 size += 1 + size_of_uleb128 (1) + 1;
4973 }
4974 }
4975
4976 return size;
4977}
4978
4979/* Return the size of the .debug_pubnames table generated for the
4980 compilation unit. */
4981
4982static unsigned long
4983size_of_pubnames ()
4984{
4985 register unsigned long size;
4986 register unsigned i;
4987
4988 size = DWARF_PUBNAMES_HEADER_SIZE;
4989 for (i = 0; i < pubname_table_in_use; ++i)
4990 {
4991 register pubname_ref p = &pubname_table[i];
4992 size += DWARF_OFFSET_SIZE + size_of_string (p->name);
4993 }
4994
4995 size += DWARF_OFFSET_SIZE;
4996 return size;
4997}
4998
4999/* Return the size of the information in the .debug_aranges section. */
5000
5001static unsigned long
5002size_of_aranges ()
5003{
5004 register unsigned long size;
5005
5006 size = DWARF_ARANGES_HEADER_SIZE;
5007
5008 /* Count the address/length pair for this compilation unit. */
5009 size += 2 * PTR_SIZE;
5010 size += 2 * PTR_SIZE * arange_table_in_use;
5011
5012 /* Count the two zero words used to terminated the address range table. */
5013 size += 2 * PTR_SIZE;
5014 return size;
5015}
5016
5017/* Select the encoding of an attribute value. */
5018
5019static enum dwarf_form
5020value_format (v)
5021 dw_val_ref v;
5022{
5023 switch (v->val_class)
5024 {
5025 case dw_val_class_addr:
5026 return DW_FORM_addr;
5027 case dw_val_class_loc:
5028 switch (constant_size (size_of_locs (v->v.val_loc)))
5029 {
5030 case 1:
5031 return DW_FORM_block1;
5032 case 2:
5033 return DW_FORM_block2;
5034 default:
5035 abort ();
5036 }
5037 case dw_val_class_const:
5038 return DW_FORM_data4;
5039 case dw_val_class_unsigned_const:
5040 switch (constant_size (v->v.val_unsigned))
5041 {
5042 case 1:
5043 return DW_FORM_data1;
5044 case 2:
5045 return DW_FORM_data2;
5046 case 4:
5047 return DW_FORM_data4;
5048 case 8:
5049 return DW_FORM_data8;
5050 default:
5051 abort ();
5052 }
5053 case dw_val_class_long_long:
5054 return DW_FORM_block1;
5055 case dw_val_class_float:
5056 return DW_FORM_block1;
5057 case dw_val_class_flag:
5058 return DW_FORM_flag;
5059 case dw_val_class_die_ref:
5060 return DW_FORM_ref;
5061 case dw_val_class_fde_ref:
5062 return DW_FORM_data;
5063 case dw_val_class_lbl_id:
5064 return DW_FORM_addr;
|
4964 case dw_val_class_section_offset:
|
| 5065 case dw_val_class_lbl_offset: |
5066 return DW_FORM_data;
5067 case dw_val_class_str:
5068 return DW_FORM_string;
5069 default:
5070 abort ();
5071 }
5072}
5073
5074/* Output the encoding of an attribute value. */
5075
5076static void
5077output_value_format (v)
5078 dw_val_ref v;
5079{
5080 enum dwarf_form form = value_format (v);
5081
5082 output_uleb128 (form);
5083 if (flag_debug_asm)
5084 fprintf (asm_out_file, " (%s)", dwarf_form_name (form));
5085
5086 fputc ('\n', asm_out_file);
5087}
5088
5089/* Output the .debug_abbrev section which defines the DIE abbreviation
5090 table. */
5091
5092static void
5093output_abbrev_section ()
5094{
5095 unsigned long abbrev_id;
5096
5097 dw_attr_ref a_attr;
5098 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
5099 {
5100 register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
5101
5102 output_uleb128 (abbrev_id);
5103 if (flag_debug_asm)
5104 fprintf (asm_out_file, " (abbrev code)");
5105
5106 fputc ('\n', asm_out_file);
5107 output_uleb128 (abbrev->die_tag);
5108 if (flag_debug_asm)
5109 fprintf (asm_out_file, " (TAG: %s)",
5110 dwarf_tag_name (abbrev->die_tag));
5111
5112 fputc ('\n', asm_out_file);
5113 fprintf (asm_out_file, "\t%s\t0x%x", ASM_BYTE_OP,
5114 abbrev->die_child != NULL ? DW_children_yes : DW_children_no);
5115
5116 if (flag_debug_asm)
5117 fprintf (asm_out_file, "\t%s %s",
5118 ASM_COMMENT_START,
5119 (abbrev->die_child != NULL
5120 ? "DW_children_yes" : "DW_children_no"));
5121
5122 fputc ('\n', asm_out_file);
5123
5124 for (a_attr = abbrev->die_attr; a_attr != NULL;
5125 a_attr = a_attr->dw_attr_next)
5126 {
5127 output_uleb128 (a_attr->dw_attr);
5128 if (flag_debug_asm)
5129 fprintf (asm_out_file, " (%s)",
5130 dwarf_attr_name (a_attr->dw_attr));
5131
5132 fputc ('\n', asm_out_file);
5133 output_value_format (&a_attr->dw_attr_val);
5134 }
5135
5136 fprintf (asm_out_file, "\t%s\t0,0\n", ASM_BYTE_OP);
5137 }
|
5138
5139 /* We need to properly terminate the abbrev table for this
5140 compilation unit, as per the standard, and not rely on
5141 workarounds in e.g. gdb. */
5142 fprintf (asm_out_file, "\t%s\t0\n", ASM_BYTE_OP); |
5143}
5144
5145/* Output location description stack opcode's operands (if any). */
5146
5147static void
5148output_loc_operands (loc)
5149 register dw_loc_descr_ref loc;
5150{
5151 register dw_val_ref val1 = &loc->dw_loc_oprnd1;
5152 register dw_val_ref val2 = &loc->dw_loc_oprnd2;
5153
5154 switch (loc->dw_loc_opc)
5155 {
5156 case DW_OP_addr:
5157 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, val1->v.val_addr);
5158 fputc ('\n', asm_out_file);
5159 break;
5160 case DW_OP_const1u:
5161 case DW_OP_const1s:
5162 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
5163 fputc ('\n', asm_out_file);
5164 break;
5165 case DW_OP_const2u:
5166 case DW_OP_const2s:
5167 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
5168 fputc ('\n', asm_out_file);
5169 break;
5170 case DW_OP_const4u:
5171 case DW_OP_const4s:
5172 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, val1->v.val_int);
5173 fputc ('\n', asm_out_file);
5174 break;
5175 case DW_OP_const8u:
5176 case DW_OP_const8s:
5177 abort ();
5178 fputc ('\n', asm_out_file);
5179 break;
5180 case DW_OP_constu:
5181 output_uleb128 (val1->v.val_unsigned);
5182 fputc ('\n', asm_out_file);
5183 break;
5184 case DW_OP_consts:
5185 output_sleb128 (val1->v.val_int);
5186 fputc ('\n', asm_out_file);
5187 break;
5188 case DW_OP_pick:
5189 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_int);
5190 fputc ('\n', asm_out_file);
5191 break;
5192 case DW_OP_plus_uconst:
5193 output_uleb128 (val1->v.val_unsigned);
5194 fputc ('\n', asm_out_file);
5195 break;
5196 case DW_OP_skip:
5197 case DW_OP_bra:
5198 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
5199 fputc ('\n', asm_out_file);
5200 break;
5201 case DW_OP_breg0:
5202 case DW_OP_breg1:
5203 case DW_OP_breg2:
5204 case DW_OP_breg3:
5205 case DW_OP_breg4:
5206 case DW_OP_breg5:
5207 case DW_OP_breg6:
5208 case DW_OP_breg7:
5209 case DW_OP_breg8:
5210 case DW_OP_breg9:
5211 case DW_OP_breg10:
5212 case DW_OP_breg11:
5213 case DW_OP_breg12:
5214 case DW_OP_breg13:
5215 case DW_OP_breg14:
5216 case DW_OP_breg15:
5217 case DW_OP_breg16:
5218 case DW_OP_breg17:
5219 case DW_OP_breg18:
5220 case DW_OP_breg19:
5221 case DW_OP_breg20:
5222 case DW_OP_breg21:
5223 case DW_OP_breg22:
5224 case DW_OP_breg23:
5225 case DW_OP_breg24:
5226 case DW_OP_breg25:
5227 case DW_OP_breg26:
5228 case DW_OP_breg27:
5229 case DW_OP_breg28:
5230 case DW_OP_breg29:
5231 case DW_OP_breg30:
5232 case DW_OP_breg31:
5233 output_sleb128 (val1->v.val_int);
5234 fputc ('\n', asm_out_file);
5235 break;
5236 case DW_OP_regx:
5237 output_uleb128 (val1->v.val_unsigned);
5238 fputc ('\n', asm_out_file);
5239 break;
5240 case DW_OP_fbreg:
5241 output_sleb128 (val1->v.val_int);
5242 fputc ('\n', asm_out_file);
5243 break;
5244 case DW_OP_bregx:
5245 output_uleb128 (val1->v.val_unsigned);
5246 fputc ('\n', asm_out_file);
5247 output_sleb128 (val2->v.val_int);
5248 fputc ('\n', asm_out_file);
5249 break;
5250 case DW_OP_piece:
5251 output_uleb128 (val1->v.val_unsigned);
5252 fputc ('\n', asm_out_file);
5253 break;
5254 case DW_OP_deref_size:
5255 case DW_OP_xderef_size:
5256 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
5257 fputc ('\n', asm_out_file);
5258 break;
5259 default:
5260 break;
5261 }
5262}
5263
5264/* Compute the offset of a sibling. */
5265
5266static unsigned long
5267sibling_offset (die)
5268 dw_die_ref die;
5269{
5270 unsigned long offset;
5271
5272 if (die->die_child_last == NULL)
5273 offset = die->die_offset + size_of_die (die);
5274 else
5275 offset = sibling_offset (die->die_child_last) + 1;
5276
5277 return offset;
5278}
5279
5280/* Output the DIE and its attributes. Called recursively to generate
5281 the definitions of each child DIE. */
5282
5283static void
5284output_die (die)
5285 register dw_die_ref die;
5286{
5287 register dw_attr_ref a;
5288 register dw_die_ref c;
5289 register unsigned long ref_offset;
5290 register unsigned long size;
5291 register dw_loc_descr_ref loc;
|
5186 register int i;
|
5292
5293 output_uleb128 (die->die_abbrev);
5294 if (flag_debug_asm)
5295 fprintf (asm_out_file, " (DIE (0x%lx) %s)",
5296 die->die_offset, dwarf_tag_name (die->die_tag));
5297
5298 fputc ('\n', asm_out_file);
5299
5300 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5301 {
5302 switch (a->dw_attr_val.val_class)
5303 {
5304 case dw_val_class_addr:
5305 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file,
5306 a->dw_attr_val.v.val_addr);
5307 break;
5308
5309 case dw_val_class_loc:
5310 size = size_of_locs (a->dw_attr_val.v.val_loc);
5311
5312 /* Output the block length for this list of location operations. */
5313 switch (constant_size (size))
5314 {
5315 case 1:
5316 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, size);
5317 break;
5318 case 2:
5319 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, size);
5320 break;
5321 default:
5322 abort ();
5323 }
5324
5325 if (flag_debug_asm)
5326 fprintf (asm_out_file, "\t%s %s",
5327 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5328
5329 fputc ('\n', asm_out_file);
5330 for (loc = a->dw_attr_val.v.val_loc; loc != NULL;
5331 loc = loc->dw_loc_next)
5332 {
5333 /* Output the opcode. */
5334 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, loc->dw_loc_opc);
5335 if (flag_debug_asm)
5336 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START,
5337 dwarf_stack_op_name (loc->dw_loc_opc));
5338
5339 fputc ('\n', asm_out_file);
5340
5341 /* Output the operand(s) (if any). */
5342 output_loc_operands (loc);
5343 }
5344 break;
5345
5346 case dw_val_class_const:
5347 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, a->dw_attr_val.v.val_int);
5348 break;
5349
5350 case dw_val_class_unsigned_const:
5351 switch (constant_size (a->dw_attr_val.v.val_unsigned))
5352 {
5353 case 1:
5354 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5355 a->dw_attr_val.v.val_unsigned);
5356 break;
5357 case 2:
5358 ASM_OUTPUT_DWARF_DATA2 (asm_out_file,
5359 a->dw_attr_val.v.val_unsigned);
5360 break;
5361 case 4:
5362 ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
5363 a->dw_attr_val.v.val_unsigned);
5364 break;
5365 case 8:
5366 ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
5367 a->dw_attr_val.v.val_long_long.hi,
5368 a->dw_attr_val.v.val_long_long.low);
5369 break;
5370 default:
5371 abort ();
5372 }
5373 break;
5374
5375 case dw_val_class_long_long:
5376 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 8);
5377 if (flag_debug_asm)
5378 fprintf (asm_out_file, "\t%s %s",
5379 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5380
5381 fputc ('\n', asm_out_file);
5382 ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
5383 a->dw_attr_val.v.val_long_long.hi,
5384 a->dw_attr_val.v.val_long_long.low);
5385
5386 if (flag_debug_asm)
5387 fprintf (asm_out_file,
5388 "\t%s long long constant", ASM_COMMENT_START);
5389
5390 fputc ('\n', asm_out_file);
5391 break;
5392
5393 case dw_val_class_float:
|
5289 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5290 a->dw_attr_val.v.val_float.length * 4);
5291 if (flag_debug_asm)
5292 fprintf (asm_out_file, "\t%s %s",
5293 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
|
5394 {
5395 register unsigned int i;
5396 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5397 a->dw_attr_val.v.val_float.length * 4);
5398 if (flag_debug_asm)
5399 fprintf (asm_out_file, "\t%s %s",
5400 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr)); |
5401
|
5295 fputc ('\n', asm_out_file);
5296 for (i = 0; i < a->dw_attr_val.v.val_float.length; ++i)
5297 {
5298 ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
5299 a->dw_attr_val.v.val_float.array[i]);
5300 if (flag_debug_asm)
5301 fprintf (asm_out_file, "\t%s fp constant word %d",
5302 ASM_COMMENT_START, i);
|
5402 fputc ('\n', asm_out_file);
5403 for (i = 0; i < a->dw_attr_val.v.val_float.length; ++i)
5404 {
5405 ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
5406 a->dw_attr_val.v.val_float.array[i]);
5407 if (flag_debug_asm)
5408 fprintf (asm_out_file, "\t%s fp constant word %u",
5409 ASM_COMMENT_START, i); |
5410
|
5304 fputc ('\n', asm_out_file);
5305 }
|
5411 fputc ('\n', asm_out_file);
5412 } |
5413 break;
|
| 5414 } |
5415
5416 case dw_val_class_flag:
5417 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, a->dw_attr_val.v.val_flag);
5418 break;
5419
5420 case dw_val_class_die_ref:
5421 if (a->dw_attr_val.v.val_die_ref != NULL)
5422 ref_offset = a->dw_attr_val.v.val_die_ref->die_offset;
5423 else if (a->dw_attr == DW_AT_sibling)
5424 ref_offset = sibling_offset(die);
5425 else
5426 abort ();
5427
5428 ASM_OUTPUT_DWARF_DATA (asm_out_file, ref_offset);
5429 break;
5430
5431 case dw_val_class_fde_ref:
5432 {
5433 char l1[20];
5434 ASM_GENERATE_INTERNAL_LABEL
5435 (l1, FDE_AFTER_SIZE_LABEL, a->dw_attr_val.v.val_fde_index * 2);
5436 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, l1);
5437 fprintf (asm_out_file, " - %d", DWARF_OFFSET_SIZE);
5438 }
5439 break;
5440
5441 case dw_val_class_lbl_id:
5442 ASM_OUTPUT_DWARF_ADDR (asm_out_file, a->dw_attr_val.v.val_lbl_id);
5443 break;
5444
|
5337 case dw_val_class_section_offset:
5338 ASM_OUTPUT_DWARF_OFFSET (asm_out_file,
5339 stripattributes
5340 (a->dw_attr_val.v.val_section));
|
5445 case dw_val_class_lbl_offset:
5446 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, a->dw_attr_val.v.val_lbl_id); |
5447 break;
5448
5449 case dw_val_class_str:
5450 if (flag_debug_asm)
5451 ASM_OUTPUT_DWARF_STRING (asm_out_file, a->dw_attr_val.v.val_str);
5452 else
5453 ASM_OUTPUT_ASCII (asm_out_file,
5454 a->dw_attr_val.v.val_str,
|
5349 strlen (a->dw_attr_val.v.val_str) + 1);
|
| 5455 (int) strlen (a->dw_attr_val.v.val_str) + 1); |
5456 break;
5457
5458 default:
5459 abort ();
5460 }
5461
5462 if (a->dw_attr_val.val_class != dw_val_class_loc
5463 && a->dw_attr_val.val_class != dw_val_class_long_long
5464 && a->dw_attr_val.val_class != dw_val_class_float)
5465 {
5466 if (flag_debug_asm)
5467 fprintf (asm_out_file, "\t%s %s",
5468 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5469
5470 fputc ('\n', asm_out_file);
5471 }
5472 }
5473
5474 for (c = die->die_child; c != NULL; c = c->die_sib)
5475 output_die (c);
5476
5477 if (die->die_child != NULL)
5478 {
5479 /* Add null byte to terminate sibling list. */
5480 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5481 if (flag_debug_asm)
5482 fprintf (asm_out_file, "\t%s end of children of DIE 0x%lx",
5483 ASM_COMMENT_START, die->die_offset);
5484
5485 fputc ('\n', asm_out_file);
5486 }
5487}
5488
5489/* Output the compilation unit that appears at the beginning of the
5490 .debug_info section, and precedes the DIE descriptions. */
5491
5492static void
5493output_compilation_unit_header ()
5494{
5495 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset - DWARF_OFFSET_SIZE);
5496 if (flag_debug_asm)
5497 fprintf (asm_out_file, "\t%s Length of Compilation Unit Info.",
5498 ASM_COMMENT_START);
5499
5500 fputc ('\n', asm_out_file);
5501 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5502 if (flag_debug_asm)
5503 fprintf (asm_out_file, "\t%s DWARF version number", ASM_COMMENT_START);
5504
5505 fputc ('\n', asm_out_file);
|
5400 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (ABBREV_SECTION));
|
| 5506 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, abbrev_section_label); |
5507 if (flag_debug_asm)
5508 fprintf (asm_out_file, "\t%s Offset Into Abbrev. Section",
5509 ASM_COMMENT_START);
5510
5511 fputc ('\n', asm_out_file);
5512 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
5513 if (flag_debug_asm)
5514 fprintf (asm_out_file, "\t%s Pointer Size (in bytes)", ASM_COMMENT_START);
5515
5516 fputc ('\n', asm_out_file);
5517}
5518
5519/* The DWARF2 pubname for a nested thingy looks like "A::f". The output
5520 of decl_printable_name for C++ looks like "A::f(int)". Let's drop the
5521 argument list, and maybe the scope. */
5522
5523static char *
5524dwarf2_name (decl, scope)
5525 tree decl;
5526 int scope;
5527{
5528 return (*decl_printable_name) (decl, scope ? 1 : 0);
5529}
5530
5531/* Add a new entry to .debug_pubnames if appropriate. */
5532
5533static void
5534add_pubname (decl, die)
5535 tree decl;
5536 dw_die_ref die;
5537{
5538 pubname_ref p;
5539
5540 if (! TREE_PUBLIC (decl))
5541 return;
5542
5543 if (pubname_table_in_use == pubname_table_allocated)
5544 {
5545 pubname_table_allocated += PUBNAME_TABLE_INCREMENT;
5546 pubname_table = (pubname_ref) xrealloc
5547 (pubname_table, pubname_table_allocated * sizeof (pubname_entry));
5548 }
5549
5550 p = &pubname_table[pubname_table_in_use++];
5551 p->die = die;
5552
5553 p->name = xstrdup (dwarf2_name (decl, 1));
5554}
5555
5556/* Output the public names table used to speed up access to externally
5557 visible names. For now, only generate entries for externally
5558 visible procedures. */
5559
5560static void
5561output_pubnames ()
5562{
5563 register unsigned i;
5564 register unsigned long pubnames_length = size_of_pubnames ();
5565
5566 ASM_OUTPUT_DWARF_DATA (asm_out_file, pubnames_length);
5567
5568 if (flag_debug_asm)
5569 fprintf (asm_out_file, "\t%s Length of Public Names Info.",
5570 ASM_COMMENT_START);
5571
5572 fputc ('\n', asm_out_file);
5573 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5574
5575 if (flag_debug_asm)
5576 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5577
5578 fputc ('\n', asm_out_file);
|
5473 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (DEBUG_INFO_SECTION));
|
| 5579 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, debug_info_section_label); |
5580 if (flag_debug_asm)
5581 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
5582 ASM_COMMENT_START);
5583
5584 fputc ('\n', asm_out_file);
5585 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset);
5586 if (flag_debug_asm)
5587 fprintf (asm_out_file, "\t%s Compilation Unit Length", ASM_COMMENT_START);
5588
5589 fputc ('\n', asm_out_file);
5590 for (i = 0; i < pubname_table_in_use; ++i)
5591 {
5592 register pubname_ref pub = &pubname_table[i];
5593
5594 ASM_OUTPUT_DWARF_DATA (asm_out_file, pub->die->die_offset);
5595 if (flag_debug_asm)
5596 fprintf (asm_out_file, "\t%s DIE offset", ASM_COMMENT_START);
5597
5598 fputc ('\n', asm_out_file);
5599
5600 if (flag_debug_asm)
5601 {
5602 ASM_OUTPUT_DWARF_STRING (asm_out_file, pub->name);
5603 fprintf (asm_out_file, "%s external name", ASM_COMMENT_START);
5604 }
5605 else
5606 {
|
5501 ASM_OUTPUT_ASCII (asm_out_file, pub->name, strlen (pub->name) + 1);
|
5607 ASM_OUTPUT_ASCII (asm_out_file, pub->name,
5608 (int) strlen (pub->name) + 1); |
5609 }
5610
5611 fputc ('\n', asm_out_file);
5612 }
5613
5614 ASM_OUTPUT_DWARF_DATA (asm_out_file, 0);
5615 fputc ('\n', asm_out_file);
5616}
5617
5618/* Add a new entry to .debug_aranges if appropriate. */
5619
5620static void
5621add_arange (decl, die)
5622 tree decl;
5623 dw_die_ref die;
5624{
5625 if (! DECL_SECTION_NAME (decl))
5626 return;
5627
5628 if (arange_table_in_use == arange_table_allocated)
5629 {
5630 arange_table_allocated += ARANGE_TABLE_INCREMENT;
5631 arange_table
5632 = (arange_ref) xrealloc (arange_table,
5633 arange_table_allocated * sizeof (dw_die_ref));
5634 }
5635
5636 arange_table[arange_table_in_use++] = die;
5637}
5638
5639/* Output the information that goes into the .debug_aranges table.
5640 Namely, define the beginning and ending address range of the
5641 text section generated for this compilation unit. */
5642
5643static void
5644output_aranges ()
5645{
5646 register unsigned i;
5647 register unsigned long aranges_length = size_of_aranges ();
5648
5649 ASM_OUTPUT_DWARF_DATA (asm_out_file, aranges_length);
5650 if (flag_debug_asm)
5651 fprintf (asm_out_file, "\t%s Length of Address Ranges Info.",
5652 ASM_COMMENT_START);
5653
5654 fputc ('\n', asm_out_file);
5655 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5656 if (flag_debug_asm)
5657 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5658
5659 fputc ('\n', asm_out_file);
|
5553 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (DEBUG_INFO_SECTION));
|
| 5660 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, debug_info_section_label); |
5661 if (flag_debug_asm)
5662 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
5663 ASM_COMMENT_START);
5664
5665 fputc ('\n', asm_out_file);
5666 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
5667 if (flag_debug_asm)
5668 fprintf (asm_out_file, "\t%s Size of Address", ASM_COMMENT_START);
5669
5670 fputc ('\n', asm_out_file);
5671 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5672 if (flag_debug_asm)
5673 fprintf (asm_out_file, "\t%s Size of Segment Descriptor",
5674 ASM_COMMENT_START);
5675
5676 fputc ('\n', asm_out_file);
5677 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 4);
5678 if (PTR_SIZE == 8)
5679 fprintf (asm_out_file, ",0,0");
5680
5681 if (flag_debug_asm)
5682 fprintf (asm_out_file, "\t%s Pad to %d byte boundary",
5683 ASM_COMMENT_START, 2 * PTR_SIZE);
5684
5685 fputc ('\n', asm_out_file);
|
5579 ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_SECTION);
|
| 5686 ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_section_label); |
5687 if (flag_debug_asm)
5688 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
5689
5690 fputc ('\n', asm_out_file);
|
5584 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, text_end_label, TEXT_SECTION);
|
5691 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, text_end_label,
5692 text_section_label); |
5693 if (flag_debug_asm)
5694 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
5695
5696 fputc ('\n', asm_out_file);
5697 for (i = 0; i < arange_table_in_use; ++i)
5698 {
5699 dw_die_ref a = arange_table[i];
5700
5701 if (a->die_tag == DW_TAG_subprogram)
5702 ASM_OUTPUT_DWARF_ADDR (asm_out_file, get_AT_low_pc (a));
5703 else
5704 {
5705 char *name = get_AT_string (a, DW_AT_MIPS_linkage_name);
5706 if (! name)
5707 name = get_AT_string (a, DW_AT_name);
5708
5709 ASM_OUTPUT_DWARF_ADDR (asm_out_file, name);
5710 }
5711
5712 if (flag_debug_asm)
5713 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
5714
5715 fputc ('\n', asm_out_file);
5716 if (a->die_tag == DW_TAG_subprogram)
5717 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, get_AT_hi_pc (a),
5718 get_AT_low_pc (a));
5719 else
5720 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file,
5721 get_AT_unsigned (a, DW_AT_byte_size));
5722
5723 if (flag_debug_asm)
5724 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
5725
5726 fputc ('\n', asm_out_file);
5727 }
5728
5729 /* Output the terminator words. */
5730 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
5731 fputc ('\n', asm_out_file);
5732 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
5733 fputc ('\n', asm_out_file);
5734}
5735
5736/* Output the source line number correspondence information. This
5737 information goes into the .debug_line section.
5738
5739 If the format of this data changes, then the function size_of_line_info
5740 must also be adjusted the same way. */
5741
5742static void
5743output_line_info ()
5744{
5745 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
5746 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
5747 register unsigned opc;
5748 register unsigned n_op_args;
5749 register unsigned long ft_index;
5750 register unsigned long lt_index;
5751 register unsigned long current_line;
5752 register long line_offset;
5753 register long line_delta;
5754 register unsigned long current_file;
5755 register unsigned long function;
5756
5757 ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_info ());
5758 if (flag_debug_asm)
5759 fprintf (asm_out_file, "\t%s Length of Source Line Info.",
5760 ASM_COMMENT_START);
5761
5762 fputc ('\n', asm_out_file);
5763 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5764 if (flag_debug_asm)
5765 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5766
5767 fputc ('\n', asm_out_file);
5768 ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_prolog ());
5769 if (flag_debug_asm)
5770 fprintf (asm_out_file, "\t%s Prolog Length", ASM_COMMENT_START);
5771
5772 fputc ('\n', asm_out_file);
5773 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_MIN_INSTR_LENGTH);
5774 if (flag_debug_asm)
5775 fprintf (asm_out_file, "\t%s Minimum Instruction Length",
5776 ASM_COMMENT_START);
5777
5778 fputc ('\n', asm_out_file);
5779 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_DEFAULT_IS_STMT_START);
5780 if (flag_debug_asm)
5781 fprintf (asm_out_file, "\t%s Default is_stmt_start flag",
5782 ASM_COMMENT_START);
5783
5784 fputc ('\n', asm_out_file);
5785 fprintf (asm_out_file, "\t%s\t%d", ASM_BYTE_OP, DWARF_LINE_BASE);
5786 if (flag_debug_asm)
5787 fprintf (asm_out_file, "\t%s Line Base Value (Special Opcodes)",
5788 ASM_COMMENT_START);
5789
5790 fputc ('\n', asm_out_file);
5791 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_RANGE);
5792 if (flag_debug_asm)
5793 fprintf (asm_out_file, "\t%s Line Range Value (Special Opcodes)",
5794 ASM_COMMENT_START);
5795
5796 fputc ('\n', asm_out_file);
5797 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_OPCODE_BASE);
5798 if (flag_debug_asm)
5799 fprintf (asm_out_file, "\t%s Special Opcode Base", ASM_COMMENT_START);
5800
5801 fputc ('\n', asm_out_file);
5802 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; ++opc)
5803 {
5804 switch (opc)
5805 {
5806 case DW_LNS_advance_pc:
5807 case DW_LNS_advance_line:
5808 case DW_LNS_set_file:
5809 case DW_LNS_set_column:
5810 case DW_LNS_fixed_advance_pc:
5811 n_op_args = 1;
5812 break;
5813 default:
5814 n_op_args = 0;
5815 break;
5816 }
5817 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, n_op_args);
5818 if (flag_debug_asm)
5819 fprintf (asm_out_file, "\t%s opcode: 0x%x has %d args",
5820 ASM_COMMENT_START, opc, n_op_args);
5821 fputc ('\n', asm_out_file);
5822 }
5823
5824 if (flag_debug_asm)
5825 fprintf (asm_out_file, "%s Include Directory Table\n", ASM_COMMENT_START);
5826
5827 /* Include directory table is empty, at present */
5828 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5829 fputc ('\n', asm_out_file);
5830 if (flag_debug_asm)
5831 fprintf (asm_out_file, "%s File Name Table\n", ASM_COMMENT_START);
5832
5833 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
5834 {
5835 if (flag_debug_asm)
5836 {
5837 ASM_OUTPUT_DWARF_STRING (asm_out_file, file_table[ft_index]);
5838 fprintf (asm_out_file, "%s File Entry: 0x%lx",
5839 ASM_COMMENT_START, ft_index);
5840 }
5841 else
5842 {
5843 ASM_OUTPUT_ASCII (asm_out_file,
5844 file_table[ft_index],
|
5737 strlen (file_table[ft_index]) + 1);
|
| 5845 (int) strlen (file_table[ft_index]) + 1); |
5846 }
5847
5848 fputc ('\n', asm_out_file);
5849
5850 /* Include directory index */
5851 output_uleb128 (0);
5852 fputc ('\n', asm_out_file);
5853
5854 /* Modification time */
5855 output_uleb128 (0);
5856 fputc ('\n', asm_out_file);
5857
5858 /* File length in bytes */
5859 output_uleb128 (0);
5860 fputc ('\n', asm_out_file);
5861 }
5862
5863 /* Terminate the file name table */
5864 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5865 fputc ('\n', asm_out_file);
5866
|
5759 /* Set the address register to the first location in the text section */
5760 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5761 if (flag_debug_asm)
5762 fprintf (asm_out_file, "\t%s DW_LNE_set_address", ASM_COMMENT_START);
|
5867 /* We used to set the address register to the first location in the text
5868 section here, but that didn't accomplish anything since we already
5869 have a line note for the opening brace of the first function. */ |
5870
|
5764 fputc ('\n', asm_out_file);
5765 output_uleb128 (1 + PTR_SIZE);
5766 fputc ('\n', asm_out_file);
5767 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5768 fputc ('\n', asm_out_file);
5769 ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_SECTION);
5770 fputc ('\n', asm_out_file);
5771
|
5871 /* Generate the line number to PC correspondence table, encoded as
5872 a series of state machine operations. */
5873 current_file = 1;
5874 current_line = 1;
|
5776 strcpy (prev_line_label, TEXT_SECTION);
|
| 5875 strcpy (prev_line_label, text_section_label); |
5876 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
5877 {
|
5779 register dw_line_info_ref line_info;
|
| 5878 register dw_line_info_ref line_info = &line_info_table[lt_index]; |
5879
|
5880 /* Don't emit anything for redundant notes. Just updating the
5881 address doesn't accomplish anything, because we already assume
5882 that anything after the last address is this line. */
5883 if (line_info->dw_line_num == current_line
5884 && line_info->dw_file_num == current_file)
5885 continue;
5886 |
5887 /* Emit debug info for the address of the current line, choosing
5888 the encoding that uses the least amount of space. */
5889 /* ??? Unfortunately, we have little choice here currently, and must
5890 always use the most general form. Gcc does not know the address
5891 delta itself, so we can't use DW_LNS_advance_pc. There are no known
5892 dwarf2 aware assemblers at this time, so we can't use any special
5893 pseudo ops that would allow the assembler to optimally encode this for
5894 us. Many ports do have length attributes which will give an upper
5895 bound on the address range. We could perhaps use length attributes
5896 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
5897 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
5898 if (0)
5899 {
5900 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
5901 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5902 if (flag_debug_asm)
5903 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5904 ASM_COMMENT_START);
5905
5906 fputc ('\n', asm_out_file);
5907 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, prev_line_label);
5908 fputc ('\n', asm_out_file);
5909 }
5910 else
5911 {
5912 /* This can handle any delta. This takes 4+PTR_SIZE bytes. */
5913 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5914 if (flag_debug_asm)
5915 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
5916 ASM_COMMENT_START);
5917 fputc ('\n', asm_out_file);
5918 output_uleb128 (1 + PTR_SIZE);
5919 fputc ('\n', asm_out_file);
5920 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5921 fputc ('\n', asm_out_file);
5922 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
5923 fputc ('\n', asm_out_file);
5924 }
5925 strcpy (prev_line_label, line_label);
5926
5927 /* Emit debug info for the source file of the current line, if
5928 different from the previous line. */
|
5823 line_info = &line_info_table[lt_index];
|
5929 if (line_info->dw_file_num != current_file)
5930 {
5931 current_file = line_info->dw_file_num;
5932 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
5933 if (flag_debug_asm)
5934 fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START);
5935
5936 fputc ('\n', asm_out_file);
5937 output_uleb128 (current_file);
5938 if (flag_debug_asm)
5939 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
5940
5941 fputc ('\n', asm_out_file);
5942 }
5943
5944 /* Emit debug info for the current line number, choosing the encoding
5945 that uses the least amount of space. */
|
5841 line_offset = line_info->dw_line_num - current_line;
5842 line_delta = line_offset - DWARF_LINE_BASE;
5843 current_line = line_info->dw_line_num;
5844 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
|
| 5946 if (line_info->dw_line_num != current_line) |
5947 {
|
5846 /* This can handle deltas from -10 to 234, using the current
5847 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
5848 takes 1 byte. */
5849 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5850 DWARF_LINE_OPCODE_BASE + line_delta);
5851 if (flag_debug_asm)
5852 fprintf (asm_out_file,
5853 "\t%s line %ld", ASM_COMMENT_START, current_line);
|
5948 line_offset = line_info->dw_line_num - current_line;
5949 line_delta = line_offset - DWARF_LINE_BASE;
5950 current_line = line_info->dw_line_num;
5951 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
5952 {
5953 /* This can handle deltas from -10 to 234, using the current
5954 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
5955 takes 1 byte. */
5956 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5957 DWARF_LINE_OPCODE_BASE + line_delta);
5958 if (flag_debug_asm)
5959 fprintf (asm_out_file,
5960 "\t%s line %ld", ASM_COMMENT_START, current_line); |
5961
|
5855 fputc ('\n', asm_out_file);
|
5962 fputc ('\n', asm_out_file);
5963 }
5964 else
5965 {
5966 /* This can handle any delta. This takes at least 4 bytes,
5967 depending on the value being encoded. */
5968 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
5969 if (flag_debug_asm)
5970 fprintf (asm_out_file, "\t%s advance to line %ld",
5971 ASM_COMMENT_START, current_line);
5972
5973 fputc ('\n', asm_out_file);
5974 output_sleb128 (line_offset);
5975 fputc ('\n', asm_out_file);
5976 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5977 if (flag_debug_asm)
5978 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5979 fputc ('\n', asm_out_file);
5980 } |
5981 }
5982 else
5983 {
|
5859 /* This can handle any delta. This takes at least 4 bytes, depending
5860 on the value being encoded. */
5861 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
|
5984 /* We still need to start a new row, so output a copy insn. */
5985 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy); |
5986 if (flag_debug_asm)
|
5863 fprintf (asm_out_file, "\t%s advance to line %ld",
5864 ASM_COMMENT_START, current_line);
5865
|
| 5987 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START); |
5988 fputc ('\n', asm_out_file);
|
5867 output_sleb128 (line_offset);
5868 fputc ('\n', asm_out_file);
5869 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5870 fputc ('\n', asm_out_file);
|
5989 }
5990 }
5991
5992 /* Emit debug info for the address of the end of the function. */
5993 if (0)
5994 {
5995 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5996 if (flag_debug_asm)
5997 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5998 ASM_COMMENT_START);
5999
6000 fputc ('\n', asm_out_file);
6001 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, text_end_label, prev_line_label);
6002 fputc ('\n', asm_out_file);
6003 }
6004 else
6005 {
6006 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6007 if (flag_debug_asm)
6008 fprintf (asm_out_file, "\t%s DW_LNE_set_address", ASM_COMMENT_START);
6009 fputc ('\n', asm_out_file);
6010 output_uleb128 (1 + PTR_SIZE);
6011 fputc ('\n', asm_out_file);
6012 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
6013 fputc ('\n', asm_out_file);
6014 ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_end_label);
6015 fputc ('\n', asm_out_file);
6016 }
6017
6018 /* Output the marker for the end of the line number info. */
6019 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6020 if (flag_debug_asm)
6021 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence", ASM_COMMENT_START);
6022
6023 fputc ('\n', asm_out_file);
6024 output_uleb128 (1);
6025 fputc ('\n', asm_out_file);
6026 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
6027 fputc ('\n', asm_out_file);
6028
6029 function = 0;
6030 current_file = 1;
6031 current_line = 1;
6032 for (lt_index = 0; lt_index < separate_line_info_table_in_use; )
6033 {
6034 register dw_separate_line_info_ref line_info
6035 = &separate_line_info_table[lt_index];
6036
|
6037 /* Don't emit anything for redundant notes. */
6038 if (line_info->dw_line_num == current_line
6039 && line_info->dw_file_num == current_file
6040 && line_info->function == function)
6041 goto cont;
6042 |
6043 /* Emit debug info for the address of the current line. If this is
6044 a new function, or the first line of a function, then we need
6045 to handle it differently. */
6046 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
6047 lt_index);
6048 if (function != line_info->function)
6049 {
6050 function = line_info->function;
6051
6052 /* Set the address register to the first line in the function */
6053 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6054 if (flag_debug_asm)
6055 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
6056 ASM_COMMENT_START);
6057
6058 fputc ('\n', asm_out_file);
6059 output_uleb128 (1 + PTR_SIZE);
6060 fputc ('\n', asm_out_file);
6061 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
6062 fputc ('\n', asm_out_file);
6063 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
6064 fputc ('\n', asm_out_file);
6065 }
6066 else
6067 {
6068 /* ??? See the DW_LNS_advance_pc comment above. */
6069 if (0)
6070 {
6071 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
6072 if (flag_debug_asm)
6073 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
6074 ASM_COMMENT_START);
6075
6076 fputc ('\n', asm_out_file);
6077 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label,
6078 prev_line_label);
6079 fputc ('\n', asm_out_file);
6080 }
6081 else
6082 {
6083 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6084 if (flag_debug_asm)
6085 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
6086 ASM_COMMENT_START);
6087 fputc ('\n', asm_out_file);
6088 output_uleb128 (1 + PTR_SIZE);
6089 fputc ('\n', asm_out_file);
6090 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
6091 fputc ('\n', asm_out_file);
6092 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
6093 fputc ('\n', asm_out_file);
6094 }
6095 }
6096 strcpy (prev_line_label, line_label);
6097
6098 /* Emit debug info for the source file of the current line, if
6099 different from the previous line. */
6100 if (line_info->dw_file_num != current_file)
6101 {
6102 current_file = line_info->dw_file_num;
6103 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
6104 if (flag_debug_asm)
6105 fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START);
6106
6107 fputc ('\n', asm_out_file);
6108 output_uleb128 (current_file);
6109 if (flag_debug_asm)
6110 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
6111
6112 fputc ('\n', asm_out_file);
6113 }
6114
6115 /* Emit debug info for the current line number, choosing the encoding
6116 that uses the least amount of space. */
6117 if (line_info->dw_line_num != current_line)
6118 {
6119 line_offset = line_info->dw_line_num - current_line;
6120 line_delta = line_offset - DWARF_LINE_BASE;
6121 current_line = line_info->dw_line_num;
6122 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
6123 {
6124 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
6125 DWARF_LINE_OPCODE_BASE + line_delta);
6126 if (flag_debug_asm)
6127 fprintf (asm_out_file,
6128 "\t%s line %ld", ASM_COMMENT_START, current_line);
6129
6130 fputc ('\n', asm_out_file);
6131 }
6132 else
6133 {
6134 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
6135 if (flag_debug_asm)
6136 fprintf (asm_out_file, "\t%s advance to line %ld",
6137 ASM_COMMENT_START, current_line);
6138
6139 fputc ('\n', asm_out_file);
6140 output_sleb128 (line_offset);
6141 fputc ('\n', asm_out_file);
6142 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
|
6143 if (flag_debug_asm)
6144 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START); |
6145 fputc ('\n', asm_out_file);
6146 }
6147 }
|
6148 else
6149 {
6150 /* We still need to start a new row, so output a copy insn. */
6151 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
6152 if (flag_debug_asm)
6153 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
6154 fputc ('\n', asm_out_file);
6155 } |
6156
|
| 6157 cont: |
6158 ++lt_index;
6159
6160 /* If we're done with a function, end its sequence. */
6161 if (lt_index == separate_line_info_table_in_use
6162 || separate_line_info_table[lt_index].function != function)
6163 {
6164 current_file = 1;
6165 current_line = 1;
6166
6167 /* Emit debug info for the address of the end of the function. */
6168 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
6169 if (0)
6170 {
6171 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
6172 if (flag_debug_asm)
6173 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
6174 ASM_COMMENT_START);
6175
6176 fputc ('\n', asm_out_file);
6177 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label,
6178 prev_line_label);
6179 fputc ('\n', asm_out_file);
6180 }
6181 else
6182 {
6183 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6184 if (flag_debug_asm)
6185 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
6186 ASM_COMMENT_START);
6187 fputc ('\n', asm_out_file);
6188 output_uleb128 (1 + PTR_SIZE);
6189 fputc ('\n', asm_out_file);
6190 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
6191 fputc ('\n', asm_out_file);
6192 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
6193 fputc ('\n', asm_out_file);
6194 }
6195
6196 /* Output the marker for the end of this sequence. */
6197 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6198 if (flag_debug_asm)
6199 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence",
6200 ASM_COMMENT_START);
6201
6202 fputc ('\n', asm_out_file);
6203 output_uleb128 (1);
6204 fputc ('\n', asm_out_file);
6205 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
6206 fputc ('\n', asm_out_file);
6207 }
6208 }
6209}
6210
6211/* Given a pointer to a BLOCK node return non-zero if (and only if) the node
6212 in question represents the outermost pair of curly braces (i.e. the "body
6213 block") of a function or method.
6214
6215 For any BLOCK node representing a "body block" of a function or method, the
6216 BLOCK_SUPERCONTEXT of the node will point to another BLOCK node which
6217 represents the outermost (function) scope for the function or method (i.e.
6218 the one which includes the formal parameters). The BLOCK_SUPERCONTEXT of
6219 *that* node in turn will point to the relevant FUNCTION_DECL node. */
6220
6221static inline int
6222is_body_block (stmt)
6223 register tree stmt;
6224{
6225 if (TREE_CODE (stmt) == BLOCK)
6226 {
6227 register tree parent = BLOCK_SUPERCONTEXT (stmt);
6228
6229 if (TREE_CODE (parent) == BLOCK)
6230 {
6231 register tree grandparent = BLOCK_SUPERCONTEXT (parent);
6232
6233 if (TREE_CODE (grandparent) == FUNCTION_DECL)
6234 return 1;
6235 }
6236 }
6237
6238 return 0;
6239}
6240
6241/* Given a pointer to a tree node for some base type, return a pointer to
6242 a DIE that describes the given type.
6243
6244 This routine must only be called for GCC type nodes that correspond to
6245 Dwarf base (fundamental) types. */
6246
6247static dw_die_ref
6248base_type_die (type)
6249 register tree type;
6250{
6251 register dw_die_ref base_type_result;
6252 register char *type_name;
6253 register enum dwarf_type encoding;
6254 register tree name = TYPE_NAME (type);
6255
6256 if (TREE_CODE (type) == ERROR_MARK
6257 || TREE_CODE (type) == VOID_TYPE)
6258 return 0;
6259
6260 if (TREE_CODE (name) == TYPE_DECL)
6261 name = DECL_NAME (name);
6262 type_name = IDENTIFIER_POINTER (name);
6263
6264 switch (TREE_CODE (type))
6265 {
6266 case INTEGER_TYPE:
6267 /* Carefully distinguish the C character types, without messing
6268 up if the language is not C. Note that we check only for the names
6269 that contain spaces; other names might occur by coincidence in other
6270 languages. */
6271 if (! (TYPE_PRECISION (type) == CHAR_TYPE_SIZE
6272 && (type == char_type_node
6273 || ! strcmp (type_name, "signed char")
6274 || ! strcmp (type_name, "unsigned char"))))
6275 {
6276 if (TREE_UNSIGNED (type))
6277 encoding = DW_ATE_unsigned;
6278 else
6279 encoding = DW_ATE_signed;
6280 break;
6281 }
6282 /* else fall through */
6283
6284 case CHAR_TYPE:
6285 /* GNU Pascal/Ada CHAR type. Not used in C. */
6286 if (TREE_UNSIGNED (type))
6287 encoding = DW_ATE_unsigned_char;
6288 else
6289 encoding = DW_ATE_signed_char;
6290 break;
6291
6292 case REAL_TYPE:
6293 encoding = DW_ATE_float;
6294 break;
6295
6296 case COMPLEX_TYPE:
6297 encoding = DW_ATE_complex_float;
6298 break;
6299
6300 case BOOLEAN_TYPE:
6301 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
6302 encoding = DW_ATE_boolean;
6303 break;
6304
6305 default:
6306 abort (); /* No other TREE_CODEs are Dwarf fundamental types. */
6307 }
6308
6309 base_type_result = new_die (DW_TAG_base_type, comp_unit_die);
6310 add_AT_string (base_type_result, DW_AT_name, type_name);
6311 add_AT_unsigned (base_type_result, DW_AT_byte_size,
6312 int_size_in_bytes (type));
6313 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
6314
6315 return base_type_result;
6316}
6317
6318/* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
6319 the Dwarf "root" type for the given input type. The Dwarf "root" type of
6320 a given type is generally the same as the given type, except that if the
6321 given type is a pointer or reference type, then the root type of the given
6322 type is the root type of the "basis" type for the pointer or reference
6323 type. (This definition of the "root" type is recursive.) Also, the root
6324 type of a `const' qualified type or a `volatile' qualified type is the
6325 root type of the given type without the qualifiers. */
6326
6327static tree
6328root_type (type)
6329 register tree type;
6330{
6331 if (TREE_CODE (type) == ERROR_MARK)
6332 return error_mark_node;
6333
6334 switch (TREE_CODE (type))
6335 {
6336 case ERROR_MARK:
6337 return error_mark_node;
6338
6339 case POINTER_TYPE:
6340 case REFERENCE_TYPE:
6341 return type_main_variant (root_type (TREE_TYPE (type)));
6342
6343 default:
6344 return type_main_variant (type);
6345 }
6346}
6347
6348/* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the
6349 given input type is a Dwarf "fundamental" type. Otherwise return null. */
6350
6351static inline int
6352is_base_type (type)
6353 register tree type;
6354{
6355 switch (TREE_CODE (type))
6356 {
6357 case ERROR_MARK:
6358 case VOID_TYPE:
6359 case INTEGER_TYPE:
6360 case REAL_TYPE:
6361 case COMPLEX_TYPE:
6362 case BOOLEAN_TYPE:
6363 case CHAR_TYPE:
6364 return 1;
6365
6366 case SET_TYPE:
6367 case ARRAY_TYPE:
6368 case RECORD_TYPE:
6369 case UNION_TYPE:
6370 case QUAL_UNION_TYPE:
6371 case ENUMERAL_TYPE:
6372 case FUNCTION_TYPE:
6373 case METHOD_TYPE:
6374 case POINTER_TYPE:
6375 case REFERENCE_TYPE:
6376 case FILE_TYPE:
6377 case OFFSET_TYPE:
6378 case LANG_TYPE:
6379 return 0;
6380
6381 default:
6382 abort ();
6383 }
6384
6385 return 0;
6386}
6387
6388/* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
6389 entry that chains various modifiers in front of the given type. */
6390
6391static dw_die_ref
6392modified_type_die (type, is_const_type, is_volatile_type, context_die)
6393 register tree type;
6394 register int is_const_type;
6395 register int is_volatile_type;
6396 register dw_die_ref context_die;
6397{
6398 register enum tree_code code = TREE_CODE (type);
6399 register dw_die_ref mod_type_die = NULL;
6400 register dw_die_ref sub_die = NULL;
6401 register tree item_type = NULL;
6402
6403 if (code != ERROR_MARK)
6404 {
6405 type = build_type_variant (type, is_const_type, is_volatile_type);
6406
6407 mod_type_die = lookup_type_die (type);
6408 if (mod_type_die)
6409 return mod_type_die;
6410
6411 /* Handle C typedef types. */
6412 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6413 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
6414 {
6415 tree dtype = TREE_TYPE (TYPE_NAME (type));
6416 if (type == dtype)
6417 {
6418 /* For a named type, use the typedef. */
6419 gen_type_die (type, context_die);
6420 mod_type_die = lookup_type_die (type);
6421 }
6422
6423 else if (is_const_type < TYPE_READONLY (dtype)
6424 || is_volatile_type < TYPE_VOLATILE (dtype))
6425 /* cv-unqualified version of named type. Just use the unnamed
6426 type to which it refers. */
6427 mod_type_die
6428 = modified_type_die (DECL_ORIGINAL_TYPE (TYPE_NAME (type)),
6429 is_const_type, is_volatile_type,
6430 context_die);
6431 /* Else cv-qualified version of named type; fall through. */
6432 }
6433
6434 if (mod_type_die)
6435 /* OK */;
6436 else if (is_const_type)
6437 {
6438 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die);
6439 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
6440 }
6441 else if (is_volatile_type)
6442 {
6443 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die);
6444 sub_die = modified_type_die (type, 0, 0, context_die);
6445 }
6446 else if (code == POINTER_TYPE)
6447 {
6448 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die);
6449 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
6450#if 0
6451 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
6452#endif
6453 item_type = TREE_TYPE (type);
6454 }
6455 else if (code == REFERENCE_TYPE)
6456 {
6457 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die);
6458 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
6459#if 0
6460 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
6461#endif
6462 item_type = TREE_TYPE (type);
6463 }
6464 else if (is_base_type (type))
6465 mod_type_die = base_type_die (type);
6466 else
6467 {
6468 gen_type_die (type, context_die);
6469
6470 /* We have to get the type_main_variant here (and pass that to the
6471 `lookup_type_die' routine) because the ..._TYPE node we have
6472 might simply be a *copy* of some original type node (where the
6473 copy was created to help us keep track of typedef names) and
6474 that copy might have a different TYPE_UID from the original
6475 ..._TYPE node. */
6476 mod_type_die = lookup_type_die (type_main_variant (type));
6477 if (mod_type_die == NULL)
6478 abort ();
6479 }
6480 }
6481
6482 equate_type_number_to_die (type, mod_type_die);
6483 if (item_type)
6484 /* We must do this after the equate_type_number_to_die call, in case
6485 this is a recursive type. This ensures that the modified_type_die
6486 recursion will terminate even if the type is recursive. Recursive
6487 types are possible in Ada. */
6488 sub_die = modified_type_die (item_type,
6489 TYPE_READONLY (item_type),
6490 TYPE_VOLATILE (item_type),
6491 context_die);
6492
6493 if (sub_die != NULL)
6494 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
6495
6496 return mod_type_die;
6497}
6498
6499/* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
6500 an enumerated type. */
6501
6502static inline int
6503type_is_enum (type)
6504 register tree type;
6505{
6506 return TREE_CODE (type) == ENUMERAL_TYPE;
6507}
6508
6509/* Return a location descriptor that designates a machine register. */
6510
6511static dw_loc_descr_ref
6512reg_loc_descriptor (rtl)
6513 register rtx rtl;
6514{
6515 register dw_loc_descr_ref loc_result = NULL;
6516 register unsigned reg = reg_number (rtl);
6517
6518 if (reg <= 31)
6519 loc_result = new_loc_descr (DW_OP_reg0 + reg, 0, 0);
6520 else
6521 loc_result = new_loc_descr (DW_OP_regx, reg, 0);
6522
6523 return loc_result;
6524}
6525
6526/* Return a location descriptor that designates a base+offset location. */
6527
6528static dw_loc_descr_ref
6529based_loc_descr (reg, offset)
6530 unsigned reg;
6531 long int offset;
6532{
6533 register dw_loc_descr_ref loc_result;
6534 /* For the "frame base", we use the frame pointer or stack pointer
6535 registers, since the RTL for local variables is relative to one of
6536 them. */
6537 register unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed
6538 ? HARD_FRAME_POINTER_REGNUM
6539 : STACK_POINTER_REGNUM);
6540
6541 if (reg == fp_reg)
6542 loc_result = new_loc_descr (DW_OP_fbreg, offset, 0);
6543 else if (reg <= 31)
6544 loc_result = new_loc_descr (DW_OP_breg0 + reg, offset, 0);
6545 else
6546 loc_result = new_loc_descr (DW_OP_bregx, reg, offset);
6547
6548 return loc_result;
6549}
6550
6551/* Return true if this RTL expression describes a base+offset calculation. */
6552
6553static inline int
6554is_based_loc (rtl)
6555 register rtx rtl;
6556{
6557 return (GET_CODE (rtl) == PLUS
6558 && ((GET_CODE (XEXP (rtl, 0)) == REG
6559 && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
6560}
6561
6562/* The following routine converts the RTL for a variable or parameter
6563 (resident in memory) into an equivalent Dwarf representation of a
6564 mechanism for getting the address of that same variable onto the top of a
6565 hypothetical "address evaluation" stack.
6566
6567 When creating memory location descriptors, we are effectively transforming
6568 the RTL for a memory-resident object into its Dwarf postfix expression
6569 equivalent. This routine recursively descends an RTL tree, turning
6570 it into Dwarf postfix code as it goes. */
6571
6572static dw_loc_descr_ref
6573mem_loc_descriptor (rtl)
6574 register rtx rtl;
6575{
6576 dw_loc_descr_ref mem_loc_result = NULL;
6577 /* Note that for a dynamically sized array, the location we will generate a
6578 description of here will be the lowest numbered location which is
6579 actually within the array. That's *not* necessarily the same as the
6580 zeroth element of the array. */
6581
6582 switch (GET_CODE (rtl))
6583 {
6584 case SUBREG:
6585 /* The case of a subreg may arise when we have a local (register)
6586 variable or a formal (register) parameter which doesn't quite fill
6587 up an entire register. For now, just assume that it is
6588 legitimate to make the Dwarf info refer to the whole register which
6589 contains the given subreg. */
6590 rtl = XEXP (rtl, 0);
6591
6592 /* ... fall through ... */
6593
6594 case REG:
6595 /* Whenever a register number forms a part of the description of the
6596 method for calculating the (dynamic) address of a memory resident
6597 object, DWARF rules require the register number be referred to as
6598 a "base register". This distinction is not based in any way upon
6599 what category of register the hardware believes the given register
6600 belongs to. This is strictly DWARF terminology we're dealing with
6601 here. Note that in cases where the location of a memory-resident
6602 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
6603 OP_CONST (0)) the actual DWARF location descriptor that we generate
6604 may just be OP_BASEREG (basereg). This may look deceptively like
6605 the object in question was allocated to a register (rather than in
6606 memory) so DWARF consumers need to be aware of the subtle
6607 distinction between OP_REG and OP_BASEREG. */
6608 mem_loc_result = based_loc_descr (reg_number (rtl), 0);
6609 break;
6610
6611 case MEM:
6612 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0));
6613 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
6614 break;
6615
6616 case CONST:
6617 case SYMBOL_REF:
6618 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
6619 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
6620 mem_loc_result->dw_loc_oprnd1.v.val_addr = addr_to_string (rtl);
6621 break;
6622
6623 case PLUS:
6624 if (is_based_loc (rtl))
6625 mem_loc_result = based_loc_descr (reg_number (XEXP (rtl, 0)),
6626 INTVAL (XEXP (rtl, 1)));
6627 else
6628 {
6629 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0)));
6630 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1)));
6631 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_plus, 0, 0));
6632 }
6633 break;
6634
6635 case MULT:
6636 /* If a pseudo-reg is optimized away, it is possible for it to
6637 be replaced with a MEM containing a multiply. */
6638 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0)));
6639 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1)));
6640 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
6641 break;
6642
6643 case CONST_INT:
6644 mem_loc_result = new_loc_descr (DW_OP_constu, INTVAL (rtl), 0);
6645 break;
6646
6647 default:
6648 abort ();
6649 }
6650
6651 return mem_loc_result;
6652}
6653
6654/* Return a descriptor that describes the concatenation of two locations.
6655 This is typically a complex variable. */
6656
6657static dw_loc_descr_ref
6658concat_loc_descriptor (x0, x1)
6659 register rtx x0, x1;
6660{
6661 dw_loc_descr_ref cc_loc_result = NULL;
6662
6663 if (!is_pseudo_reg (x0)
6664 && (GET_CODE (x0) != MEM || !is_pseudo_reg (XEXP (x0, 0))))
6665 add_loc_descr (&cc_loc_result, loc_descriptor (x0));
6666 add_loc_descr (&cc_loc_result,
6667 new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x0)), 0));
6668
6669 if (!is_pseudo_reg (x1)
6670 && (GET_CODE (x1) != MEM || !is_pseudo_reg (XEXP (x1, 0))))
6671 add_loc_descr (&cc_loc_result, loc_descriptor (x1));
6672 add_loc_descr (&cc_loc_result,
6673 new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x1)), 0));
6674
6675 return cc_loc_result;
6676}
6677
6678/* Output a proper Dwarf location descriptor for a variable or parameter
6679 which is either allocated in a register or in a memory location. For a
6680 register, we just generate an OP_REG and the register number. For a
6681 memory location we provide a Dwarf postfix expression describing how to
6682 generate the (dynamic) address of the object onto the address stack. */
6683
6684static dw_loc_descr_ref
6685loc_descriptor (rtl)
6686 register rtx rtl;
6687{
6688 dw_loc_descr_ref loc_result = NULL;
6689 switch (GET_CODE (rtl))
6690 {
6691 case SUBREG:
6692 /* The case of a subreg may arise when we have a local (register)
6693 variable or a formal (register) parameter which doesn't quite fill
6694 up an entire register. For now, just assume that it is
6695 legitimate to make the Dwarf info refer to the whole register which
6696 contains the given subreg. */
6697 rtl = XEXP (rtl, 0);
6698
6699 /* ... fall through ... */
6700
6701 case REG:
6702 loc_result = reg_loc_descriptor (rtl);
6703 break;
6704
6705 case MEM:
6706 loc_result = mem_loc_descriptor (XEXP (rtl, 0));
6707 break;
6708
6709 case CONCAT:
6710 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
6711 break;
6712
6713 default:
6714 abort ();
6715 }
6716
6717 return loc_result;
6718}
6719
6720/* Given an unsigned value, round it up to the lowest multiple of `boundary'
6721 which is not less than the value itself. */
6722
6723static inline unsigned
6724ceiling (value, boundary)
6725 register unsigned value;
6726 register unsigned boundary;
6727{
6728 return (((value + boundary - 1) / boundary) * boundary);
6729}
6730
6731/* Given a pointer to what is assumed to be a FIELD_DECL node, return a
6732 pointer to the declared type for the relevant field variable, or return
6733 `integer_type_node' if the given node turns out to be an
6734 ERROR_MARK node. */
6735
6736static inline tree
6737field_type (decl)
6738 register tree decl;
6739{
6740 register tree type;
6741
6742 if (TREE_CODE (decl) == ERROR_MARK)
6743 return integer_type_node;
6744
6745 type = DECL_BIT_FIELD_TYPE (decl);
6746 if (type == NULL_TREE)
6747 type = TREE_TYPE (decl);
6748
6749 return type;
6750}
6751
6752/* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6753 node, return the alignment in bits for the type, or else return
6754 BITS_PER_WORD if the node actually turns out to be an
6755 ERROR_MARK node. */
6756
6757static inline unsigned
6758simple_type_align_in_bits (type)
6759 register tree type;
6760{
6761 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
6762}
6763
6764/* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6765 node, return the size in bits for the type if it is a constant, or else
6766 return the alignment for the type if the type's size is not constant, or
6767 else return BITS_PER_WORD if the type actually turns out to be an
6768 ERROR_MARK node. */
6769
6770static inline unsigned
6771simple_type_size_in_bits (type)
6772 register tree type;
6773{
6774 if (TREE_CODE (type) == ERROR_MARK)
6775 return BITS_PER_WORD;
6776 else
6777 {
6778 register tree type_size_tree = TYPE_SIZE (type);
6779
6780 if (TREE_CODE (type_size_tree) != INTEGER_CST)
6781 return TYPE_ALIGN (type);
6782
6783 return (unsigned) TREE_INT_CST_LOW (type_size_tree);
6784 }
6785}
6786
6787/* Given a pointer to what is assumed to be a FIELD_DECL node, compute and
6788 return the byte offset of the lowest addressed byte of the "containing
6789 object" for the given FIELD_DECL, or return 0 if we are unable to
6790 determine what that offset is, either because the argument turns out to
6791 be a pointer to an ERROR_MARK node, or because the offset is actually
6792 variable. (We can't handle the latter case just yet). */
6793
6794static unsigned
6795field_byte_offset (decl)
6796 register tree decl;
6797{
6798 register unsigned type_align_in_bytes;
6799 register unsigned type_align_in_bits;
6800 register unsigned type_size_in_bits;
6801 register unsigned object_offset_in_align_units;
6802 register unsigned object_offset_in_bits;
6803 register unsigned object_offset_in_bytes;
6804 register tree type;
6805 register tree bitpos_tree;
6806 register tree field_size_tree;
6807 register unsigned bitpos_int;
6808 register unsigned deepest_bitpos;
6809 register unsigned field_size_in_bits;
6810
6811 if (TREE_CODE (decl) == ERROR_MARK)
6812 return 0;
6813
6814 if (TREE_CODE (decl) != FIELD_DECL)
6815 abort ();
6816
6817 type = field_type (decl);
6818
6819 bitpos_tree = DECL_FIELD_BITPOS (decl);
6820 field_size_tree = DECL_SIZE (decl);
6821
6822 /* We cannot yet cope with fields whose positions or sizes are variable, so
6823 for now, when we see such things, we simply return 0. Someday, we may
6824 be able to handle such cases, but it will be damn difficult. */
6825 if (TREE_CODE (bitpos_tree) != INTEGER_CST)
6826 return 0;
6827 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
6828
6829 if (TREE_CODE (field_size_tree) != INTEGER_CST)
6830 return 0;
6831
6832 field_size_in_bits = (unsigned) TREE_INT_CST_LOW (field_size_tree);
6833 type_size_in_bits = simple_type_size_in_bits (type);
6834 type_align_in_bits = simple_type_align_in_bits (type);
6835 type_align_in_bytes = type_align_in_bits / BITS_PER_UNIT;
6836
6837 /* Note that the GCC front-end doesn't make any attempt to keep track of
6838 the starting bit offset (relative to the start of the containing
6839 structure type) of the hypothetical "containing object" for a bit-
6840 field. Thus, when computing the byte offset value for the start of the
6841 "containing object" of a bit-field, we must deduce this information on
6842 our own. This can be rather tricky to do in some cases. For example,
6843 handling the following structure type definition when compiling for an
6844 i386/i486 target (which only aligns long long's to 32-bit boundaries)
6845 can be very tricky:
6846
6847 struct S { int field1; long long field2:31; };
6848
6849 Fortunately, there is a simple rule-of-thumb which can be
6850 used in such cases. When compiling for an i386/i486, GCC will allocate
6851 8 bytes for the structure shown above. It decides to do this based upon
6852 one simple rule for bit-field allocation. Quite simply, GCC allocates
6853 each "containing object" for each bit-field at the first (i.e. lowest
6854 addressed) legitimate alignment boundary (based upon the required
6855 minimum alignment for the declared type of the field) which it can
6856 possibly use, subject to the condition that there is still enough
6857 available space remaining in the containing object (when allocated at
6858 the selected point) to fully accommodate all of the bits of the
6859 bit-field itself. This simple rule makes it obvious why GCC allocates
6860 8 bytes for each object of the structure type shown above. When looking
6861 for a place to allocate the "containing object" for `field2', the
6862 compiler simply tries to allocate a 64-bit "containing object" at each
6863 successive 32-bit boundary (starting at zero) until it finds a place to
6864 allocate that 64- bit field such that at least 31 contiguous (and
6865 previously unallocated) bits remain within that selected 64 bit field.
6866 (As it turns out, for the example above, the compiler finds that it is
6867 OK to allocate the "containing object" 64-bit field at bit-offset zero
6868 within the structure type.) Here we attempt to work backwards from the
6869 limited set of facts we're given, and we try to deduce from those facts,
6870 where GCC must have believed that the containing object started (within
6871 the structure type). The value we deduce is then used (by the callers of
6872 this routine) to generate DW_AT_location and DW_AT_bit_offset attributes
6873 for fields (both bit-fields and, in the case of DW_AT_location, regular
6874 fields as well). */
6875
6876 /* Figure out the bit-distance from the start of the structure to the
6877 "deepest" bit of the bit-field. */
6878 deepest_bitpos = bitpos_int + field_size_in_bits;
6879
6880 /* This is the tricky part. Use some fancy footwork to deduce where the
6881 lowest addressed bit of the containing object must be. */
6882 object_offset_in_bits
6883 = ceiling (deepest_bitpos, type_align_in_bits) - type_size_in_bits;
6884
6885 /* Compute the offset of the containing object in "alignment units". */
6886 object_offset_in_align_units = object_offset_in_bits / type_align_in_bits;
6887
6888 /* Compute the offset of the containing object in bytes. */
6889 object_offset_in_bytes = object_offset_in_align_units * type_align_in_bytes;
6890
6891 return object_offset_in_bytes;
6892}
6893
6894/* The following routines define various Dwarf attributes and any data
6895 associated with them. */
6896
6897/* Add a location description attribute value to a DIE.
6898
6899 This emits location attributes suitable for whole variables and
6900 whole parameters. Note that the location attributes for struct fields are
6901 generated by the routine `data_member_location_attribute' below. */
6902
6903static void
6904add_AT_location_description (die, attr_kind, rtl)
6905 dw_die_ref die;
6906 enum dwarf_attribute attr_kind;
6907 register rtx rtl;
6908{
6909 /* Handle a special case. If we are about to output a location descriptor
6910 for a variable or parameter which has been optimized out of existence,
6911 don't do that. A variable which has been optimized out
6912 of existence will have a DECL_RTL value which denotes a pseudo-reg.
6913 Currently, in some rare cases, variables can have DECL_RTL values which
6914 look like (MEM (REG pseudo-reg#)). These cases are due to bugs
6915 elsewhere in the compiler. We treat such cases as if the variable(s) in
6916 question had been optimized out of existence. */
6917
6918 if (is_pseudo_reg (rtl)
6919 || (GET_CODE (rtl) == MEM
6920 && is_pseudo_reg (XEXP (rtl, 0)))
6921 || (GET_CODE (rtl) == CONCAT
6922 && is_pseudo_reg (XEXP (rtl, 0))
6923 && is_pseudo_reg (XEXP (rtl, 1))))
6924 return;
6925
6926 add_AT_loc (die, attr_kind, loc_descriptor (rtl));
6927}
6928
6929/* Attach the specialized form of location attribute used for data
6930 members of struct and union types. In the special case of a
6931 FIELD_DECL node which represents a bit-field, the "offset" part
6932 of this special location descriptor must indicate the distance
6933 in bytes from the lowest-addressed byte of the containing struct
6934 or union type to the lowest-addressed byte of the "containing
6935 object" for the bit-field. (See the `field_byte_offset' function
6936 above).. For any given bit-field, the "containing object" is a
6937 hypothetical object (of some integral or enum type) within which
6938 the given bit-field lives. The type of this hypothetical
6939 "containing object" is always the same as the declared type of
6940 the individual bit-field itself (for GCC anyway... the DWARF
6941 spec doesn't actually mandate this). Note that it is the size
6942 (in bytes) of the hypothetical "containing object" which will
6943 be given in the DW_AT_byte_size attribute for this bit-field.
6944 (See the `byte_size_attribute' function below.) It is also used
6945 when calculating the value of the DW_AT_bit_offset attribute.
6946 (See the `bit_offset_attribute' function below). */
6947
6948static void
6949add_data_member_location_attribute (die, decl)
6950 register dw_die_ref die;
6951 register tree decl;
6952{
6953 register unsigned long offset;
6954 register dw_loc_descr_ref loc_descr;
6955 register enum dwarf_location_atom op;
6956
6957 if (TREE_CODE (decl) == TREE_VEC)
6958 offset = TREE_INT_CST_LOW (BINFO_OFFSET (decl));
6959 else
6960 offset = field_byte_offset (decl);
6961
6962 /* The DWARF2 standard says that we should assume that the structure address
6963 is already on the stack, so we can specify a structure field address
6964 by using DW_OP_plus_uconst. */
6965
6966#ifdef MIPS_DEBUGGING_INFO
6967 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst operator
6968 correctly. It works only if we leave the offset on the stack. */
6969 op = DW_OP_constu;
6970#else
6971 op = DW_OP_plus_uconst;
6972#endif
6973
6974 loc_descr = new_loc_descr (op, offset, 0);
6975 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
6976}
6977
6978/* Attach an DW_AT_const_value attribute for a variable or a parameter which
6979 does not have a "location" either in memory or in a register. These
6980 things can arise in GNU C when a constant is passed as an actual parameter
6981 to an inlined function. They can also arise in C++ where declared
6982 constants do not necessarily get memory "homes". */
6983
6984static void
6985add_const_value_attribute (die, rtl)
6986 register dw_die_ref die;
6987 register rtx rtl;
6988{
6989 switch (GET_CODE (rtl))
6990 {
6991 case CONST_INT:
6992 /* Note that a CONST_INT rtx could represent either an integer or a
6993 floating-point constant. A CONST_INT is used whenever the constant
6994 will fit into a single word. In all such cases, the original mode
6995 of the constant value is wiped out, and the CONST_INT rtx is
6996 assigned VOIDmode. */
6997 add_AT_unsigned (die, DW_AT_const_value, (unsigned) INTVAL (rtl));
6998 break;
6999
7000 case CONST_DOUBLE:
7001 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
7002 floating-point constant. A CONST_DOUBLE is used whenever the
7003 constant requires more than one word in order to be adequately
7004 represented. We output CONST_DOUBLEs as blocks. */
7005 {
7006 register enum machine_mode mode = GET_MODE (rtl);
7007
7008 if (GET_MODE_CLASS (mode) == MODE_FLOAT)
7009 {
7010 register unsigned length = GET_MODE_SIZE (mode) / sizeof (long);
7011 long array[4];
7012 REAL_VALUE_TYPE rv;
7013
7014 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
7015 switch (mode)
7016 {
7017 case SFmode:
7018 REAL_VALUE_TO_TARGET_SINGLE (rv, array[0]);
7019 break;
7020
7021 case DFmode:
7022 REAL_VALUE_TO_TARGET_DOUBLE (rv, array);
7023 break;
7024
7025 case XFmode:
7026 case TFmode:
7027 REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, array);
7028 break;
7029
7030 default:
7031 abort ();
7032 }
7033
7034 add_AT_float (die, DW_AT_const_value, length, array);
7035 }
7036 else
7037 add_AT_long_long (die, DW_AT_const_value,
7038 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
7039 }
7040 break;
7041
7042 case CONST_STRING:
7043 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
7044 break;
7045
7046 case SYMBOL_REF:
7047 case LABEL_REF:
7048 case CONST:
7049 add_AT_addr (die, DW_AT_const_value, addr_to_string (rtl));
7050 break;
7051
7052 case PLUS:
7053 /* In cases where an inlined instance of an inline function is passed
7054 the address of an `auto' variable (which is local to the caller) we
7055 can get a situation where the DECL_RTL of the artificial local
7056 variable (for the inlining) which acts as a stand-in for the
7057 corresponding formal parameter (of the inline function) will look
7058 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
7059 exactly a compile-time constant expression, but it isn't the address
7060 of the (artificial) local variable either. Rather, it represents the
7061 *value* which the artificial local variable always has during its
7062 lifetime. We currently have no way to represent such quasi-constant
7063 values in Dwarf, so for now we just punt and generate nothing. */
7064 break;
7065
7066 default:
7067 /* No other kinds of rtx should be possible here. */
7068 abort ();
7069 }
7070
7071}
7072
7073/* Generate *either* an DW_AT_location attribute or else an DW_AT_const_value
7074 data attribute for a variable or a parameter. We generate the
7075 DW_AT_const_value attribute only in those cases where the given variable
7076 or parameter does not have a true "location" either in memory or in a
7077 register. This can happen (for example) when a constant is passed as an
7078 actual argument in a call to an inline function. (It's possible that
7079 these things can crop up in other ways also.) Note that one type of
7080 constant value which can be passed into an inlined function is a constant
7081 pointer. This can happen for example if an actual argument in an inlined
7082 function call evaluates to a compile-time constant address. */
7083
7084static void
7085add_location_or_const_value_attribute (die, decl)
7086 register dw_die_ref die;
7087 register tree decl;
7088{
7089 register rtx rtl;
7090 register tree declared_type;
7091 register tree passed_type;
7092
7093 if (TREE_CODE (decl) == ERROR_MARK)
7094 return;
7095
7096 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL)
7097 abort ();
7098
7099 /* Here we have to decide where we are going to say the parameter "lives"
7100 (as far as the debugger is concerned). We only have a couple of
7101 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
7102
7103 DECL_RTL normally indicates where the parameter lives during most of the
7104 activation of the function. If optimization is enabled however, this
7105 could be either NULL or else a pseudo-reg. Both of those cases indicate
7106 that the parameter doesn't really live anywhere (as far as the code
7107 generation parts of GCC are concerned) during most of the function's
7108 activation. That will happen (for example) if the parameter is never
7109 referenced within the function.
7110
7111 We could just generate a location descriptor here for all non-NULL
7112 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
7113 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
7114 where DECL_RTL is NULL or is a pseudo-reg.
7115
7116 Note however that we can only get away with using DECL_INCOMING_RTL as
7117 a backup substitute for DECL_RTL in certain limited cases. In cases
7118 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
7119 we can be sure that the parameter was passed using the same type as it is
7120 declared to have within the function, and that its DECL_INCOMING_RTL
7121 points us to a place where a value of that type is passed.
7122
7123 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
7124 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
7125 because in these cases DECL_INCOMING_RTL points us to a value of some
7126 type which is *different* from the type of the parameter itself. Thus,
7127 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
7128 such cases, the debugger would end up (for example) trying to fetch a
7129 `float' from a place which actually contains the first part of a
7130 `double'. That would lead to really incorrect and confusing
7131 output at debug-time.
7132
7133 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
7134 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
7135 are a couple of exceptions however. On little-endian machines we can
7136 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
7137 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
7138 an integral type that is smaller than TREE_TYPE (decl). These cases arise
7139 when (on a little-endian machine) a non-prototyped function has a
7140 parameter declared to be of type `short' or `char'. In such cases,
7141 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
7142 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
7143 passed `int' value. If the debugger then uses that address to fetch
7144 a `short' or a `char' (on a little-endian machine) the result will be
7145 the correct data, so we allow for such exceptional cases below.
7146
7147 Note that our goal here is to describe the place where the given formal
7148 parameter lives during most of the function's activation (i.e. between
7149 the end of the prologue and the start of the epilogue). We'll do that
7150 as best as we can. Note however that if the given formal parameter is
7151 modified sometime during the execution of the function, then a stack
7152 backtrace (at debug-time) will show the function as having been
7153 called with the *new* value rather than the value which was
7154 originally passed in. This happens rarely enough that it is not
7155 a major problem, but it *is* a problem, and I'd like to fix it.
7156
7157 A future version of dwarf2out.c may generate two additional
7158 attributes for any given DW_TAG_formal_parameter DIE which will
7159 describe the "passed type" and the "passed location" for the
7160 given formal parameter in addition to the attributes we now
7161 generate to indicate the "declared type" and the "active
7162 location" for each parameter. This additional set of attributes
7163 could be used by debuggers for stack backtraces. Separately, note
7164 that sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be
7165 NULL also. This happens (for example) for inlined-instances of
7166 inline function formal parameters which are never referenced.
7167 This really shouldn't be happening. All PARM_DECL nodes should
7168 get valid non-NULL DECL_INCOMING_RTL values, but integrate.c
7169 doesn't currently generate these values for inlined instances of
7170 inline function parameters, so when we see such cases, we are
7171 just out-of-luck for the time being (until integrate.c
7172 gets fixed). */
7173
7174 /* Use DECL_RTL as the "location" unless we find something better. */
7175 rtl = DECL_RTL (decl);
7176
7177 if (TREE_CODE (decl) == PARM_DECL)
7178 {
7179 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
7180 {
7181 declared_type = type_main_variant (TREE_TYPE (decl));
7182 passed_type = type_main_variant (DECL_ARG_TYPE (decl));
7183
7184 /* This decl represents a formal parameter which was optimized out.
7185 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
7186 all* cases where (rtl == NULL_RTX) just below. */
7187 if (declared_type == passed_type)
7188 rtl = DECL_INCOMING_RTL (decl);
7189 else if (! BYTES_BIG_ENDIAN
7190 && TREE_CODE (declared_type) == INTEGER_TYPE
|
7056 && TYPE_SIZE (declared_type) <= TYPE_SIZE (passed_type))
|
7191 && (GET_MODE_SIZE (TYPE_MODE (declared_type))
7192 <= GET_MODE_SIZE (TYPE_MODE (passed_type)))) |
7193 rtl = DECL_INCOMING_RTL (decl);
7194 }
|
7195
7196 /* If the parm was passed in registers, but lives on the stack, then
7197 make a big endian correction if the mode of the type of the
7198 parameter is not the same as the mode of the rtl. */
7199 /* ??? This is the same series of checks that are made in dbxout.c before
7200 we reach the big endian correction code there. It isn't clear if all
7201 of these checks are necessary here, but keeping them all is the safe
7202 thing to do. */
7203 else if (GET_CODE (rtl) == MEM
7204 && XEXP (rtl, 0) != const0_rtx
7205 && ! CONSTANT_P (XEXP (rtl, 0))
7206 /* Not passed in memory. */
7207 && GET_CODE (DECL_INCOMING_RTL (decl)) != MEM
7208 /* Not passed by invisible reference. */
7209 && (GET_CODE (XEXP (rtl, 0)) != REG
7210 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
7211 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
7212#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
7213 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
7214#endif
7215 )
7216 /* Big endian correction check. */
7217 && BYTES_BIG_ENDIAN
7218 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
7219 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
7220 < UNITS_PER_WORD))
7221 {
7222 int offset = (UNITS_PER_WORD
7223 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
7224 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
7225 plus_constant (XEXP (rtl, 0), offset));
7226 } |
7227 }
7228
7229 if (rtl == NULL_RTX)
7230 return;
7231
7232 rtl = eliminate_regs (rtl, 0, NULL_RTX);
7233#ifdef LEAF_REG_REMAP
|
7066 if (leaf_function)
|
| 7234 if (current_function_uses_only_leaf_regs) |
7235 leaf_renumber_regs_insn (rtl);
7236#endif
7237
7238 switch (GET_CODE (rtl))
7239 {
7240 case ADDRESSOF:
7241 /* The address of a variable that was optimized away; don't emit
7242 anything. */
7243 break;
7244
7245 case CONST_INT:
7246 case CONST_DOUBLE:
7247 case CONST_STRING:
7248 case SYMBOL_REF:
7249 case LABEL_REF:
7250 case CONST:
7251 case PLUS:
7252 /* DECL_RTL could be (plus (reg ...) (const_int ...)) */
7253 add_const_value_attribute (die, rtl);
7254 break;
7255
7256 case MEM:
7257 case REG:
7258 case SUBREG:
7259 case CONCAT:
7260 add_AT_location_description (die, DW_AT_location, rtl);
7261 break;
7262
7263 default:
7264 abort ();
7265 }
7266}
7267
7268/* Generate an DW_AT_name attribute given some string value to be included as
7269 the value of the attribute. */
7270
7271static inline void
7272add_name_attribute (die, name_string)
7273 register dw_die_ref die;
7274 register char *name_string;
7275{
7276 if (name_string != NULL && *name_string != 0)
7277 add_AT_string (die, DW_AT_name, name_string);
7278}
7279
7280/* Given a tree node describing an array bound (either lower or upper) output
7281 a representation for that bound. */
7282
7283static void
7284add_bound_info (subrange_die, bound_attr, bound)
7285 register dw_die_ref subrange_die;
7286 register enum dwarf_attribute bound_attr;
7287 register tree bound;
7288{
7289 register unsigned bound_value = 0;
7290
7291 /* If this is an Ada unconstrained array type, then don't emit any debug
7292 info because the array bounds are unknown. They are parameterized when
7293 the type is instantiated. */
7294 if (contains_placeholder_p (bound))
7295 return;
7296
7297 switch (TREE_CODE (bound))
7298 {
7299 case ERROR_MARK:
7300 return;
7301
7302 /* All fixed-bounds are represented by INTEGER_CST nodes. */
7303 case INTEGER_CST:
7304 bound_value = TREE_INT_CST_LOW (bound);
7305 if (bound_attr == DW_AT_lower_bound
7306 && ((is_c_family () && bound_value == 0)
7307 || (is_fortran () && bound_value == 1)))
7308 /* use the default */;
7309 else
7310 add_AT_unsigned (subrange_die, bound_attr, bound_value);
7311 break;
7312
7313 case CONVERT_EXPR:
7314 case NOP_EXPR:
7315 case NON_LVALUE_EXPR:
7316 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
7317 break;
7318
7319 case SAVE_EXPR:
7320 /* If optimization is turned on, the SAVE_EXPRs that describe how to
7321 access the upper bound values may be bogus. If they refer to a
7322 register, they may only describe how to get at these values at the
7323 points in the generated code right after they have just been
7324 computed. Worse yet, in the typical case, the upper bound values
7325 will not even *be* computed in the optimized code (though the
7326 number of elements will), so these SAVE_EXPRs are entirely
7327 bogus. In order to compensate for this fact, we check here to see
7328 if optimization is enabled, and if so, we don't add an attribute
7329 for the (unknown and unknowable) upper bound. This should not
7330 cause too much trouble for existing (stupid?) debuggers because
7331 they have to deal with empty upper bounds location descriptions
7332 anyway in order to be able to deal with incomplete array types.
7333 Of course an intelligent debugger (GDB?) should be able to
7334 comprehend that a missing upper bound specification in a array
7335 type used for a storage class `auto' local array variable
7336 indicates that the upper bound is both unknown (at compile- time)
7337 and unknowable (at run-time) due to optimization.
7338
7339 We assume that a MEM rtx is safe because gcc wouldn't put the
7340 value there unless it was going to be used repeatedly in the
7341 function, i.e. for cleanups. */
7342 if (! optimize || GET_CODE (SAVE_EXPR_RTL (bound)) == MEM)
7343 {
7344 register dw_die_ref ctx = lookup_decl_die (current_function_decl);
7345 register dw_die_ref decl_die = new_die (DW_TAG_variable, ctx);
7346 register rtx loc = SAVE_EXPR_RTL (bound);
7347
7348 /* If the RTL for the SAVE_EXPR is memory, handle the case where
7349 it references an outer function's frame. */
7350
7351 if (GET_CODE (loc) == MEM)
7352 {
7353 rtx new_addr = fix_lexical_addr (XEXP (loc, 0), bound);
7354
7355 if (XEXP (loc, 0) != new_addr)
7356 loc = gen_rtx (MEM, GET_MODE (loc), new_addr);
7357 }
7358
7359 add_AT_flag (decl_die, DW_AT_artificial, 1);
7360 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
7361 add_AT_location_description (decl_die, DW_AT_location, loc);
7362 add_AT_die_ref (subrange_die, bound_attr, decl_die);
7363 }
7364
7365 /* Else leave out the attribute. */
7366 break;
7367
7368 case MAX_EXPR:
7369 case VAR_DECL:
7370 case COMPONENT_REF:
7371 /* ??? These types of bounds can be created by the Ada front end,
7372 and it isn't clear how to emit debug info for them. */
7373 break;
7374
7375 default:
7376 abort ();
7377 }
7378}
7379
7380/* Note that the block of subscript information for an array type also
7381 includes information about the element type of type given array type. */
7382
7383static void
7384add_subscript_info (type_die, type)
7385 register dw_die_ref type_die;
7386 register tree type;
7387{
7388#ifndef MIPS_DEBUGGING_INFO
7389 register unsigned dimension_number;
7390#endif
7391 register tree lower, upper;
7392 register dw_die_ref subrange_die;
7393
7394 /* The GNU compilers represent multidimensional array types as sequences of
7395 one dimensional array types whose element types are themselves array
7396 types. Here we squish that down, so that each multidimensional array
7397 type gets only one array_type DIE in the Dwarf debugging info. The draft
7398 Dwarf specification say that we are allowed to do this kind of
7399 compression in C (because there is no difference between an array or
7400 arrays and a multidimensional array in C) but for other source languages
7401 (e.g. Ada) we probably shouldn't do this. */
7402
7403 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
7404 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
7405 We work around this by disabling this feature. See also
7406 gen_array_type_die. */
7407#ifndef MIPS_DEBUGGING_INFO
7408 for (dimension_number = 0;
7409 TREE_CODE (type) == ARRAY_TYPE;
7410 type = TREE_TYPE (type), dimension_number++)
7411 {
7412#endif
7413 register tree domain = TYPE_DOMAIN (type);
7414
7415 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
7416 and (in GNU C only) variable bounds. Handle all three forms
7417 here. */
7418 subrange_die = new_die (DW_TAG_subrange_type, type_die);
7419 if (domain)
7420 {
7421 /* We have an array type with specified bounds. */
7422 lower = TYPE_MIN_VALUE (domain);
7423 upper = TYPE_MAX_VALUE (domain);
7424
7425 /* define the index type. */
7426 if (TREE_TYPE (domain))
7427 {
7428 /* ??? This is probably an Ada unnamed subrange type. Ignore the
7429 TREE_TYPE field. We can't emit debug info for this
7430 because it is an unnamed integral type. */
7431 if (TREE_CODE (domain) == INTEGER_TYPE
7432 && TYPE_NAME (domain) == NULL_TREE
7433 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
7434 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
7435 ;
7436 else
7437 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
7438 type_die);
7439 }
7440
7441 /* ??? If upper is NULL, the array has unspecified length,
7442 but it does have a lower bound. This happens with Fortran
7443 dimension arr(N:*)
7444 Since the debugger is definitely going to need to know N
7445 to produce useful results, go ahead and output the lower
7446 bound solo, and hope the debugger can cope. */
7447
7448 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
7449 if (upper)
7450 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
7451 }
7452 else
7453 /* We have an array type with an unspecified length. The DWARF-2
7454 spec does not say how to handle this; let's just leave out the
7455 bounds. */
7456 {;}
7457
7458
7459#ifndef MIPS_DEBUGGING_INFO
7460 }
7461#endif
7462}
7463
7464static void
7465add_byte_size_attribute (die, tree_node)
7466 dw_die_ref die;
7467 register tree tree_node;
7468{
7469 register unsigned size;
7470
7471 switch (TREE_CODE (tree_node))
7472 {
7473 case ERROR_MARK:
7474 size = 0;
7475 break;
7476 case ENUMERAL_TYPE:
7477 case RECORD_TYPE:
7478 case UNION_TYPE:
7479 case QUAL_UNION_TYPE:
7480 size = int_size_in_bytes (tree_node);
7481 break;
7482 case FIELD_DECL:
7483 /* For a data member of a struct or union, the DW_AT_byte_size is
7484 generally given as the number of bytes normally allocated for an
7485 object of the *declared* type of the member itself. This is true
7486 even for bit-fields. */
7487 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
7488 break;
7489 default:
7490 abort ();
7491 }
7492
7493 /* Note that `size' might be -1 when we get to this point. If it is, that
7494 indicates that the byte size of the entity in question is variable. We
7495 have no good way of expressing this fact in Dwarf at the present time,
7496 so just let the -1 pass on through. */
7497
7498 add_AT_unsigned (die, DW_AT_byte_size, size);
7499}
7500
7501/* For a FIELD_DECL node which represents a bit-field, output an attribute
7502 which specifies the distance in bits from the highest order bit of the
7503 "containing object" for the bit-field to the highest order bit of the
7504 bit-field itself.
7505
7506 For any given bit-field, the "containing object" is a hypothetical
7507 object (of some integral or enum type) within which the given bit-field
7508 lives. The type of this hypothetical "containing object" is always the
7509 same as the declared type of the individual bit-field itself. The
7510 determination of the exact location of the "containing object" for a
7511 bit-field is rather complicated. It's handled by the
7512 `field_byte_offset' function (above).
7513
7514 Note that it is the size (in bytes) of the hypothetical "containing object"
7515 which will be given in the DW_AT_byte_size attribute for this bit-field.
7516 (See `byte_size_attribute' above). */
7517
7518static inline void
7519add_bit_offset_attribute (die, decl)
7520 register dw_die_ref die;
7521 register tree decl;
7522{
7523 register unsigned object_offset_in_bytes = field_byte_offset (decl);
7524 register tree type = DECL_BIT_FIELD_TYPE (decl);
7525 register tree bitpos_tree = DECL_FIELD_BITPOS (decl);
7526 register unsigned bitpos_int;
7527 register unsigned highest_order_object_bit_offset;
7528 register unsigned highest_order_field_bit_offset;
7529 register unsigned bit_offset;
7530
7531 /* Must be a field and a bit field. */
7532 if (!type
7533 || TREE_CODE (decl) != FIELD_DECL)
7534 abort ();
7535
7536 /* We can't yet handle bit-fields whose offsets are variable, so if we
7537 encounter such things, just return without generating any attribute
7538 whatsoever. */
7539 if (TREE_CODE (bitpos_tree) != INTEGER_CST)
7540 return;
7541
7542 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
7543
7544 /* Note that the bit offset is always the distance (in bits) from the
7545 highest-order bit of the "containing object" to the highest-order bit of
7546 the bit-field itself. Since the "high-order end" of any object or field
7547 is different on big-endian and little-endian machines, the computation
7548 below must take account of these differences. */
7549 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
7550 highest_order_field_bit_offset = bitpos_int;
7551
7552 if (! BYTES_BIG_ENDIAN)
7553 {
7554 highest_order_field_bit_offset
7555 += (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl));
7556
7557 highest_order_object_bit_offset += simple_type_size_in_bits (type);
7558 }
7559
7560 bit_offset
7561 = (! BYTES_BIG_ENDIAN
7562 ? highest_order_object_bit_offset - highest_order_field_bit_offset
7563 : highest_order_field_bit_offset - highest_order_object_bit_offset);
7564
7565 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
7566}
7567
7568/* For a FIELD_DECL node which represents a bit field, output an attribute
7569 which specifies the length in bits of the given field. */
7570
7571static inline void
7572add_bit_size_attribute (die, decl)
7573 register dw_die_ref die;
7574 register tree decl;
7575{
7576 /* Must be a field and a bit field. */
7577 if (TREE_CODE (decl) != FIELD_DECL
7578 || ! DECL_BIT_FIELD_TYPE (decl))
7579 abort ();
7580 add_AT_unsigned (die, DW_AT_bit_size,
7581 (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl)));
7582}
7583
7584/* If the compiled language is ANSI C, then add a 'prototyped'
7585 attribute, if arg types are given for the parameters of a function. */
7586
7587static inline void
7588add_prototyped_attribute (die, func_type)
7589 register dw_die_ref die;
7590 register tree func_type;
7591{
7592 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
7593 && TYPE_ARG_TYPES (func_type) != NULL)
7594 add_AT_flag (die, DW_AT_prototyped, 1);
7595}
7596
7597
7598/* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
7599 by looking in either the type declaration or object declaration
7600 equate table. */
7601
7602static inline void
7603add_abstract_origin_attribute (die, origin)
7604 register dw_die_ref die;
7605 register tree origin;
7606{
7607 dw_die_ref origin_die = NULL;
7608 if (TREE_CODE_CLASS (TREE_CODE (origin)) == 'd')
7609 origin_die = lookup_decl_die (origin);
7610 else if (TREE_CODE_CLASS (TREE_CODE (origin)) == 't')
7611 origin_die = lookup_type_die (origin);
7612
7613 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
7614}
7615
7616/* We do not currently support the pure_virtual attribute. */
7617
7618static inline void
7619add_pure_or_virtual_attribute (die, func_decl)
7620 register dw_die_ref die;
7621 register tree func_decl;
7622{
7623 if (DECL_VINDEX (func_decl))
7624 {
7625 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
7626 add_AT_loc (die, DW_AT_vtable_elem_location,
7627 new_loc_descr (DW_OP_constu,
7628 TREE_INT_CST_LOW (DECL_VINDEX (func_decl)),
7629 0));
7630
7631 /* GNU extension: Record what type this method came from originally. */
7632 if (debug_info_level > DINFO_LEVEL_TERSE)
7633 add_AT_die_ref (die, DW_AT_containing_type,
7634 lookup_type_die (DECL_CONTEXT (func_decl)));
7635 }
7636}
7637
7638/* Add source coordinate attributes for the given decl. */
7639
7640static void
7641add_src_coords_attributes (die, decl)
7642 register dw_die_ref die;
7643 register tree decl;
7644{
7645 register unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
7646
7647 add_AT_unsigned (die, DW_AT_decl_file, file_index);
7648 add_AT_unsigned (die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
7649}
7650
7651/* Add an DW_AT_name attribute and source coordinate attribute for the
7652 given decl, but only if it actually has a name. */
7653
7654static void
7655add_name_and_src_coords_attributes (die, decl)
7656 register dw_die_ref die;
7657 register tree decl;
7658{
7659 register tree decl_name;
7660
7661 decl_name = DECL_NAME (decl);
7662 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
7663 {
7664 add_name_attribute (die, dwarf2_name (decl, 0));
7665 add_src_coords_attributes (die, decl);
7666 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
7667 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7668 add_AT_string (die, DW_AT_MIPS_linkage_name,
7669 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
7670 }
7671}
7672
7673/* Push a new declaration scope. */
7674
7675static void
7676push_decl_scope (scope)
7677 tree scope;
7678{
7679 tree containing_scope;
7680 int i;
7681
7682 /* Make room in the decl_scope_table, if necessary. */
7683 if (decl_scope_table_allocated == decl_scope_depth)
7684 {
7685 decl_scope_table_allocated += DECL_SCOPE_TABLE_INCREMENT;
7686 decl_scope_table
7687 = (decl_scope_node *) xrealloc (decl_scope_table,
7688 (decl_scope_table_allocated
7689 * sizeof (decl_scope_node)));
7690 }
7691
7692 decl_scope_table[decl_scope_depth].scope = scope;
7693
7694 /* Sometimes, while recursively emitting subtypes within a class type,
7695 we end up recuring on a subtype at a higher level then the current
7696 subtype. In such a case, we need to search the decl_scope_table to
7697 find the parent of this subtype. */
7698
|
7531 if (TREE_CODE_CLASS (TREE_CODE (scope)) == 't')
|
| 7699 if (AGGREGATE_TYPE_P (scope)) |
7700 containing_scope = TYPE_CONTEXT (scope);
7701 else
7702 containing_scope = NULL_TREE;
7703
7704 /* The normal case. */
7705 if (decl_scope_depth == 0
7706 || containing_scope == NULL_TREE
7707 /* Ignore namespaces for the moment. */
7708 || TREE_CODE (containing_scope) == NAMESPACE_DECL
7709 || containing_scope == decl_scope_table[decl_scope_depth - 1].scope)
7710 decl_scope_table[decl_scope_depth].previous = decl_scope_depth - 1;
7711 else
7712 {
7713 /* We need to search for the containing_scope. */
7714 for (i = 0; i < decl_scope_depth; i++)
7715 if (decl_scope_table[i].scope == containing_scope)
7716 break;
7717
7718 if (i == decl_scope_depth)
7719 abort ();
7720 else
7721 decl_scope_table[decl_scope_depth].previous = i;
7722 }
7723
7724 decl_scope_depth++;
7725}
7726
7727/* Return the DIE for the scope that immediately contains this declaration. */
7728
7729static dw_die_ref
7730scope_die_for (t, context_die)
7731 register tree t;
7732 register dw_die_ref context_die;
7733{
7734 register dw_die_ref scope_die = NULL;
7735 register tree containing_scope;
7736 register int i;
7737
7738 /* Walk back up the declaration tree looking for a place to define
7739 this type. */
7740 if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
7741 containing_scope = TYPE_CONTEXT (t);
7742 else if (TREE_CODE (t) == FUNCTION_DECL && DECL_VINDEX (t))
7743 containing_scope = decl_class_context (t);
7744 else
7745 containing_scope = DECL_CONTEXT (t);
7746
7747 /* Ignore namespaces for the moment. */
7748 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
7749 containing_scope = NULL_TREE;
7750
|
7751 /* Ignore function type "scopes" from the C frontend. They mean that
7752 a tagged type is local to a parmlist of a function declarator, but
7753 that isn't useful to DWARF. */
7754 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
7755 containing_scope = NULL_TREE;
7756 |
7757 /* Function-local tags and functions get stuck in limbo until they are
7758 fixed up by decls_for_scope. */
7759 if (context_die == NULL && containing_scope != NULL_TREE
7760 && (TREE_CODE (t) == FUNCTION_DECL || is_tagged_type (t)))
7761 return NULL;
7762
7763 if (containing_scope == NULL_TREE)
7764 scope_die = comp_unit_die;
7765 else
7766 {
7767 for (i = decl_scope_depth - 1, scope_die = context_die;
7768 i >= 0 && decl_scope_table[i].scope != containing_scope;
7769 (scope_die = scope_die->die_parent,
7770 i = decl_scope_table[i].previous))
7771 ;
7772
7773 /* ??? Integrate_decl_tree does not handle BLOCK_TYPE_TAGS, nor
7774 does it try to handle types defined by TYPE_DECLs. Such types
7775 thus have an incorrect TYPE_CONTEXT, which points to the block
7776 they were originally defined in, instead of the current block
7777 created by function inlining. We try to detect that here and
7778 work around it. */
7779
7780 if (i < 0 && scope_die == comp_unit_die
7781 && TREE_CODE (containing_scope) == BLOCK
7782 && is_tagged_type (t)
7783 && (block_ultimate_origin (decl_scope_table[decl_scope_depth - 1].scope)
7784 == containing_scope))
7785 {
7786 scope_die = context_die;
7787 /* Since the checks below are no longer applicable. */
7788 i = 0;
7789 }
7790
7791 if (i < 0)
7792 {
|
7619 if (scope_die != comp_unit_die
7620 || TREE_CODE_CLASS (TREE_CODE (containing_scope)) != 't')
|
| 7793 if (TREE_CODE_CLASS (TREE_CODE (containing_scope)) != 't') |
7794 abort ();
7795 if (debug_info_level > DINFO_LEVEL_TERSE
7796 && !TREE_ASM_WRITTEN (containing_scope))
7797 abort ();
|
7798
7799 /* If none of the current dies are suitable, we get file scope. */
7800 scope_die = comp_unit_die; |
7801 }
7802 }
7803
7804 return scope_die;
7805}
7806
7807/* Pop a declaration scope. */
7808static inline void
7809pop_decl_scope ()
7810{
7811 if (decl_scope_depth <= 0)
7812 abort ();
7813 --decl_scope_depth;
7814}
7815
7816/* Many forms of DIEs require a "type description" attribute. This
7817 routine locates the proper "type descriptor" die for the type given
7818 by 'type', and adds an DW_AT_type attribute below the given die. */
7819
7820static void
7821add_type_attribute (object_die, type, decl_const, decl_volatile, context_die)
7822 register dw_die_ref object_die;
7823 register tree type;
7824 register int decl_const;
7825 register int decl_volatile;
7826 register dw_die_ref context_die;
7827{
7828 register enum tree_code code = TREE_CODE (type);
7829 register dw_die_ref type_die = NULL;
7830
7831 /* ??? If this type is an unnamed subrange type of an integral or
7832 floating-point type, use the inner type. This is because we have no
7833 support for unnamed types in base_type_die. This can happen if this is
7834 an Ada subrange type. Correct solution is emit a subrange type die. */
7835 if ((code == INTEGER_TYPE || code == REAL_TYPE)
7836 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
7837 type = TREE_TYPE (type), code = TREE_CODE (type);
7838
7839 if (code == ERROR_MARK)
7840 return;
7841
7842 /* Handle a special case. For functions whose return type is void, we
7843 generate *no* type attribute. (Note that no object may have type
7844 `void', so this only applies to function return types). */
7845 if (code == VOID_TYPE)
7846 return;
7847
7848 type_die = modified_type_die (type,
7849 decl_const || TYPE_READONLY (type),
7850 decl_volatile || TYPE_VOLATILE (type),
7851 context_die);
7852 if (type_die != NULL)
7853 add_AT_die_ref (object_die, DW_AT_type, type_die);
7854}
7855
7856/* Given a tree pointer to a struct, class, union, or enum type node, return
7857 a pointer to the (string) tag name for the given type, or zero if the type
7858 was declared without a tag. */
7859
7860static char *
7861type_tag (type)
7862 register tree type;
7863{
7864 register char *name = 0;
7865
7866 if (TYPE_NAME (type) != 0)
7867 {
7868 register tree t = 0;
7869
7870 /* Find the IDENTIFIER_NODE for the type name. */
7871 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
7872 t = TYPE_NAME (type);
7873
7874 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
7875 a TYPE_DECL node, regardless of whether or not a `typedef' was
7876 involved. */
7877 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7878 && ! DECL_IGNORED_P (TYPE_NAME (type)))
7879 t = DECL_NAME (TYPE_NAME (type));
7880
7881 /* Now get the name as a string, or invent one. */
7882 if (t != 0)
7883 name = IDENTIFIER_POINTER (t);
7884 }
7885
7886 return (name == 0 || *name == '\0') ? 0 : name;
7887}
7888
7889/* Return the type associated with a data member, make a special check
7890 for bit field types. */
7891
7892static inline tree
7893member_declared_type (member)
7894 register tree member;
7895{
7896 return (DECL_BIT_FIELD_TYPE (member)
7897 ? DECL_BIT_FIELD_TYPE (member)
7898 : TREE_TYPE (member));
7899}
7900
7901/* Get the decl's label, as described by its RTL. This may be different
7902 from the DECL_NAME name used in the source file. */
7903
7904#if 0
7905static char *
7906decl_start_label (decl)
7907 register tree decl;
7908{
7909 rtx x;
7910 char *fnname;
7911 x = DECL_RTL (decl);
7912 if (GET_CODE (x) != MEM)
7913 abort ();
7914
7915 x = XEXP (x, 0);
7916 if (GET_CODE (x) != SYMBOL_REF)
7917 abort ();
7918
7919 fnname = XSTR (x, 0);
7920 return fnname;
7921}
7922#endif
7923
7924/* These routines generate the internal representation of the DIE's for
7925 the compilation unit. Debugging information is collected by walking
7926 the declaration trees passed in from dwarf2out_decl(). */
7927
7928static void
7929gen_array_type_die (type, context_die)
7930 register tree type;
7931 register dw_die_ref context_die;
7932{
7933 register dw_die_ref scope_die = scope_die_for (type, context_die);
7934 register dw_die_ref array_die;
7935 register tree element_type;
7936
7937 /* ??? The SGI dwarf reader fails for array of array of enum types unless
7938 the inner array type comes before the outer array type. Thus we must
7939 call gen_type_die before we call new_die. See below also. */
7940#ifdef MIPS_DEBUGGING_INFO
7941 gen_type_die (TREE_TYPE (type), context_die);
7942#endif
7943
7944 array_die = new_die (DW_TAG_array_type, scope_die);
7945
7946#if 0
7947 /* We default the array ordering. SDB will probably do
7948 the right things even if DW_AT_ordering is not present. It's not even
7949 an issue until we start to get into multidimensional arrays anyway. If
7950 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
7951 then we'll have to put the DW_AT_ordering attribute back in. (But if
7952 and when we find out that we need to put these in, we will only do so
7953 for multidimensional arrays. */
7954 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
7955#endif
7956
7957#ifdef MIPS_DEBUGGING_INFO
7958 /* The SGI compilers handle arrays of unknown bound by setting
7959 AT_declaration and not emitting any subrange DIEs. */
7960 if (! TYPE_DOMAIN (type))
7961 add_AT_unsigned (array_die, DW_AT_declaration, 1);
7962 else
7963#endif
7964 add_subscript_info (array_die, type);
7965
7966 equate_type_number_to_die (type, array_die);
7967
7968 /* Add representation of the type of the elements of this array type. */
7969 element_type = TREE_TYPE (type);
7970
7971 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
7972 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
7973 We work around this by disabling this feature. See also
7974 add_subscript_info. */
7975#ifndef MIPS_DEBUGGING_INFO
7976 while (TREE_CODE (element_type) == ARRAY_TYPE)
7977 element_type = TREE_TYPE (element_type);
7978
7979 gen_type_die (element_type, context_die);
7980#endif
7981
7982 add_type_attribute (array_die, element_type, 0, 0, context_die);
7983}
7984
7985static void
7986gen_set_type_die (type, context_die)
7987 register tree type;
7988 register dw_die_ref context_die;
7989{
7990 register dw_die_ref type_die
7991 = new_die (DW_TAG_set_type, scope_die_for (type, context_die));
7992
7993 equate_type_number_to_die (type, type_die);
7994 add_type_attribute (type_die, TREE_TYPE (type), 0, 0, context_die);
7995}
7996
7997#if 0
7998static void
7999gen_entry_point_die (decl, context_die)
8000 register tree decl;
8001 register dw_die_ref context_die;
8002{
8003 register tree origin = decl_ultimate_origin (decl);
8004 register dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die);
8005 if (origin != NULL)
8006 add_abstract_origin_attribute (decl_die, origin);
8007 else
8008 {
8009 add_name_and_src_coords_attributes (decl_die, decl);
8010 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
8011 0, 0, context_die);
8012 }
8013
8014 if (DECL_ABSTRACT (decl))
8015 equate_decl_number_to_die (decl, decl_die);
8016 else
8017 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
8018}
8019#endif
8020
8021/* Remember a type in the pending_types_list. */
8022
8023static void
8024pend_type (type)
8025 register tree type;
8026{
8027 if (pending_types == pending_types_allocated)
8028 {
8029 pending_types_allocated += PENDING_TYPES_INCREMENT;
8030 pending_types_list
8031 = (tree *) xrealloc (pending_types_list,
8032 sizeof (tree) * pending_types_allocated);
8033 }
8034
8035 pending_types_list[pending_types++] = type;
8036}
8037
8038/* Output any pending types (from the pending_types list) which we can output
8039 now (taking into account the scope that we are working on now).
8040
8041 For each type output, remove the given type from the pending_types_list
8042 *before* we try to output it. */
8043
8044static void
8045output_pending_types_for_scope (context_die)
8046 register dw_die_ref context_die;
8047{
8048 register tree type;
8049
8050 while (pending_types)
8051 {
8052 --pending_types;
8053 type = pending_types_list[pending_types];
8054 gen_type_die (type, context_die);
8055 if (!TREE_ASM_WRITTEN (type))
8056 abort ();
8057 }
8058}
8059
|
8060/* Remember a type in the incomplete_types_list. */
8061
8062static void
8063add_incomplete_type (type)
8064 tree type;
8065{
8066 if (incomplete_types == incomplete_types_allocated)
8067 {
8068 incomplete_types_allocated += INCOMPLETE_TYPES_INCREMENT;
8069 incomplete_types_list
8070 = (tree *) xrealloc (incomplete_types_list,
8071 sizeof (tree) * incomplete_types_allocated);
8072 }
8073
8074 incomplete_types_list[incomplete_types++] = type;
8075}
8076
8077/* Walk through the list of incomplete types again, trying once more to
8078 emit full debugging info for them. */
8079
8080static void
8081retry_incomplete_types ()
8082{
8083 register tree type;
8084
8085 while (incomplete_types)
8086 {
8087 --incomplete_types;
8088 type = incomplete_types_list[incomplete_types];
8089 gen_type_die (type, comp_unit_die);
8090 }
8091}
8092 |
8093/* Generate a DIE to represent an inlined instance of an enumeration type. */
8094
8095static void
8096gen_inlined_enumeration_type_die (type, context_die)
8097 register tree type;
8098 register dw_die_ref context_die;
8099{
8100 register dw_die_ref type_die = new_die (DW_TAG_enumeration_type,
8101 scope_die_for (type, context_die));
8102
8103 if (!TREE_ASM_WRITTEN (type))
8104 abort ();
8105 add_abstract_origin_attribute (type_die, type);
8106}
8107
8108/* Generate a DIE to represent an inlined instance of a structure type. */
8109
8110static void
8111gen_inlined_structure_type_die (type, context_die)
8112 register tree type;
8113 register dw_die_ref context_die;
8114{
8115 register dw_die_ref type_die = new_die (DW_TAG_structure_type,
8116 scope_die_for (type, context_die));
8117
8118 if (!TREE_ASM_WRITTEN (type))
8119 abort ();
8120 add_abstract_origin_attribute (type_die, type);
8121}
8122
8123/* Generate a DIE to represent an inlined instance of a union type. */
8124
8125static void
8126gen_inlined_union_type_die (type, context_die)
8127 register tree type;
8128 register dw_die_ref context_die;
8129{
8130 register dw_die_ref type_die = new_die (DW_TAG_union_type,
8131 scope_die_for (type, context_die));
8132
8133 if (!TREE_ASM_WRITTEN (type))
8134 abort ();
8135 add_abstract_origin_attribute (type_die, type);
8136}
8137
8138/* Generate a DIE to represent an enumeration type. Note that these DIEs
8139 include all of the information about the enumeration values also. Each
8140 enumerated type name/value is listed as a child of the enumerated type
8141 DIE. */
8142
8143static void
8144gen_enumeration_type_die (type, context_die)
8145 register tree type;
8146 register dw_die_ref context_die;
8147{
8148 register dw_die_ref type_die = lookup_type_die (type);
8149
8150 if (type_die == NULL)
8151 {
8152 type_die = new_die (DW_TAG_enumeration_type,
8153 scope_die_for (type, context_die));
8154 equate_type_number_to_die (type, type_die);
8155 add_name_attribute (type_die, type_tag (type));
8156 }
8157 else if (! TYPE_SIZE (type))
8158 return;
8159 else
8160 remove_AT (type_die, DW_AT_declaration);
8161
8162 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
8163 given enum type is incomplete, do not generate the DW_AT_byte_size
8164 attribute or the DW_AT_element_list attribute. */
8165 if (TYPE_SIZE (type))
8166 {
8167 register tree link;
8168
8169 TREE_ASM_WRITTEN (type) = 1;
8170 add_byte_size_attribute (type_die, type);
8171 if (TYPE_STUB_DECL (type) != NULL_TREE)
8172 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
8173
8174 /* If the first reference to this type was as the return type of an
8175 inline function, then it may not have a parent. Fix this now. */
8176 if (type_die->die_parent == NULL)
8177 add_child_die (scope_die_for (type, context_die), type_die);
8178
8179 for (link = TYPE_FIELDS (type);
8180 link != NULL; link = TREE_CHAIN (link))
8181 {
8182 register dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die);
8183
8184 add_name_attribute (enum_die,
8185 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
8186 add_AT_unsigned (enum_die, DW_AT_const_value,
8187 (unsigned) TREE_INT_CST_LOW (TREE_VALUE (link)));
8188 }
8189 }
8190 else
8191 add_AT_flag (type_die, DW_AT_declaration, 1);
8192}
8193
8194
8195/* Generate a DIE to represent either a real live formal parameter decl or to
8196 represent just the type of some formal parameter position in some function
8197 type.
8198
8199 Note that this routine is a bit unusual because its argument may be a
8200 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
8201 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
8202 node. If it's the former then this function is being called to output a
8203 DIE to represent a formal parameter object (or some inlining thereof). If
8204 it's the latter, then this function is only being called to output a
8205 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
8206 argument type of some subprogram type. */
8207
8208static dw_die_ref
8209gen_formal_parameter_die (node, context_die)
8210 register tree node;
8211 register dw_die_ref context_die;
8212{
8213 register dw_die_ref parm_die
8214 = new_die (DW_TAG_formal_parameter, context_die);
8215 register tree origin;
8216
8217 switch (TREE_CODE_CLASS (TREE_CODE (node)))
8218 {
8219 case 'd':
8220 origin = decl_ultimate_origin (node);
8221 if (origin != NULL)
8222 add_abstract_origin_attribute (parm_die, origin);
8223 else
8224 {
8225 add_name_and_src_coords_attributes (parm_die, node);
8226 add_type_attribute (parm_die, TREE_TYPE (node),
8227 TREE_READONLY (node),
8228 TREE_THIS_VOLATILE (node),
8229 context_die);
8230 if (DECL_ARTIFICIAL (node))
8231 add_AT_flag (parm_die, DW_AT_artificial, 1);
8232 }
8233
8234 equate_decl_number_to_die (node, parm_die);
8235 if (! DECL_ABSTRACT (node))
8236 add_location_or_const_value_attribute (parm_die, node);
8237
8238 break;
8239
8240 case 't':
8241 /* We were called with some kind of a ..._TYPE node. */
8242 add_type_attribute (parm_die, node, 0, 0, context_die);
8243 break;
8244
8245 default:
8246 abort ();
8247 }
8248
8249 return parm_die;
8250}
8251
8252/* Generate a special type of DIE used as a stand-in for a trailing ellipsis
8253 at the end of an (ANSI prototyped) formal parameters list. */
8254
8255static void
8256gen_unspecified_parameters_die (decl_or_type, context_die)
8257 register tree decl_or_type;
8258 register dw_die_ref context_die;
8259{
8260 new_die (DW_TAG_unspecified_parameters, context_die);
8261}
8262
8263/* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
8264 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
8265 parameters as specified in some function type specification (except for
8266 those which appear as part of a function *definition*).
8267
8268 Note we must be careful here to output all of the parameter DIEs before*
8269 we output any DIEs needed to represent the types of the formal parameters.
8270 This keeps svr4 SDB happy because it (incorrectly) thinks that the first
8271 non-parameter DIE it sees ends the formal parameter list. */
8272
8273static void
8274gen_formal_types_die (function_or_method_type, context_die)
8275 register tree function_or_method_type;
8276 register dw_die_ref context_die;
8277{
8278 register tree link;
8279 register tree formal_type = NULL;
8280 register tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
8281
8282#if 0
8283 /* In the case where we are generating a formal types list for a C++
8284 non-static member function type, skip over the first thing on the
8285 TYPE_ARG_TYPES list because it only represents the type of the hidden
8286 `this pointer'. The debugger should be able to figure out (without
8287 being explicitly told) that this non-static member function type takes a
8288 `this pointer' and should be able to figure what the type of that hidden
8289 parameter is from the DW_AT_member attribute of the parent
8290 DW_TAG_subroutine_type DIE. */
8291 if (TREE_CODE (function_or_method_type) == METHOD_TYPE)
8292 first_parm_type = TREE_CHAIN (first_parm_type);
8293#endif
8294
8295 /* Make our first pass over the list of formal parameter types and output a
8296 DW_TAG_formal_parameter DIE for each one. */
8297 for (link = first_parm_type; link; link = TREE_CHAIN (link))
8298 {
8299 register dw_die_ref parm_die;
8300
8301 formal_type = TREE_VALUE (link);
8302 if (formal_type == void_type_node)
8303 break;
8304
8305 /* Output a (nameless) DIE to represent the formal parameter itself. */
8306 parm_die = gen_formal_parameter_die (formal_type, context_die);
8307 if (TREE_CODE (function_or_method_type) == METHOD_TYPE
8308 && link == first_parm_type)
8309 add_AT_flag (parm_die, DW_AT_artificial, 1);
8310 }
8311
8312 /* If this function type has an ellipsis, add a
8313 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
8314 if (formal_type != void_type_node)
8315 gen_unspecified_parameters_die (function_or_method_type, context_die);
8316
8317 /* Make our second (and final) pass over the list of formal parameter types
8318 and output DIEs to represent those types (as necessary). */
8319 for (link = TYPE_ARG_TYPES (function_or_method_type);
8320 link;
8321 link = TREE_CHAIN (link))
8322 {
8323 formal_type = TREE_VALUE (link);
8324 if (formal_type == void_type_node)
8325 break;
8326
8327 gen_type_die (formal_type, context_die);
8328 }
8329}
8330
8331/* Generate a DIE to represent a declared function (either file-scope or
8332 block-local). */
8333
8334static void
8335gen_subprogram_die (decl, context_die)
8336 register tree decl;
8337 register dw_die_ref context_die;
8338{
8339 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
8340 register tree origin = decl_ultimate_origin (decl);
8341 register dw_die_ref subr_die;
8342 register rtx fp_reg;
8343 register tree fn_arg_types;
8344 register tree outer_scope;
8345 register dw_die_ref old_die = lookup_decl_die (decl);
8346 register int declaration
8347 = (current_function_decl != decl
8348 || (context_die
8349 && (context_die->die_tag == DW_TAG_structure_type
8350 || context_die->die_tag == DW_TAG_union_type)));
8351
8352 if (origin != NULL)
8353 {
8354 subr_die = new_die (DW_TAG_subprogram, context_die);
8355 add_abstract_origin_attribute (subr_die, origin);
8356 }
8357 else if (old_die && DECL_ABSTRACT (decl)
8358 && get_AT_unsigned (old_die, DW_AT_inline))
8359 {
8360 /* This must be a redefinition of an extern inline function.
8361 We can just reuse the old die here. */
8362 subr_die = old_die;
8363
8364 /* Clear out the inlined attribute and parm types. */
8365 remove_AT (subr_die, DW_AT_inline);
8366 remove_children (subr_die);
8367 }
8368 else if (old_die)
8369 {
8370 register unsigned file_index
8371 = lookup_filename (DECL_SOURCE_FILE (decl));
8372
8373 if (get_AT_flag (old_die, DW_AT_declaration) != 1)
|
8165 abort ();
|
8374 {
8375 /* ??? This can happen if there is a bug in the program, for
8376 instance, if it has duplicate function definitions. Ideally,
8377 we should detect this case and ignore it. For now, if we have
8378 already reported an error, any error at all, then assume that
8379 we got here because of a input error, not a dwarf2 bug. */
8380 extern int errorcount;
8381 if (errorcount)
8382 return;
8383 abort ();
8384 } |
8385
8386 /* If the definition comes from the same place as the declaration,
8387 maybe use the old DIE. We always want the DIE for this function
8388 that has the *_pc attributes to be under comp_unit_die so the
8389 debugger can find it. For inlines, that is the concrete instance,
8390 so we can use the old DIE here. For non-inline methods, we want a
8391 specification DIE at toplevel, so we need a new DIE. For local
8392 class methods, this does not apply. */
8393 if ((DECL_ABSTRACT (decl) || old_die->die_parent == comp_unit_die
8394 || context_die == NULL)
8395 && get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
8396 && (get_AT_unsigned (old_die, DW_AT_decl_line)
8397 == DECL_SOURCE_LINE (decl)))
8398 {
8399 subr_die = old_die;
8400
8401 /* Clear out the declaration attribute and the parm types. */
8402 remove_AT (subr_die, DW_AT_declaration);
8403 remove_children (subr_die);
8404 }
8405 else
8406 {
8407 subr_die = new_die (DW_TAG_subprogram, context_die);
8408 add_AT_die_ref (subr_die, DW_AT_specification, old_die);
8409 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
8410 add_AT_unsigned (subr_die, DW_AT_decl_file, file_index);
8411 if (get_AT_unsigned (old_die, DW_AT_decl_line)
8412 != DECL_SOURCE_LINE (decl))
8413 add_AT_unsigned
8414 (subr_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
8415 }
8416 }
8417 else
8418 {
8419 register dw_die_ref scope_die;
8420
8421 if (DECL_CONTEXT (decl))
8422 scope_die = scope_die_for (decl, context_die);
8423 else
8424 /* Don't put block extern declarations under comp_unit_die. */
8425 scope_die = context_die;
8426
8427 subr_die = new_die (DW_TAG_subprogram, scope_die);
8428
8429 if (TREE_PUBLIC (decl))
8430 add_AT_flag (subr_die, DW_AT_external, 1);
8431
8432 add_name_and_src_coords_attributes (subr_die, decl);
8433 if (debug_info_level > DINFO_LEVEL_TERSE)
8434 {
8435 register tree type = TREE_TYPE (decl);
8436
8437 add_prototyped_attribute (subr_die, type);
8438 add_type_attribute (subr_die, TREE_TYPE (type), 0, 0, context_die);
8439 }
8440
8441 add_pure_or_virtual_attribute (subr_die, decl);
8442 if (DECL_ARTIFICIAL (decl))
8443 add_AT_flag (subr_die, DW_AT_artificial, 1);
8444 if (TREE_PROTECTED (decl))
8445 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
8446 else if (TREE_PRIVATE (decl))
8447 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
8448 }
8449
8450 if (declaration)
8451 {
8452 add_AT_flag (subr_die, DW_AT_declaration, 1);
8453
8454 /* The first time we see a member function, it is in the context of
8455 the class to which it belongs. We make sure of this by emitting
8456 the class first. The next time is the definition, which is
8457 handled above. The two may come from the same source text. */
8458 if (DECL_CONTEXT (decl))
8459 equate_decl_number_to_die (decl, subr_die);
8460 }
8461 else if (DECL_ABSTRACT (decl))
8462 {
8463 /* ??? Checking DECL_DEFER_OUTPUT is correct for static inline functions,
8464 but not for extern inline functions. We can't get this completely
8465 correct because information about whether the function was declared
8466 inline is not saved anywhere. */
8467 if (DECL_DEFER_OUTPUT (decl))
8468 {
8469 if (DECL_INLINE (decl))
8470 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
8471 else
8472 add_AT_unsigned (subr_die, DW_AT_inline,
8473 DW_INL_declared_not_inlined);
8474 }
8475 else if (DECL_INLINE (decl))
8476 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
8477 else
8478 abort ();
8479
8480 equate_decl_number_to_die (decl, subr_die);
8481 }
8482 else if (!DECL_EXTERNAL (decl))
8483 {
8484 if (origin == NULL_TREE)
8485 equate_decl_number_to_die (decl, subr_die);
8486
8487 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
8488 current_funcdef_number);
8489 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
8490 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
8491 current_funcdef_number);
8492 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
8493
8494 add_pubname (decl, subr_die);
8495 add_arange (decl, subr_die);
8496
8497#ifdef MIPS_DEBUGGING_INFO
8498 /* Add a reference to the FDE for this routine. */
8499 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
8500#endif
8501
8502 /* Define the "frame base" location for this routine. We use the
8503 frame pointer or stack pointer registers, since the RTL for local
8504 variables is relative to one of them. */
8505 fp_reg
8506 = frame_pointer_needed ? hard_frame_pointer_rtx : stack_pointer_rtx;
8507 add_AT_loc (subr_die, DW_AT_frame_base, reg_loc_descriptor (fp_reg));
8508
8509#if 0
8510 /* ??? This fails for nested inline functions, because context_display
8511 is not part of the state saved/restored for inline functions. */
8512 if (current_function_needs_context)
8513 add_AT_location_description (subr_die, DW_AT_static_link,
8514 lookup_static_chain (decl));
8515#endif
8516 }
8517
8518 /* Now output descriptions of the arguments for this function. This gets
8519 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
8520 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
8521 `...' at the end of the formal parameter list. In order to find out if
8522 there was a trailing ellipsis or not, we must instead look at the type
8523 associated with the FUNCTION_DECL. This will be a node of type
8524 FUNCTION_TYPE. If the chain of type nodes hanging off of this
8525 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
8526 an ellipsis at the end. */
8527 push_decl_scope (decl);
8528
8529 /* In the case where we are describing a mere function declaration, all we
8530 need to do here (and all we *can* do here) is to describe the *types* of
8531 its formal parameters. */
8532 if (debug_info_level <= DINFO_LEVEL_TERSE)
8533 ;
8534 else if (declaration)
8535 gen_formal_types_die (TREE_TYPE (decl), subr_die);
8536 else
8537 {
8538 /* Generate DIEs to represent all known formal parameters */
8539 register tree arg_decls = DECL_ARGUMENTS (decl);
8540 register tree parm;
8541
8542 /* When generating DIEs, generate the unspecified_parameters DIE
8543 instead if we come across the arg "__builtin_va_alist" */
8544 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
8545 if (TREE_CODE (parm) == PARM_DECL)
8546 {
8547 if (DECL_NAME (parm)
8548 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
8549 "__builtin_va_alist"))
8550 gen_unspecified_parameters_die (parm, subr_die);
8551 else
8552 gen_decl_die (parm, subr_die);
8553 }
8554
8555 /* Decide whether we need a unspecified_parameters DIE at the end.
8556 There are 2 more cases to do this for: 1) the ansi ... declaration -
8557 this is detectable when the end of the arg list is not a
8558 void_type_node 2) an unprototyped function declaration (not a
8559 definition). This just means that we have no info about the
8560 parameters at all. */
8561 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
8562 if (fn_arg_types != NULL)
8563 {
8564 /* this is the prototyped case, check for ... */
8565 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
8566 gen_unspecified_parameters_die (decl, subr_die);
8567 }
8568 else if (DECL_INITIAL (decl) == NULL_TREE)
8569 gen_unspecified_parameters_die (decl, subr_die);
8570 }
8571
8572 /* Output Dwarf info for all of the stuff within the body of the function
8573 (if it has one - it may be just a declaration). */
8574 outer_scope = DECL_INITIAL (decl);
8575
8576 /* Note that here, `outer_scope' is a pointer to the outermost BLOCK
8577 node created to represent a function. This outermost BLOCK actually
8578 represents the outermost binding contour for the function, i.e. the
8579 contour in which the function's formal parameters and labels get
8580 declared. Curiously, it appears that the front end doesn't actually
8581 put the PARM_DECL nodes for the current function onto the BLOCK_VARS
8582 list for this outer scope. (They are strung off of the DECL_ARGUMENTS
8583 list for the function instead.) The BLOCK_VARS list for the
8584 `outer_scope' does provide us with a list of the LABEL_DECL nodes for
8585 the function however, and we output DWARF info for those in
8586 decls_for_scope. Just within the `outer_scope' there will be a BLOCK
8587 node representing the function's outermost pair of curly braces, and
8588 any blocks used for the base and member initializers of a C++
8589 constructor function. */
8590 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
8591 {
8592 current_function_has_inlines = 0;
8593 decls_for_scope (outer_scope, subr_die, 0);
8594
8595#if 0 && defined (MIPS_DEBUGGING_INFO)
8596 if (current_function_has_inlines)
8597 {
8598 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
8599 if (! comp_unit_has_inlines)
8600 {
8601 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
8602 comp_unit_has_inlines = 1;
8603 }
8604 }
8605#endif
8606 }
8607
8608 pop_decl_scope ();
8609}
8610
8611/* Generate a DIE to represent a declared data object. */
8612
8613static void
8614gen_variable_die (decl, context_die)
8615 register tree decl;
8616 register dw_die_ref context_die;
8617{
8618 register tree origin = decl_ultimate_origin (decl);
8619 register dw_die_ref var_die = new_die (DW_TAG_variable, context_die);
8620
8621 dw_die_ref old_die = lookup_decl_die (decl);
8622 int declaration
8623 = (DECL_EXTERNAL (decl)
8624 || current_function_decl != decl_function_context (decl)
8625 || context_die->die_tag == DW_TAG_structure_type
8626 || context_die->die_tag == DW_TAG_union_type);
8627
8628 if (origin != NULL)
8629 add_abstract_origin_attribute (var_die, origin);
8630 /* Loop unrolling can create multiple blocks that refer to the same
8631 static variable, so we must test for the DW_AT_declaration flag. */
8632 /* ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
8633 copy decls and set the DECL_ABSTRACT flag on them instead of
8634 sharing them. */
8635 else if (old_die && TREE_STATIC (decl)
8636 && get_AT_flag (old_die, DW_AT_declaration) == 1)
8637 {
8638 /* ??? This is an instantiation of a C++ class level static. */
8639 add_AT_die_ref (var_die, DW_AT_specification, old_die);
8640 if (DECL_NAME (decl))
8641 {
8642 register unsigned file_index
8643 = lookup_filename (DECL_SOURCE_FILE (decl));
8644
8645 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
8646 add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
8647
8648 if (get_AT_unsigned (old_die, DW_AT_decl_line)
8649 != DECL_SOURCE_LINE (decl))
8650
8651 add_AT_unsigned (var_die, DW_AT_decl_line,
8652 DECL_SOURCE_LINE (decl));
8653 }
8654 }
8655 else
8656 {
8657 add_name_and_src_coords_attributes (var_die, decl);
8658 add_type_attribute (var_die, TREE_TYPE (decl),
8659 TREE_READONLY (decl),
8660 TREE_THIS_VOLATILE (decl), context_die);
8661
8662 if (TREE_PUBLIC (decl))
8663 add_AT_flag (var_die, DW_AT_external, 1);
8664
8665 if (DECL_ARTIFICIAL (decl))
8666 add_AT_flag (var_die, DW_AT_artificial, 1);
8667
8668 if (TREE_PROTECTED (decl))
8669 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
8670
8671 else if (TREE_PRIVATE (decl))
8672 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
8673 }
8674
8675 if (declaration)
8676 add_AT_flag (var_die, DW_AT_declaration, 1);
8677
8678 if ((declaration && decl_class_context (decl)) || DECL_ABSTRACT (decl))
8679 equate_decl_number_to_die (decl, var_die);
8680
8681 if (! declaration && ! DECL_ABSTRACT (decl))
8682 {
8683 equate_decl_number_to_die (decl, var_die);
8684 add_location_or_const_value_attribute (var_die, decl);
8685 add_pubname (decl, var_die);
8686 }
8687}
8688
8689/* Generate a DIE to represent a label identifier. */
8690
8691static void
8692gen_label_die (decl, context_die)
8693 register tree decl;
8694 register dw_die_ref context_die;
8695{
8696 register tree origin = decl_ultimate_origin (decl);
8697 register dw_die_ref lbl_die = new_die (DW_TAG_label, context_die);
8698 register rtx insn;
8699 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8700 char label2[MAX_ARTIFICIAL_LABEL_BYTES];
8701
8702 if (origin != NULL)
8703 add_abstract_origin_attribute (lbl_die, origin);
8704 else
8705 add_name_and_src_coords_attributes (lbl_die, decl);
8706
8707 if (DECL_ABSTRACT (decl))
8708 equate_decl_number_to_die (decl, lbl_die);
8709 else
8710 {
8711 insn = DECL_RTL (decl);
|
8493 if (GET_CODE (insn) == CODE_LABEL)
|
8712
8713 /* Deleted labels are programmer specified labels which have been
8714 eliminated because of various optimisations. We still emit them
8715 here so that it is possible to put breakpoints on them. */
8716 if (GET_CODE (insn) == CODE_LABEL
8717 || ((GET_CODE (insn) == NOTE
8718 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL))) |
8719 {
8720 /* When optimization is enabled (via -O) some parts of the compiler
8721 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
8722 represent source-level labels which were explicitly declared by
8723 the user. This really shouldn't be happening though, so catch
8724 it if it ever does happen. */
8725 if (INSN_DELETED_P (insn))
8726 abort ();
8727
8728 sprintf (label2, INSN_LABEL_FMT, current_funcdef_number);
8729 ASM_GENERATE_INTERNAL_LABEL (label, label2,
8730 (unsigned) INSN_UID (insn));
8731 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
8732 }
8733 }
8734}
8735
8736/* Generate a DIE for a lexical block. */
8737
8738static void
8739gen_lexical_block_die (stmt, context_die, depth)
8740 register tree stmt;
8741 register dw_die_ref context_die;
8742 int depth;
8743{
8744 register dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die);
8745 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8746
8747 if (! BLOCK_ABSTRACT (stmt))
8748 {
8749 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
8750 next_block_number);
8751 add_AT_lbl_id (stmt_die, DW_AT_low_pc, label);
8752 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
8753 add_AT_lbl_id (stmt_die, DW_AT_high_pc, label);
8754 }
8755
8756 push_decl_scope (stmt);
8757 decls_for_scope (stmt, stmt_die, depth);
8758 pop_decl_scope ();
8759}
8760
8761/* Generate a DIE for an inlined subprogram. */
8762
8763static void
8764gen_inlined_subroutine_die (stmt, context_die, depth)
8765 register tree stmt;
8766 register dw_die_ref context_die;
8767 int depth;
8768{
8769 if (! BLOCK_ABSTRACT (stmt))
8770 {
8771 register dw_die_ref subr_die
8772 = new_die (DW_TAG_inlined_subroutine, context_die);
8773 register tree decl = block_ultimate_origin (stmt);
8774 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8775
8776 add_abstract_origin_attribute (subr_die, decl);
8777 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
8778 next_block_number);
8779 add_AT_lbl_id (subr_die, DW_AT_low_pc, label);
8780 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
8781 add_AT_lbl_id (subr_die, DW_AT_high_pc, label);
8782 push_decl_scope (decl);
8783 decls_for_scope (stmt, subr_die, depth);
8784 pop_decl_scope ();
8785 current_function_has_inlines = 1;
8786 }
8787}
8788
8789/* Generate a DIE for a field in a record, or structure. */
8790
8791static void
8792gen_field_die (decl, context_die)
8793 register tree decl;
8794 register dw_die_ref context_die;
8795{
8796 register dw_die_ref decl_die = new_die (DW_TAG_member, context_die);
8797
8798 add_name_and_src_coords_attributes (decl_die, decl);
8799 add_type_attribute (decl_die, member_declared_type (decl),
8800 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
8801 context_die);
8802
8803 /* If this is a bit field... */
8804 if (DECL_BIT_FIELD_TYPE (decl))
8805 {
8806 add_byte_size_attribute (decl_die, decl);
8807 add_bit_size_attribute (decl_die, decl);
8808 add_bit_offset_attribute (decl_die, decl);
8809 }
8810
8811 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
8812 add_data_member_location_attribute (decl_die, decl);
8813
8814 if (DECL_ARTIFICIAL (decl))
8815 add_AT_flag (decl_die, DW_AT_artificial, 1);
8816
8817 if (TREE_PROTECTED (decl))
8818 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
8819
8820 else if (TREE_PRIVATE (decl))
8821 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
8822}
8823
8824#if 0
8825/* Don't generate either pointer_type DIEs or reference_type DIEs here.
8826 Use modified_type_die instead.
8827 We keep this code here just in case these types of DIEs may be needed to
8828 represent certain things in other languages (e.g. Pascal) someday. */
8829static void
8830gen_pointer_type_die (type, context_die)
8831 register tree type;
8832 register dw_die_ref context_die;
8833{
8834 register dw_die_ref ptr_die
8835 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die));
8836
8837 equate_type_number_to_die (type, ptr_die);
8838 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
8839 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
8840}
8841
8842/* Don't generate either pointer_type DIEs or reference_type DIEs here.
8843 Use modified_type_die instead.
8844 We keep this code here just in case these types of DIEs may be needed to
8845 represent certain things in other languages (e.g. Pascal) someday. */
8846static void
8847gen_reference_type_die (type, context_die)
8848 register tree type;
8849 register dw_die_ref context_die;
8850{
8851 register dw_die_ref ref_die
8852 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die));
8853
8854 equate_type_number_to_die (type, ref_die);
8855 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
8856 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
8857}
8858#endif
8859
8860/* Generate a DIE for a pointer to a member type. */
8861static void
8862gen_ptr_to_mbr_type_die (type, context_die)
8863 register tree type;
8864 register dw_die_ref context_die;
8865{
8866 register dw_die_ref ptr_die
8867 = new_die (DW_TAG_ptr_to_member_type, scope_die_for (type, context_die));
8868
8869 equate_type_number_to_die (type, ptr_die);
8870 add_AT_die_ref (ptr_die, DW_AT_containing_type,
8871 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
8872 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
8873}
8874
8875/* Generate the DIE for the compilation unit. */
8876
8877static void
8878gen_compile_unit_die (main_input_filename)
8879 register char *main_input_filename;
8880{
8881 char producer[250];
8882 char *wd = getpwd ();
8883
8884 comp_unit_die = new_die (DW_TAG_compile_unit, NULL);
8885 add_name_attribute (comp_unit_die, main_input_filename);
8886
8887 if (wd != NULL)
8888 add_AT_string (comp_unit_die, DW_AT_comp_dir, wd);
8889
8890 sprintf (producer, "%s %s", language_string, version_string);
8891
8892#ifdef MIPS_DEBUGGING_INFO
8893 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
8894 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
8895 not appear in the producer string, the debugger reaches the conclusion
8896 that the object file is stripped and has no debugging information.
8897 To get the MIPS/SGI debugger to believe that there is debugging
8898 information in the object file, we add a -g to the producer string. */
8899 if (debug_info_level > DINFO_LEVEL_TERSE)
8900 strcat (producer, " -g");
8901#endif
8902
8903 add_AT_string (comp_unit_die, DW_AT_producer, producer);
8904
8905 if (strcmp (language_string, "GNU C++") == 0)
8906 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C_plus_plus);
8907
8908 else if (strcmp (language_string, "GNU Ada") == 0)
8909 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Ada83);
8910
8911 else if (strcmp (language_string, "GNU F77") == 0)
8912 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Fortran77);
8913
8914 else if (strcmp (language_string, "GNU Pascal") == 0)
8915 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Pascal83);
8916
8917 else if (flag_traditional)
8918 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C);
8919
8920 else
8921 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C89);
8922
8923#if 0 /* unimplemented */
8924 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
8925 add_AT_unsigned (comp_unit_die, DW_AT_macro_info, 0);
8926#endif
8927}
8928
8929/* Generate a DIE for a string type. */
8930
8931static void
8932gen_string_type_die (type, context_die)
8933 register tree type;
8934 register dw_die_ref context_die;
8935{
8936 register dw_die_ref type_die
8937 = new_die (DW_TAG_string_type, scope_die_for (type, context_die));
8938
8939 equate_type_number_to_die (type, type_die);
8940
8941 /* Fudge the string length attribute for now. */
8942
8943 /* TODO: add string length info.
8944 string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
8945 bound_representation (upper_bound, 0, 'u'); */
8946}
8947
8948/* Generate the DIE for a base class. */
8949
8950static void
8951gen_inheritance_die (binfo, context_die)
8952 register tree binfo;
8953 register dw_die_ref context_die;
8954{
8955 dw_die_ref die = new_die (DW_TAG_inheritance, context_die);
8956
8957 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
8958 add_data_member_location_attribute (die, binfo);
8959
8960 if (TREE_VIA_VIRTUAL (binfo))
8961 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
8962 if (TREE_VIA_PUBLIC (binfo))
8963 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
8964 else if (TREE_VIA_PROTECTED (binfo))
8965 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
8966}
8967
8968/* Generate a DIE for a class member. */
8969
8970static void
8971gen_member_die (type, context_die)
8972 register tree type;
8973 register dw_die_ref context_die;
8974{
8975 register tree member;
8976
8977 /* If this is not an incomplete type, output descriptions of each of its
8978 members. Note that as we output the DIEs necessary to represent the
8979 members of this record or union type, we will also be trying to output
8980 DIEs to represent the *types* of those members. However the `type'
8981 function (above) will specifically avoid generating type DIEs for member
8982 types *within* the list of member DIEs for this (containing) type execpt
8983 for those types (of members) which are explicitly marked as also being
8984 members of this (containing) type themselves. The g++ front- end can
8985 force any given type to be treated as a member of some other
8986 (containing) type by setting the TYPE_CONTEXT of the given (member) type
8987 to point to the TREE node representing the appropriate (containing)
8988 type. */
8989
8990 /* First output info about the base classes. */
8991 if (TYPE_BINFO (type) && TYPE_BINFO_BASETYPES (type))
8992 {
8993 register tree bases = TYPE_BINFO_BASETYPES (type);
8994 register int n_bases = TREE_VEC_LENGTH (bases);
8995 register int i;
8996
8997 for (i = 0; i < n_bases; i++)
8998 gen_inheritance_die (TREE_VEC_ELT (bases, i), context_die);
8999 }
9000
9001 /* Now output info about the data members and type members. */
9002 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
9003 gen_decl_die (member, context_die);
9004
9005 /* Now output info about the function members (if any). */
9006 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
9007 gen_decl_die (member, context_die);
9008}
9009
9010/* Generate a DIE for a structure or union type. */
9011
9012static void
9013gen_struct_or_union_type_die (type, context_die)
9014 register tree type;
9015 register dw_die_ref context_die;
9016{
9017 register dw_die_ref type_die = lookup_type_die (type);
9018 register dw_die_ref scope_die = 0;
9019 register int nested = 0;
9020
9021 if (type_die && ! TYPE_SIZE (type))
9022 return;
9023
9024 if (TYPE_CONTEXT (type) != NULL_TREE
|
8800 && TREE_CODE_CLASS (TREE_CODE (TYPE_CONTEXT (type))) == 't')
|
| 9025 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))) |
9026 nested = 1;
9027
9028 scope_die = scope_die_for (type, context_die);
9029
9030 if (! type_die || (nested && scope_die == comp_unit_die))
9031 /* First occurrence of type or toplevel definition of nested class. */
9032 {
9033 register dw_die_ref old_die = type_die;
9034
9035 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
9036 ? DW_TAG_structure_type : DW_TAG_union_type,
9037 scope_die);
9038 equate_type_number_to_die (type, type_die);
9039 add_name_attribute (type_die, type_tag (type));
9040 if (old_die)
9041 add_AT_die_ref (type_die, DW_AT_specification, old_die);
9042 }
9043 else
9044 remove_AT (type_die, DW_AT_declaration);
9045
9046 /* If we're not in the right context to be defining this type, defer to
9047 avoid tricky recursion. */
9048 if (TYPE_SIZE (type) && decl_scope_depth > 0 && scope_die == comp_unit_die)
9049 {
9050 add_AT_flag (type_die, DW_AT_declaration, 1);
9051 pend_type (type);
9052 }
9053 /* If this type has been completed, then give it a byte_size attribute and
9054 then give a list of members. */
9055 else if (TYPE_SIZE (type))
9056 {
9057 /* Prevent infinite recursion in cases where the type of some member of
9058 this type is expressed in terms of this type itself. */
9059 TREE_ASM_WRITTEN (type) = 1;
9060 add_byte_size_attribute (type_die, type);
9061 if (TYPE_STUB_DECL (type) != NULL_TREE)
9062 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
9063
9064 /* If the first reference to this type was as the return type of an
9065 inline function, then it may not have a parent. Fix this now. */
9066 if (type_die->die_parent == NULL)
9067 add_child_die (scope_die, type_die);
9068
9069 push_decl_scope (type);
9070 gen_member_die (type, type_die);
9071 pop_decl_scope ();
9072
9073 /* GNU extension: Record what type our vtable lives in. */
9074 if (TYPE_VFIELD (type))
9075 {
9076 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
9077
9078 gen_type_die (vtype, context_die);
9079 add_AT_die_ref (type_die, DW_AT_containing_type,
9080 lookup_type_die (vtype));
9081 }
9082 }
9083 else
|
8859 add_AT_flag (type_die, DW_AT_declaration, 1);
|
9084 {
9085 add_AT_flag (type_die, DW_AT_declaration, 1);
9086
9087 /* We can't do this for function-local types, and we don't need to. */
9088 if (TREE_PERMANENT (type))
9089 add_incomplete_type (type);
9090 } |
9091}
9092
9093/* Generate a DIE for a subroutine _type_. */
9094
9095static void
9096gen_subroutine_type_die (type, context_die)
9097 register tree type;
9098 register dw_die_ref context_die;
9099{
9100 register tree return_type = TREE_TYPE (type);
9101 register dw_die_ref subr_die
9102 = new_die (DW_TAG_subroutine_type, scope_die_for (type, context_die));
9103
9104 equate_type_number_to_die (type, subr_die);
9105 add_prototyped_attribute (subr_die, type);
9106 add_type_attribute (subr_die, return_type, 0, 0, context_die);
9107 gen_formal_types_die (type, subr_die);
9108}
9109
9110/* Generate a DIE for a type definition */
9111
9112static void
9113gen_typedef_die (decl, context_die)
9114 register tree decl;
9115 register dw_die_ref context_die;
9116{
9117 register dw_die_ref type_die;
9118 register tree origin;
9119
9120 if (TREE_ASM_WRITTEN (decl))
9121 return;
9122 TREE_ASM_WRITTEN (decl) = 1;
9123
9124 type_die = new_die (DW_TAG_typedef, scope_die_for (decl, context_die));
9125 origin = decl_ultimate_origin (decl);
9126 if (origin != NULL)
9127 add_abstract_origin_attribute (type_die, origin);
9128 else
9129 {
9130 register tree type;
9131 add_name_and_src_coords_attributes (type_die, decl);
9132 if (DECL_ORIGINAL_TYPE (decl))
9133 {
9134 type = DECL_ORIGINAL_TYPE (decl);
9135 equate_type_number_to_die (TREE_TYPE (decl), type_die);
9136 }
9137 else
9138 type = TREE_TYPE (decl);
9139 add_type_attribute (type_die, type, TREE_READONLY (decl),
9140 TREE_THIS_VOLATILE (decl), context_die);
9141 }
9142
9143 if (DECL_ABSTRACT (decl))
9144 equate_decl_number_to_die (decl, type_die);
9145}
9146
9147/* Generate a type description DIE. */
9148
9149static void
9150gen_type_die (type, context_die)
9151 register tree type;
9152 register dw_die_ref context_die;
9153{
9154 if (type == NULL_TREE || type == error_mark_node)
9155 return;
9156
9157 /* We are going to output a DIE to represent the unqualified version of
9158 this type (i.e. without any const or volatile qualifiers) so get the
9159 main variant (i.e. the unqualified version) of this type now. */
9160 type = type_main_variant (type);
9161
9162 if (TREE_ASM_WRITTEN (type))
9163 return;
9164
9165 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
9166 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
9167 {
9168 TREE_ASM_WRITTEN (type) = 1;
9169 gen_decl_die (TYPE_NAME (type), context_die);
9170 return;
9171 }
9172
9173 switch (TREE_CODE (type))
9174 {
9175 case ERROR_MARK:
9176 break;
9177
9178 case POINTER_TYPE:
9179 case REFERENCE_TYPE:
9180 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
9181 ensures that the gen_type_die recursion will terminate even if the
9182 type is recursive. Recursive types are possible in Ada. */
9183 /* ??? We could perhaps do this for all types before the switch
9184 statement. */
9185 TREE_ASM_WRITTEN (type) = 1;
9186
9187 /* For these types, all that is required is that we output a DIE (or a
9188 set of DIEs) to represent the "basis" type. */
9189 gen_type_die (TREE_TYPE (type), context_die);
9190 break;
9191
9192 case OFFSET_TYPE:
9193 /* This code is used for C++ pointer-to-data-member types.
9194 Output a description of the relevant class type. */
9195 gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
9196
9197 /* Output a description of the type of the object pointed to. */
9198 gen_type_die (TREE_TYPE (type), context_die);
9199
9200 /* Now output a DIE to represent this pointer-to-data-member type
9201 itself. */
9202 gen_ptr_to_mbr_type_die (type, context_die);
9203 break;
9204
9205 case SET_TYPE:
9206 gen_type_die (TYPE_DOMAIN (type), context_die);
9207 gen_set_type_die (type, context_die);
9208 break;
9209
9210 case FILE_TYPE:
9211 gen_type_die (TREE_TYPE (type), context_die);
9212 abort (); /* No way to represent these in Dwarf yet! */
9213 break;
9214
9215 case FUNCTION_TYPE:
9216 /* Force out return type (in case it wasn't forced out already). */
9217 gen_type_die (TREE_TYPE (type), context_die);
9218 gen_subroutine_type_die (type, context_die);
9219 break;
9220
9221 case METHOD_TYPE:
9222 /* Force out return type (in case it wasn't forced out already). */
9223 gen_type_die (TREE_TYPE (type), context_die);
9224 gen_subroutine_type_die (type, context_die);
9225 break;
9226
9227 case ARRAY_TYPE:
9228 if (TYPE_STRING_FLAG (type) && TREE_CODE (TREE_TYPE (type)) == CHAR_TYPE)
9229 {
9230 gen_type_die (TREE_TYPE (type), context_die);
9231 gen_string_type_die (type, context_die);
9232 }
9233 else
9234 gen_array_type_die (type, context_die);
9235 break;
9236
9237 case ENUMERAL_TYPE:
9238 case RECORD_TYPE:
9239 case UNION_TYPE:
9240 case QUAL_UNION_TYPE:
9241 /* If this is a nested type whose containing class hasn't been
9242 written out yet, writing it out will cover this one, too. */
9243 if (TYPE_CONTEXT (type)
|
9013 && TREE_CODE_CLASS (TREE_CODE (TYPE_CONTEXT (type))) == 't'
|
| 9244 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)) |
9245 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
9246 {
9247 gen_type_die (TYPE_CONTEXT (type), context_die);
9248
9249 if (TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
9250 return;
9251
9252 /* If that failed, attach ourselves to the stub. */
9253 push_decl_scope (TYPE_CONTEXT (type));
9254 context_die = lookup_type_die (TYPE_CONTEXT (type));
9255 }
9256
9257 if (TREE_CODE (type) == ENUMERAL_TYPE)
9258 gen_enumeration_type_die (type, context_die);
9259 else
9260 gen_struct_or_union_type_die (type, context_die);
9261
9262 if (TYPE_CONTEXT (type)
|
9032 && TREE_CODE_CLASS (TREE_CODE (TYPE_CONTEXT (type))) == 't'
|
| 9263 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)) |
9264 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
9265 pop_decl_scope ();
9266
9267 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
9268 it up if it is ever completed. gen_*_type_die will set it for us
9269 when appropriate. */
9270 return;
9271
9272 case VOID_TYPE:
9273 case INTEGER_TYPE:
9274 case REAL_TYPE:
9275 case COMPLEX_TYPE:
9276 case BOOLEAN_TYPE:
9277 case CHAR_TYPE:
9278 /* No DIEs needed for fundamental types. */
9279 break;
9280
9281 case LANG_TYPE:
9282 /* No Dwarf representation currently defined. */
9283 break;
9284
9285 default:
9286 abort ();
9287 }
9288
9289 TREE_ASM_WRITTEN (type) = 1;
9290}
9291
9292/* Generate a DIE for a tagged type instantiation. */
9293
9294static void
9295gen_tagged_type_instantiation_die (type, context_die)
9296 register tree type;
9297 register dw_die_ref context_die;
9298{
9299 if (type == NULL_TREE || type == error_mark_node)
9300 return;
9301
9302 /* We are going to output a DIE to represent the unqualified version of
9303 this type (i.e. without any const or volatile qualifiers) so make sure
9304 that we have the main variant (i.e. the unqualified version) of this
9305 type now. */
9306 if (type != type_main_variant (type)
9307 || !TREE_ASM_WRITTEN (type))
9308 abort ();
9309
9310 switch (TREE_CODE (type))
9311 {
9312 case ERROR_MARK:
9313 break;
9314
9315 case ENUMERAL_TYPE:
9316 gen_inlined_enumeration_type_die (type, context_die);
9317 break;
9318
9319 case RECORD_TYPE:
9320 gen_inlined_structure_type_die (type, context_die);
9321 break;
9322
9323 case UNION_TYPE:
9324 case QUAL_UNION_TYPE:
9325 gen_inlined_union_type_die (type, context_die);
9326 break;
9327
9328 default:
9329 abort ();
9330 }
9331}
9332
9333/* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
9334 things which are local to the given block. */
9335
9336static void
9337gen_block_die (stmt, context_die, depth)
9338 register tree stmt;
9339 register dw_die_ref context_die;
9340 int depth;
9341{
9342 register int must_output_die = 0;
9343 register tree origin;
9344 register tree decl;
9345 register enum tree_code origin_code;
9346
9347 /* Ignore blocks never really used to make RTL. */
9348
9349 if (stmt == NULL_TREE || !TREE_USED (stmt))
9350 return;
9351
9352 /* Determine the "ultimate origin" of this block. This block may be an
9353 inlined instance of an inlined instance of inline function, so we have
9354 to trace all of the way back through the origin chain to find out what
9355 sort of node actually served as the original seed for the creation of
9356 the current block. */
9357 origin = block_ultimate_origin (stmt);
9358 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
9359
9360 /* Determine if we need to output any Dwarf DIEs at all to represent this
9361 block. */
9362 if (origin_code == FUNCTION_DECL)
9363 /* The outer scopes for inlinings *must* always be represented. We
9364 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
9365 must_output_die = 1;
9366 else
9367 {
9368 /* In the case where the current block represents an inlining of the
9369 "body block" of an inline function, we must *NOT* output any DIE for
9370 this block because we have already output a DIE to represent the
9371 whole inlined function scope and the "body block" of any function
9372 doesn't really represent a different scope according to ANSI C
9373 rules. So we check here to make sure that this block does not
9374 represent a "body block inlining" before trying to set the
9375 `must_output_die' flag. */
9376 if (! is_body_block (origin ? origin : stmt))
9377 {
9378 /* Determine if this block directly contains any "significant"
9379 local declarations which we will need to output DIEs for. */
9380 if (debug_info_level > DINFO_LEVEL_TERSE)
9381 /* We are not in terse mode so *any* local declaration counts
9382 as being a "significant" one. */
9383 must_output_die = (BLOCK_VARS (stmt) != NULL);
9384 else
9385 /* We are in terse mode, so only local (nested) function
9386 definitions count as "significant" local declarations. */
9387 for (decl = BLOCK_VARS (stmt);
9388 decl != NULL; decl = TREE_CHAIN (decl))
9389 if (TREE_CODE (decl) == FUNCTION_DECL
9390 && DECL_INITIAL (decl))
9391 {
9392 must_output_die = 1;
9393 break;
9394 }
9395 }
9396 }
9397
9398 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
9399 DIE for any block which contains no significant local declarations at
9400 all. Rather, in such cases we just call `decls_for_scope' so that any
9401 needed Dwarf info for any sub-blocks will get properly generated. Note
9402 that in terse mode, our definition of what constitutes a "significant"
9403 local declaration gets restricted to include only inlined function
9404 instances and local (nested) function definitions. */
9405 if (must_output_die)
9406 {
9407 if (origin_code == FUNCTION_DECL)
9408 gen_inlined_subroutine_die (stmt, context_die, depth);
9409 else
9410 gen_lexical_block_die (stmt, context_die, depth);
9411 }
9412 else
9413 decls_for_scope (stmt, context_die, depth);
9414}
9415
9416/* Generate all of the decls declared within a given scope and (recursively)
9417 all of its sub-blocks. */
9418
9419static void
9420decls_for_scope (stmt, context_die, depth)
9421 register tree stmt;
9422 register dw_die_ref context_die;
9423 int depth;
9424{
9425 register tree decl;
9426 register tree subblocks;
9427
9428 /* Ignore blocks never really used to make RTL. */
9429 if (stmt == NULL_TREE || ! TREE_USED (stmt))
9430 return;
9431
9432 if (!BLOCK_ABSTRACT (stmt) && depth > 0)
9433 next_block_number++;
9434
9435 /* Output the DIEs to represent all of the data objects and typedefs
9436 declared directly within this block but not within any nested
9437 sub-blocks. Also, nested function and tag DIEs have been
9438 generated with a parent of NULL; fix that up now. */
9439 for (decl = BLOCK_VARS (stmt);
9440 decl != NULL; decl = TREE_CHAIN (decl))
9441 {
9442 register dw_die_ref die;
9443
9444 if (TREE_CODE (decl) == FUNCTION_DECL)
9445 die = lookup_decl_die (decl);
9446 else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
9447 die = lookup_type_die (TREE_TYPE (decl));
9448 else
9449 die = NULL;
9450
9451 if (die != NULL && die->die_parent == NULL)
9452 add_child_die (context_die, die);
9453 else
9454 gen_decl_die (decl, context_die);
9455 }
9456
9457 /* Output the DIEs to represent all sub-blocks (and the items declared
9458 therein) of this block. */
9459 for (subblocks = BLOCK_SUBBLOCKS (stmt);
9460 subblocks != NULL;
9461 subblocks = BLOCK_CHAIN (subblocks))
9462 gen_block_die (subblocks, context_die, depth + 1);
9463}
9464
9465/* Is this a typedef we can avoid emitting? */
9466
9467static inline int
9468is_redundant_typedef (decl)
9469 register tree decl;
9470{
9471 if (TYPE_DECL_IS_STUB (decl))
9472 return 1;
9473
9474 if (DECL_ARTIFICIAL (decl)
9475 && DECL_CONTEXT (decl)
9476 && is_tagged_type (DECL_CONTEXT (decl))
9477 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
9478 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
9479 /* Also ignore the artificial member typedef for the class name. */
9480 return 1;
9481
9482 return 0;
9483}
9484
9485/* Generate Dwarf debug information for a decl described by DECL. */
9486
9487static void
9488gen_decl_die (decl, context_die)
9489 register tree decl;
9490 register dw_die_ref context_die;
9491{
9492 register tree origin;
9493
9494 /* Make a note of the decl node we are going to be working on. We may need
9495 to give the user the source coordinates of where it appeared in case we
9496 notice (later on) that something about it looks screwy. */
9497 dwarf_last_decl = decl;
9498
9499 if (TREE_CODE (decl) == ERROR_MARK)
9500 return;
9501
9502 /* If this ..._DECL node is marked to be ignored, then ignore it. But don't
9503 ignore a function definition, since that would screw up our count of
9504 blocks, and that in turn will completely screw up the labels we will
9505 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9506 subsequent blocks). */
9507 if (DECL_IGNORED_P (decl) && TREE_CODE (decl) != FUNCTION_DECL)
9508 return;
9509
9510 switch (TREE_CODE (decl))
9511 {
9512 case CONST_DECL:
9513 /* The individual enumerators of an enum type get output when we output
9514 the Dwarf representation of the relevant enum type itself. */
9515 break;
9516
9517 case FUNCTION_DECL:
9518 /* Don't output any DIEs to represent mere function declarations,
9519 unless they are class members or explicit block externs. */
9520 if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
9521 && (current_function_decl == NULL_TREE || ! DECL_ARTIFICIAL (decl)))
9522 break;
9523
9524 if (debug_info_level > DINFO_LEVEL_TERSE)
9525 {
9526 /* Before we describe the FUNCTION_DECL itself, make sure that we
9527 have described its return type. */
9528 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
9529
9530 /* And its containing type. */
9531 origin = decl_class_context (decl);
9532 if (origin != NULL_TREE)
9533 gen_type_die (origin, context_die);
9534
9535 /* And its virtual context. */
9536 if (DECL_VINDEX (decl) != NULL_TREE)
9537 gen_type_die (DECL_CONTEXT (decl), context_die);
9538 }
9539
9540 /* Now output a DIE to represent the function itself. */
9541 gen_subprogram_die (decl, context_die);
9542 break;
9543
9544 case TYPE_DECL:
9545 /* If we are in terse mode, don't generate any DIEs to represent any
9546 actual typedefs. */
9547 if (debug_info_level <= DINFO_LEVEL_TERSE)
9548 break;
9549
9550 /* In the special case of a TYPE_DECL node representing the
9551 declaration of some type tag, if the given TYPE_DECL is marked as
9552 having been instantiated from some other (original) TYPE_DECL node
9553 (e.g. one which was generated within the original definition of an
9554 inline function) we have to generate a special (abbreviated)
9555 DW_TAG_structure_type, DW_TAG_union_type, or DW_TAG_enumeration_type
9556 DIE here. */
9557 if (TYPE_DECL_IS_STUB (decl) && DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
9558 {
9559 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
9560 break;
9561 }
9562
9563 if (is_redundant_typedef (decl))
9564 gen_type_die (TREE_TYPE (decl), context_die);
9565 else
9566 /* Output a DIE to represent the typedef itself. */
9567 gen_typedef_die (decl, context_die);
9568 break;
9569
9570 case LABEL_DECL:
9571 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9572 gen_label_die (decl, context_die);
9573 break;
9574
9575 case VAR_DECL:
9576 /* If we are in terse mode, don't generate any DIEs to represent any
9577 variable declarations or definitions. */
9578 if (debug_info_level <= DINFO_LEVEL_TERSE)
9579 break;
9580
9581 /* Output any DIEs that are needed to specify the type of this data
9582 object. */
9583 gen_type_die (TREE_TYPE (decl), context_die);
9584
9585 /* And its containing type. */
9586 origin = decl_class_context (decl);
9587 if (origin != NULL_TREE)
9588 gen_type_die (origin, context_die);
9589
9590 /* Now output the DIE to represent the data object itself. This gets
9591 complicated because of the possibility that the VAR_DECL really
9592 represents an inlined instance of a formal parameter for an inline
9593 function. */
9594 origin = decl_ultimate_origin (decl);
9595 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
9596 gen_formal_parameter_die (decl, context_die);
9597 else
9598 gen_variable_die (decl, context_die);
9599 break;
9600
9601 case FIELD_DECL:
9602 /* Ignore the nameless fields that are used to skip bits, but
9603 handle C++ anonymous unions. */
9604 if (DECL_NAME (decl) != NULL_TREE
9605 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE)
9606 {
9607 gen_type_die (member_declared_type (decl), context_die);
9608 gen_field_die (decl, context_die);
9609 }
9610 break;
9611
9612 case PARM_DECL:
9613 gen_type_die (TREE_TYPE (decl), context_die);
9614 gen_formal_parameter_die (decl, context_die);
9615 break;
9616
9617 default:
9618 abort ();
9619 }
9620}
9621
9622/* Write the debugging output for DECL. */
9623
9624void
9625dwarf2out_decl (decl)
9626 register tree decl;
9627{
9628 register dw_die_ref context_die = comp_unit_die;
9629
9630 if (TREE_CODE (decl) == ERROR_MARK)
9631 return;
9632
9633 /* If this ..._DECL node is marked to be ignored, then ignore it. We gotta
9634 hope that the node in question doesn't represent a function definition.
9635 If it does, then totally ignoring it is bound to screw up our count of
9636 blocks, and that in turn will completely screw up the labels we will
9637 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9638 subsequent blocks). (It's too bad that BLOCK nodes don't carry their
9639 own sequence numbers with them!) */
9640 if (DECL_IGNORED_P (decl))
9641 {
9642 if (TREE_CODE (decl) == FUNCTION_DECL
|
9412 && DECL_INITIAL (decl) != NULL)
|
| 9643 && DECL_INITIAL (decl) != NULL) |
9644 abort ();
9645
9646 return;
9647 }
9648
9649 switch (TREE_CODE (decl))
9650 {
9651 case FUNCTION_DECL:
9652 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of a
9653 builtin function. Explicit programmer-supplied declarations of
9654 these same functions should NOT be ignored however. */
9655 if (DECL_EXTERNAL (decl) && DECL_FUNCTION_CODE (decl))
9656 return;
9657
9658 /* What we would really like to do here is to filter out all mere
9659 file-scope declarations of file-scope functions which are never
9660 referenced later within this translation unit (and keep all of ones
9661 that *are* referenced later on) but we aren't clairvoyant, so we have
9662 no idea which functions will be referenced in the future (i.e. later
9663 on within the current translation unit). So here we just ignore all
9664 file-scope function declarations which are not also definitions. If
9665 and when the debugger needs to know something about these functions,
9666 it wil have to hunt around and find the DWARF information associated
9667 with the definition of the function. Note that we can't just check
9668 `DECL_EXTERNAL' to find out which FUNCTION_DECL nodes represent
9669 definitions and which ones represent mere declarations. We have to
9670 check `DECL_INITIAL' instead. That's because the C front-end
9671 supports some weird semantics for "extern inline" function
9672 definitions. These can get inlined within the current translation
9673 unit (an thus, we need to generate DWARF info for their abstract
9674 instances so that the DWARF info for the concrete inlined instances
9675 can have something to refer to) but the compiler never generates any
9676 out-of-lines instances of such things (despite the fact that they
9677 *are* definitions). The important point is that the C front-end
9678 marks these "extern inline" functions as DECL_EXTERNAL, but we need
9679 to generate DWARF for them anyway. Note that the C++ front-end also
9680 plays some similar games for inline function definitions appearing
9681 within include files which also contain
9682 `#pragma interface' pragmas. */
9683 if (DECL_INITIAL (decl) == NULL_TREE)
9684 return;
9685
9686 /* If we're a nested function, initially use a parent of NULL; if we're
9687 a plain function, this will be fixed up in decls_for_scope. If
9688 we're a method, it will be ignored, since we already have a DIE. */
9689 if (decl_function_context (decl))
9690 context_die = NULL;
9691
9692 break;
9693
9694 case VAR_DECL:
9695 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
9696 declaration and if the declaration was never even referenced from
9697 within this entire compilation unit. We suppress these DIEs in
9698 order to save space in the .debug section (by eliminating entries
9699 which are probably useless). Note that we must not suppress
9700 block-local extern declarations (whether used or not) because that
9701 would screw-up the debugger's name lookup mechanism and cause it to
9702 miss things which really ought to be in scope at a given point. */
9703 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
9704 return;
9705
9706 /* If we are in terse mode, don't generate any DIEs to represent any
9707 variable declarations or definitions. */
9708 if (debug_info_level <= DINFO_LEVEL_TERSE)
9709 return;
9710 break;
9711
9712 case TYPE_DECL:
9713 /* Don't bother trying to generate any DIEs to represent any of the
9714 normal built-in types for the language we are compiling. */
9715 if (DECL_SOURCE_LINE (decl) == 0)
9716 {
9717 /* OK, we need to generate one for `bool' so GDB knows what type
9718 comparisons have. */
9719 if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
9720 == DW_LANG_C_plus_plus)
9721 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE)
9722 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
9723
9724 return;
9725 }
9726
9727 /* If we are in terse mode, don't generate any DIEs for types. */
9728 if (debug_info_level <= DINFO_LEVEL_TERSE)
9729 return;
9730
9731 /* If we're a function-scope tag, initially use a parent of NULL;
9732 this will be fixed up in decls_for_scope. */
9733 if (decl_function_context (decl))
9734 context_die = NULL;
9735
9736 break;
9737
9738 default:
9739 return;
9740 }
9741
9742 gen_decl_die (decl, context_die);
9743 output_pending_types_for_scope (comp_unit_die);
9744}
9745
9746/* Output a marker (i.e. a label) for the beginning of the generated code for
9747 a lexical block. */
9748
9749void
9750dwarf2out_begin_block (blocknum)
9751 register unsigned blocknum;
9752{
9753 function_section (current_function_decl);
9754 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
9755}
9756
9757/* Output a marker (i.e. a label) for the end of the generated code for a
9758 lexical block. */
9759
9760void
9761dwarf2out_end_block (blocknum)
9762 register unsigned blocknum;
9763{
9764 function_section (current_function_decl);
9765 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
9766}
9767
9768/* Output a marker (i.e. a label) at a point in the assembly code which
9769 corresponds to a given source level label. */
9770
9771void
9772dwarf2out_label (insn)
9773 register rtx insn;
9774{
9775 char label[MAX_ARTIFICIAL_LABEL_BYTES];
9776
9777 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9778 {
9779 function_section (current_function_decl);
9780 sprintf (label, INSN_LABEL_FMT, current_funcdef_number);
9781 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, label,
9782 (unsigned) INSN_UID (insn));
9783 }
9784}
9785
9786/* Lookup a filename (in the list of filenames that we know about here in
9787 dwarf2out.c) and return its "index". The index of each (known) filename is
9788 just a unique number which is associated with only that one filename.
9789 We need such numbers for the sake of generating labels
9790 (in the .debug_sfnames section) and references to those
9791 files numbers (in the .debug_srcinfo and.debug_macinfo sections).
9792 If the filename given as an argument is not found in our current list,
9793 add it to the list and assign it the next available unique index number.
9794 In order to speed up searches, we remember the index of the filename
9795 was looked up last. This handles the majority of all searches. */
9796
9797static unsigned
9798lookup_filename (file_name)
9799 char *file_name;
9800{
9801 static unsigned last_file_lookup_index = 0;
9802 register unsigned i;
9803
9804 /* Check to see if the file name that was searched on the previous call
9805 matches this file name. If so, return the index. */
9806 if (last_file_lookup_index != 0)
9807 if (strcmp (file_name, file_table[last_file_lookup_index]) == 0)
9808 return last_file_lookup_index;
9809
9810 /* Didn't match the previous lookup, search the table */
9811 for (i = 1; i < file_table_in_use; ++i)
9812 if (strcmp (file_name, file_table[i]) == 0)
9813 {
9814 last_file_lookup_index = i;
9815 return i;
9816 }
9817
9818 /* Prepare to add a new table entry by making sure there is enough space in
9819 the table to do so. If not, expand the current table. */
9820 if (file_table_in_use == file_table_allocated)
9821 {
9822 file_table_allocated += FILE_TABLE_INCREMENT;
9823 file_table
9824 = (char **) xrealloc (file_table,
9825 file_table_allocated * sizeof (char *));
9826 }
9827
9828 /* Add the new entry to the end of the filename table. */
9829 file_table[file_table_in_use] = xstrdup (file_name);
9830 last_file_lookup_index = file_table_in_use++;
9831
9832 return last_file_lookup_index;
9833}
9834
9835/* Output a label to mark the beginning of a source code line entry
9836 and record information relating to this source line, in
9837 'line_info_table' for later output of the .debug_line section. */
9838
9839void
9840dwarf2out_line (filename, line)
9841 register char *filename;
9842 register unsigned line;
9843{
9844 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9845 {
9846 function_section (current_function_decl);
9847
9848 if (DECL_SECTION_NAME (current_function_decl))
9849 {
9850 register dw_separate_line_info_ref line_info;
9851 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, SEPARATE_LINE_CODE_LABEL,
9852 separate_line_info_table_in_use);
9853 fputc ('\n', asm_out_file);
9854
9855 /* expand the line info table if necessary */
9856 if (separate_line_info_table_in_use
9857 == separate_line_info_table_allocated)
9858 {
9859 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
9860 separate_line_info_table
9861 = (dw_separate_line_info_ref)
9862 xrealloc (separate_line_info_table,
9863 separate_line_info_table_allocated
9864 * sizeof (dw_separate_line_info_entry));
9865 }
9866
9867 /* Add the new entry at the end of the line_info_table. */
9868 line_info
9869 = &separate_line_info_table[separate_line_info_table_in_use++];
9870 line_info->dw_file_num = lookup_filename (filename);
9871 line_info->dw_line_num = line;
9872 line_info->function = current_funcdef_number;
9873 }
9874 else
9875 {
9876 register dw_line_info_ref line_info;
9877
9878 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, LINE_CODE_LABEL,
9879 line_info_table_in_use);
9880 fputc ('\n', asm_out_file);
9881
9882 /* Expand the line info table if necessary. */
9883 if (line_info_table_in_use == line_info_table_allocated)
9884 {
9885 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
9886 line_info_table
9887 = (dw_line_info_ref)
9888 xrealloc (line_info_table,
9889 (line_info_table_allocated
9890 * sizeof (dw_line_info_entry)));
9891 }
9892
9893 /* Add the new entry at the end of the line_info_table. */
9894 line_info = &line_info_table[line_info_table_in_use++];
9895 line_info->dw_file_num = lookup_filename (filename);
9896 line_info->dw_line_num = line;
9897 }
9898 }
9899}
9900
9901/* Record the beginning of a new source file, for later output
9902 of the .debug_macinfo section. At present, unimplemented. */
9903
9904void
9905dwarf2out_start_source_file (filename)
9906 register char *filename ATTRIBUTE_UNUSED;
9907{
9908}
9909
9910/* Record the end of a source file, for later output
9911 of the .debug_macinfo section. At present, unimplemented. */
9912
9913void
9914dwarf2out_end_source_file ()
9915{
9916}
9917
9918/* Called from check_newline in c-parse.y. The `buffer' parameter contains
9919 the tail part of the directive line, i.e. the part which is past the
9920 initial whitespace, #, whitespace, directive-name, whitespace part. */
9921
9922void
9923dwarf2out_define (lineno, buffer)
9924 register unsigned lineno;
9925 register char *buffer;
9926{
9927 static int initialized = 0;
9928 if (!initialized)
9929 {
9930 dwarf2out_start_source_file (primary_filename);
9931 initialized = 1;
9932 }
9933}
9934
9935/* Called from check_newline in c-parse.y. The `buffer' parameter contains
9936 the tail part of the directive line, i.e. the part which is past the
9937 initial whitespace, #, whitespace, directive-name, whitespace part. */
9938
9939void
9940dwarf2out_undef (lineno, buffer)
9941 register unsigned lineno ATTRIBUTE_UNUSED;
9942 register char *buffer ATTRIBUTE_UNUSED;
9943{
9944}
9945
9946/* Set up for Dwarf output at the start of compilation. */
9947
9948void
9949dwarf2out_init (asm_out_file, main_input_filename)
9950 register FILE *asm_out_file;
9951 register char *main_input_filename;
9952{
9953 /* Remember the name of the primary input file. */
9954 primary_filename = main_input_filename;
9955
9956 /* Allocate the initial hunk of the file_table. */
9957 file_table = (char **) xmalloc (FILE_TABLE_INCREMENT * sizeof (char *));
9958 bzero ((char *) file_table, FILE_TABLE_INCREMENT * sizeof (char *));
9959 file_table_allocated = FILE_TABLE_INCREMENT;
9960
9961 /* Skip the first entry - file numbers begin at 1. */
9962 file_table_in_use = 1;
9963
9964 /* Allocate the initial hunk of the decl_die_table. */
9965 decl_die_table
9966 = (dw_die_ref *) xmalloc (DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
9967 bzero ((char *) decl_die_table,
9968 DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
9969 decl_die_table_allocated = DECL_DIE_TABLE_INCREMENT;
9970 decl_die_table_in_use = 0;
9971
9972 /* Allocate the initial hunk of the decl_scope_table. */
9973 decl_scope_table
9974 = (decl_scope_node *) xmalloc (DECL_SCOPE_TABLE_INCREMENT
9975 * sizeof (decl_scope_node));
9976 bzero ((char *) decl_scope_table,
9977 DECL_SCOPE_TABLE_INCREMENT * sizeof (decl_scope_node));
9978 decl_scope_table_allocated = DECL_SCOPE_TABLE_INCREMENT;
9979 decl_scope_depth = 0;
9980
9981 /* Allocate the initial hunk of the abbrev_die_table. */
9982 abbrev_die_table
9983 = (dw_die_ref *) xmalloc (ABBREV_DIE_TABLE_INCREMENT
9984 * sizeof (dw_die_ref));
9985 bzero ((char *) abbrev_die_table,
9986 ABBREV_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
9987 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
9988 /* Zero-th entry is allocated, but unused */
9989 abbrev_die_table_in_use = 1;
9990
9991 /* Allocate the initial hunk of the line_info_table. */
9992 line_info_table
9993 = (dw_line_info_ref) xmalloc (LINE_INFO_TABLE_INCREMENT
9994 * sizeof (dw_line_info_entry));
9995 bzero ((char *) line_info_table,
9996 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
9997 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
9998 /* Zero-th entry is allocated, but unused */
9999 line_info_table_in_use = 1;
10000
10001 /* Generate the initial DIE for the .debug section. Note that the (string)
10002 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
10003 will (typically) be a relative pathname and that this pathname should be
10004 taken as being relative to the directory from which the compiler was
10005 invoked when the given (base) source file was compiled. */
10006 gen_compile_unit_die (main_input_filename);
10007
10008 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
|
10009 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label, ABBREV_SECTION_LABEL, 0);
10010 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
10011 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
10012 DEBUG_INFO_SECTION_LABEL, 0);
10013 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
10014 DEBUG_LINE_SECTION_LABEL, 0);
10015
10016 ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION);
10017 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
10018 ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION);
10019 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
10020 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_INFO_SECTION);
10021 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
10022 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_LINE_SECTION);
10023 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label); |
10024}
10025
10026/* Output stuff that dwarf requires at the end of every file,
10027 and generate the DWARF-2 debugging info. */
10028
10029void
10030dwarf2out_finish ()
10031{
10032 limbo_die_node *node, *next_node;
10033 dw_die_ref die;
10034 dw_attr_ref a;
10035
10036 /* Traverse the limbo die list, and add parent/child links. The only
10037 dies without parents that should be here are concrete instances of
10038 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
10039 For concrete instances, we can get the parent die from the abstract
10040 instance. */
10041 for (node = limbo_die_list; node; node = next_node)
10042 {
10043 next_node = node->next;
10044 die = node->die;
10045
10046 if (die->die_parent == NULL)
10047 {
10048 a = get_AT (die, DW_AT_abstract_origin);
10049 if (a)
10050 add_child_die (a->dw_attr_val.v.val_die_ref->die_parent, die);
10051 else if (die == comp_unit_die)
10052 ;
10053 else
10054 abort ();
10055 }
10056 free (node);
10057 }
10058
|
10059 /* Walk through the list of incomplete types again, trying once more to
10060 emit full debugging info for them. */
10061 retry_incomplete_types ();
10062 |
10063 /* Traverse the DIE tree and add sibling attributes to those DIE's
10064 that have children. */
10065 add_sibling_attributes (comp_unit_die);
10066
10067 /* Output a terminator label for the .text section. */
10068 fputc ('\n', asm_out_file);
10069 ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION);
10070 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, TEXT_END_LABEL, 0);
10071
10072#if 0
10073 /* Output a terminator label for the .data section. */
10074 fputc ('\n', asm_out_file);
10075 ASM_OUTPUT_SECTION (asm_out_file, DATA_SECTION);
10076 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, DATA_END_LABEL, 0);
10077
10078 /* Output a terminator label for the .bss section. */
10079 fputc ('\n', asm_out_file);
10080 ASM_OUTPUT_SECTION (asm_out_file, BSS_SECTION);
10081 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BSS_END_LABEL, 0);
10082#endif
10083
10084 /* Output the source line correspondence table. */
10085 if (line_info_table_in_use > 1 || separate_line_info_table_in_use)
10086 {
10087 fputc ('\n', asm_out_file);
10088 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_LINE_SECTION);
10089 output_line_info ();
10090
10091 /* We can only use the low/high_pc attributes if all of the code
10092 was in .text. */
10093 if (separate_line_info_table_in_use == 0)
10094 {
|
9845 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, TEXT_SECTION);
|
| 10095 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label); |
10096 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
10097 }
10098
|
9849 add_AT_section_offset (comp_unit_die, DW_AT_stmt_list, DEBUG_LINE_SECTION);
|
10099 add_AT_lbl_offset (comp_unit_die, DW_AT_stmt_list,
10100 debug_line_section_label); |
10101 }
10102
10103 /* Output the abbreviation table. */
10104 fputc ('\n', asm_out_file);
10105 ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION);
10106 build_abbrev_table (comp_unit_die);
10107 output_abbrev_section ();
10108
10109 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
10110 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
10111 calc_die_sizes (comp_unit_die);
10112
10113 /* Output debugging information. */
10114 fputc ('\n', asm_out_file);
10115 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_INFO_SECTION);
10116 output_compilation_unit_header ();
10117 output_die (comp_unit_die);
10118
10119 if (pubname_table_in_use)
10120 {
10121 /* Output public names table. */
10122 fputc ('\n', asm_out_file);
10123 ASM_OUTPUT_SECTION (asm_out_file, PUBNAMES_SECTION);
10124 output_pubnames ();
10125 }
10126
10127 if (fde_table_in_use)
10128 {
10129 /* Output the address range information. */
10130 fputc ('\n', asm_out_file);
10131 ASM_OUTPUT_SECTION (asm_out_file, ARANGES_SECTION);
10132 output_aranges ();
10133 }
10134}
10135#endif /* DWARF2_DEBUGGING_INFO */
|