1/* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
4 Contributed by Gary Funck (gary@intrepid.com).
5 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
6 Extensively modified by Jason Merrill (jason@cygnus.com).
7
8This file is part of GCC.
9
10GCC is free software; you can redistribute it and/or modify it under
11the terms of the GNU General Public License as published by the Free
12Software Foundation; either version 2, or (at your option) any later
13version.
14
15GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16WARRANTY; without even the implied warranty of MERCHANTABILITY or
17FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18for more details.
19
20You should have received a copy of the GNU General Public License
21along with GCC; see the file COPYING. If not, write to the Free
22Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
2302110-1301, USA. */
24
25/* TODO: Emit .debug_line header even when there are no functions, since
26 the file numbers are used by .debug_info. Alternately, leave
27 out locations for types and decls.
28 Avoid talking about ctors and op= for PODs.
29 Factor out common prologue sequences into multiple CIEs. */
30
31/* The first part of this file deals with the DWARF 2 frame unwind
32 information, which is also used by the GCC efficient exception handling
33 mechanism. The second part, controlled only by an #ifdef
34 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
35 information. */
36
37#include "config.h"
38#include "system.h"
39#include "coretypes.h"
40#include "tm.h"
41#include "tree.h"
42#include "version.h"
43#include "flags.h"
44#include "real.h"
45#include "rtl.h"
46#include "hard-reg-set.h"
47#include "regs.h"
48#include "insn-config.h"
49#include "reload.h"
50#include "function.h"
51#include "output.h"
52#include "expr.h"
53#include "libfuncs.h"
54#include "except.h"
55#include "dwarf2.h"
56#include "dwarf2out.h"
57#include "dwarf2asm.h"
58#include "toplev.h"
59#include "varray.h"
60#include "ggc.h"
61#include "md5.h"
62#include "tm_p.h"
63#include "diagnostic.h"
64#include "debug.h"
65#include "target.h"
66#include "langhooks.h"
67#include "hashtab.h"
68#include "cgraph.h"
69#include "input.h"
70
71#ifdef DWARF2_DEBUGGING_INFO
72static void dwarf2out_source_line (unsigned int, const char *);
73#endif
74
75/* DWARF2 Abbreviation Glossary:
76 CFA = Canonical Frame Address
77 a fixed address on the stack which identifies a call frame.
78 We define it to be the value of SP just before the call insn.
79 The CFA register and offset, which may change during the course
80 of the function, are used to calculate its value at runtime.
81 CFI = Call Frame Instruction
82 an instruction for the DWARF2 abstract machine
83 CIE = Common Information Entry
84 information describing information common to one or more FDEs
85 DIE = Debugging Information Entry
86 FDE = Frame Description Entry
87 information describing the stack call frame, in particular,
88 how to restore registers
89
90 DW_CFA_... = DWARF2 CFA call frame instruction
91 DW_TAG_... = DWARF2 DIE tag */
92
93#ifndef DWARF2_FRAME_INFO
94# ifdef DWARF2_DEBUGGING_INFO
95# define DWARF2_FRAME_INFO \
96 (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
97# else
98# define DWARF2_FRAME_INFO 0
99# endif
100#endif
101
102/* Map register numbers held in the call frame info that gcc has
103 collected using DWARF_FRAME_REGNUM to those that should be output in
104 .debug_frame and .eh_frame. */
105#ifndef DWARF2_FRAME_REG_OUT
106#define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
107#endif
108
109/* Decide whether we want to emit frame unwind information for the current
110 translation unit. */
111
112int
113dwarf2out_do_frame (void)
114{
115 /* We want to emit correct CFA location expressions or lists, so we
116 have to return true if we're going to output debug info, even if
117 we're not going to output frame or unwind info. */
118 return (write_symbols == DWARF2_DEBUG
119 || write_symbols == VMS_AND_DWARF2_DEBUG
120 || DWARF2_FRAME_INFO
121#ifdef DWARF2_UNWIND_INFO
122 || (DWARF2_UNWIND_INFO
123 && (flag_unwind_tables
124 || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)))
125#endif
126 );
127}
128
129/* The size of the target's pointer type. */
130#ifndef PTR_SIZE
131#define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
132#endif
133
134/* Array of RTXes referenced by the debugging information, which therefore
135 must be kept around forever. */
136static GTY(()) VEC(rtx,gc) *used_rtx_array;
137
138/* A pointer to the base of a list of incomplete types which might be
139 completed at some later time. incomplete_types_list needs to be a
140 VEC(tree,gc) because we want to tell the garbage collector about
141 it. */
142static GTY(()) VEC(tree,gc) *incomplete_types;
143
144/* A pointer to the base of a table of references to declaration
145 scopes. This table is a display which tracks the nesting
146 of declaration scopes at the current scope and containing
147 scopes. This table is used to find the proper place to
148 define type declaration DIE's. */
149static GTY(()) VEC(tree,gc) *decl_scope_table;
150
151/* Pointers to various DWARF2 sections. */
152static GTY(()) section *debug_info_section;
153static GTY(()) section *debug_abbrev_section;
154static GTY(()) section *debug_aranges_section;
155static GTY(()) section *debug_macinfo_section;
156static GTY(()) section *debug_line_section;
157static GTY(()) section *debug_loc_section;
158static GTY(()) section *debug_pubnames_section;
159static GTY(()) section *debug_str_section;
160static GTY(()) section *debug_ranges_section;
161static GTY(()) section *debug_frame_section;
162
163/* How to start an assembler comment. */
164#ifndef ASM_COMMENT_START
165#define ASM_COMMENT_START ";#"
166#endif
167
168typedef struct dw_cfi_struct *dw_cfi_ref;
169typedef struct dw_fde_struct *dw_fde_ref;
170typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
171
172/* Call frames are described using a sequence of Call Frame
173 Information instructions. The register number, offset
174 and address fields are provided as possible operands;
175 their use is selected by the opcode field. */
176
177enum dw_cfi_oprnd_type {
178 dw_cfi_oprnd_unused,
179 dw_cfi_oprnd_reg_num,
180 dw_cfi_oprnd_offset,
181 dw_cfi_oprnd_addr,
182 dw_cfi_oprnd_loc
183};
184
185typedef union dw_cfi_oprnd_struct GTY(())
186{
187 unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
188 HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
189 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
190 struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
191}
192dw_cfi_oprnd;
193
194typedef struct dw_cfi_struct GTY(())
195{
196 dw_cfi_ref dw_cfi_next;
197 enum dwarf_call_frame_info dw_cfi_opc;
198 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
199 dw_cfi_oprnd1;
200 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
201 dw_cfi_oprnd2;
202}
203dw_cfi_node;
204
205/* This is how we define the location of the CFA. We use to handle it
206 as REG + OFFSET all the time, but now it can be more complex.
207 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
208 Instead of passing around REG and OFFSET, we pass a copy
209 of this structure. */
210typedef struct cfa_loc GTY(())
211{
212 HOST_WIDE_INT offset;
213 HOST_WIDE_INT base_offset;
214 unsigned int reg;
215 int indirect; /* 1 if CFA is accessed via a dereference. */
216} dw_cfa_location;
217
218/* All call frame descriptions (FDE's) in the GCC generated DWARF
219 refer to a single Common Information Entry (CIE), defined at
220 the beginning of the .debug_frame section. This use of a single
221 CIE obviates the need to keep track of multiple CIE's
222 in the DWARF generation routines below. */
223
224typedef struct dw_fde_struct GTY(())
225{
226 tree decl;
227 const char *dw_fde_begin;
228 const char *dw_fde_current_label;
229 const char *dw_fde_end;
230 const char *dw_fde_hot_section_label;
231 const char *dw_fde_hot_section_end_label;
232 const char *dw_fde_unlikely_section_label;
233 const char *dw_fde_unlikely_section_end_label;
234 bool dw_fde_switched_sections;
235 dw_cfi_ref dw_fde_cfi;
236 unsigned funcdef_number;
237 unsigned all_throwers_are_sibcalls : 1;
238 unsigned nothrow : 1;
239 unsigned uses_eh_lsda : 1;
240}
241dw_fde_node;
242
243/* Maximum size (in bytes) of an artificially generated label. */
244#define MAX_ARTIFICIAL_LABEL_BYTES 30
245
246/* The size of addresses as they appear in the Dwarf 2 data.
247 Some architectures use word addresses to refer to code locations,
248 but Dwarf 2 info always uses byte addresses. On such machines,
249 Dwarf 2 addresses need to be larger than the architecture's
250 pointers. */
251#ifndef DWARF2_ADDR_SIZE
252#define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
253#endif
254
255/* The size in bytes of a DWARF field indicating an offset or length
256 relative to a debug info section, specified to be 4 bytes in the
257 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same
258 as PTR_SIZE. */
259
260#ifndef DWARF_OFFSET_SIZE
261#define DWARF_OFFSET_SIZE 4
262#endif
263
264/* According to the (draft) DWARF 3 specification, the initial length
265 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
266 bytes are 0xffffffff, followed by the length stored in the next 8
267 bytes.
268
269 However, the SGI/MIPS ABI uses an initial length which is equal to
270 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
271
272#ifndef DWARF_INITIAL_LENGTH_SIZE
273#define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
274#endif
275
276#define DWARF_VERSION 2
277
278/* Round SIZE up to the nearest BOUNDARY. */
279#define DWARF_ROUND(SIZE,BOUNDARY) \
280 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
281
282/* Offsets recorded in opcodes are a multiple of this alignment factor. */
283#ifndef DWARF_CIE_DATA_ALIGNMENT
284#ifdef STACK_GROWS_DOWNWARD
285#define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
286#else
287#define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
288#endif
289#endif
290
291/* CIE identifier. */
292#if HOST_BITS_PER_WIDE_INT >= 64
293#define DWARF_CIE_ID \
294 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
295#else
296#define DWARF_CIE_ID DW_CIE_ID
297#endif
298
299/* A pointer to the base of a table that contains frame description
300 information for each routine. */
301static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
302
303/* Number of elements currently allocated for fde_table. */
304static GTY(()) unsigned fde_table_allocated;
305
306/* Number of elements in fde_table currently in use. */
307static GTY(()) unsigned fde_table_in_use;
308
309/* Size (in elements) of increments by which we may expand the
310 fde_table. */
311#define FDE_TABLE_INCREMENT 256
312
313/* A list of call frame insns for the CIE. */
314static GTY(()) dw_cfi_ref cie_cfi_head;
315
316#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
317/* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
318 attribute that accelerates the lookup of the FDE associated
319 with the subprogram. This variable holds the table index of the FDE
320 associated with the current function (body) definition. */
321static unsigned current_funcdef_fde;
322#endif
323
324struct indirect_string_node GTY(())
325{
326 const char *str;
327 unsigned int refcount;
328 unsigned int form;
329 char *label;
330};
331
332static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
333
334static GTY(()) int dw2_string_counter;
335static GTY(()) unsigned long dwarf2out_cfi_label_num;
336
337#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
338
339/* Forward declarations for functions defined in this file. */
340
341static char *stripattributes (const char *);
342static const char *dwarf_cfi_name (unsigned);
343static dw_cfi_ref new_cfi (void);
344static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
345static void add_fde_cfi (const char *, dw_cfi_ref);
346static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *);
347static void lookup_cfa (dw_cfa_location *);
348static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
349static void initial_return_save (rtx);
350static HOST_WIDE_INT stack_adjust_offset (rtx);
351static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
352static void output_call_frame_info (int);
353static void dwarf2out_stack_adjust (rtx, bool);
354static void flush_queued_reg_saves (void);
355static bool clobbers_queued_reg_save (rtx);
356static void dwarf2out_frame_debug_expr (rtx, const char *);
357
358/* Support for complex CFA locations. */
359static void output_cfa_loc (dw_cfi_ref);
360static void get_cfa_from_loc_descr (dw_cfa_location *,
361 struct dw_loc_descr_struct *);
362static struct dw_loc_descr_struct *build_cfa_loc
363 (dw_cfa_location *, HOST_WIDE_INT);
364static void def_cfa_1 (const char *, dw_cfa_location *);
365
366/* How to start an assembler comment. */
367#ifndef ASM_COMMENT_START
368#define ASM_COMMENT_START ";#"
369#endif
370
371/* Data and reference forms for relocatable data. */
372#define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
373#define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
374
375#ifndef DEBUG_FRAME_SECTION
376#define DEBUG_FRAME_SECTION ".debug_frame"
377#endif
378
379#ifndef FUNC_BEGIN_LABEL
380#define FUNC_BEGIN_LABEL "LFB"
381#endif
382
383#ifndef FUNC_END_LABEL
384#define FUNC_END_LABEL "LFE"
385#endif
386
387#ifndef FRAME_BEGIN_LABEL
388#define FRAME_BEGIN_LABEL "Lframe"
389#endif
390#define CIE_AFTER_SIZE_LABEL "LSCIE"
391#define CIE_END_LABEL "LECIE"
392#define FDE_LABEL "LSFDE"
393#define FDE_AFTER_SIZE_LABEL "LASFDE"
394#define FDE_END_LABEL "LEFDE"
395#define LINE_NUMBER_BEGIN_LABEL "LSLT"
396#define LINE_NUMBER_END_LABEL "LELT"
397#define LN_PROLOG_AS_LABEL "LASLTP"
398#define LN_PROLOG_END_LABEL "LELTP"
399#define DIE_LABEL_PREFIX "DW"
400
401/* The DWARF 2 CFA column which tracks the return address. Normally this
402 is the column for PC, or the first column after all of the hard
403 registers. */
404#ifndef DWARF_FRAME_RETURN_COLUMN
405#ifdef PC_REGNUM
406#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
407#else
408#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
409#endif
410#endif
411
412/* The mapping from gcc register number to DWARF 2 CFA column number. By
413 default, we just provide columns for all registers. */
414#ifndef DWARF_FRAME_REGNUM
415#define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
416#endif
417
418/* Hook used by __throw. */
419
420rtx
421expand_builtin_dwarf_sp_column (void)
422{
423 unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
424 return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1));
425}
426
427/* Return a pointer to a copy of the section string name S with all
428 attributes stripped off, and an asterisk prepended (for assemble_name). */
429
430static inline char *
431stripattributes (const char *s)
432{
433 char *stripped = XNEWVEC (char, strlen (s) + 2);
434 char *p = stripped;
435
436 *p++ = '*';
437
438 while (*s && *s != ',')
439 *p++ = *s++;
440
441 *p = '\0';
442 return stripped;
443}
444
445/* Generate code to initialize the register size table. */
446
447void
448expand_builtin_init_dwarf_reg_sizes (tree address)
449{
450 unsigned int i;
451 enum machine_mode mode = TYPE_MODE (char_type_node);
452 rtx addr = expand_normal (address);
453 rtx mem = gen_rtx_MEM (BLKmode, addr);
454 bool wrote_return_column = false;
455
456 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
457 {
458 int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);
459
460 if (rnum < DWARF_FRAME_REGISTERS)
461 {
462 HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);
463 enum machine_mode save_mode = reg_raw_mode[i];
464 HOST_WIDE_INT size;
465
466 if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
467 save_mode = choose_hard_reg_mode (i, 1, true);
468 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
469 {
470 if (save_mode == VOIDmode)
471 continue;
472 wrote_return_column = true;
473 }
474 size = GET_MODE_SIZE (save_mode);
475 if (offset < 0)
476 continue;
477
478 emit_move_insn (adjust_address (mem, mode, offset),
479 gen_int_mode (size, mode));
480 }
481 }
482
483#ifdef DWARF_ALT_FRAME_RETURN_COLUMN
484 gcc_assert (wrote_return_column);
485 i = DWARF_ALT_FRAME_RETURN_COLUMN;
486 wrote_return_column = false;
487#else
488 i = DWARF_FRAME_RETURN_COLUMN;
489#endif
490
491 if (! wrote_return_column)
492 {
493 enum machine_mode save_mode = Pmode;
494 HOST_WIDE_INT offset = i * GET_MODE_SIZE (mode);
495 HOST_WIDE_INT size = GET_MODE_SIZE (save_mode);
496 emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
497 }
498}
499
500/* Convert a DWARF call frame info. operation to its string name */
501
502static const char *
503dwarf_cfi_name (unsigned int cfi_opc)
504{
505 switch (cfi_opc)
506 {
507 case DW_CFA_advance_loc:
508 return "DW_CFA_advance_loc";
509 case DW_CFA_offset:
510 return "DW_CFA_offset";
511 case DW_CFA_restore:
512 return "DW_CFA_restore";
513 case DW_CFA_nop:
514 return "DW_CFA_nop";
515 case DW_CFA_set_loc:
516 return "DW_CFA_set_loc";
517 case DW_CFA_advance_loc1:
518 return "DW_CFA_advance_loc1";
519 case DW_CFA_advance_loc2:
520 return "DW_CFA_advance_loc2";
521 case DW_CFA_advance_loc4:
522 return "DW_CFA_advance_loc4";
523 case DW_CFA_offset_extended:
524 return "DW_CFA_offset_extended";
525 case DW_CFA_restore_extended:
526 return "DW_CFA_restore_extended";
527 case DW_CFA_undefined:
528 return "DW_CFA_undefined";
529 case DW_CFA_same_value:
530 return "DW_CFA_same_value";
531 case DW_CFA_register:
532 return "DW_CFA_register";
533 case DW_CFA_remember_state:
534 return "DW_CFA_remember_state";
535 case DW_CFA_restore_state:
536 return "DW_CFA_restore_state";
537 case DW_CFA_def_cfa:
538 return "DW_CFA_def_cfa";
539 case DW_CFA_def_cfa_register:
540 return "DW_CFA_def_cfa_register";
541 case DW_CFA_def_cfa_offset:
542 return "DW_CFA_def_cfa_offset";
543
544 /* DWARF 3 */
545 case DW_CFA_def_cfa_expression:
546 return "DW_CFA_def_cfa_expression";
547 case DW_CFA_expression:
548 return "DW_CFA_expression";
549 case DW_CFA_offset_extended_sf:
550 return "DW_CFA_offset_extended_sf";
551 case DW_CFA_def_cfa_sf:
552 return "DW_CFA_def_cfa_sf";
553 case DW_CFA_def_cfa_offset_sf:
554 return "DW_CFA_def_cfa_offset_sf";
555
556 /* SGI/MIPS specific */
557 case DW_CFA_MIPS_advance_loc8:
558 return "DW_CFA_MIPS_advance_loc8";
559
560 /* GNU extensions */
561 case DW_CFA_GNU_window_save:
562 return "DW_CFA_GNU_window_save";
563 case DW_CFA_GNU_args_size:
564 return "DW_CFA_GNU_args_size";
565 case DW_CFA_GNU_negative_offset_extended:
566 return "DW_CFA_GNU_negative_offset_extended";
567
568 default:
569 return "DW_CFA_<unknown>";
570 }
571}
572
573/* Return a pointer to a newly allocated Call Frame Instruction. */
574
575static inline dw_cfi_ref
576new_cfi (void)
577{
578 dw_cfi_ref cfi = ggc_alloc (sizeof (dw_cfi_node));
579
580 cfi->dw_cfi_next = NULL;
581 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
582 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
583
584 return cfi;
585}
586
587/* Add a Call Frame Instruction to list of instructions. */
588
589static inline void
590add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
591{
592 dw_cfi_ref *p;
593
594 /* Find the end of the chain. */
595 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
596 ;
597
598 *p = cfi;
599}
600
601/* Generate a new label for the CFI info to refer to. */
602
603char *
604dwarf2out_cfi_label (void)
605{
606 static char label[20];
607
608 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
609 ASM_OUTPUT_LABEL (asm_out_file, label);
610 return label;
611}
612
613/* Add CFI to the current fde at the PC value indicated by LABEL if specified,
614 or to the CIE if LABEL is NULL. */
615
616static void
617add_fde_cfi (const char *label, dw_cfi_ref cfi)
618{
619 if (label)
620 {
621 dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
622
623 if (*label == 0)
624 label = dwarf2out_cfi_label ();
625
626 if (fde->dw_fde_current_label == NULL
627 || strcmp (label, fde->dw_fde_current_label) != 0)
628 {
629 dw_cfi_ref xcfi;
630
631 label = xstrdup (label);
632
633 /* Set the location counter to the new label. */
634 xcfi = new_cfi ();
635 /* If we have a current label, advance from there, otherwise
636 set the location directly using set_loc. */
637 xcfi->dw_cfi_opc = fde->dw_fde_current_label
638 ? DW_CFA_advance_loc4
639 : DW_CFA_set_loc;
640 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
641 add_cfi (&fde->dw_fde_cfi, xcfi);
642
643 fde->dw_fde_current_label = label;
644 }
645
646 add_cfi (&fde->dw_fde_cfi, cfi);
647 }
648
649 else
650 add_cfi (&cie_cfi_head, cfi);
651}
652
653/* Subroutine of lookup_cfa. */
654
655static void
656lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc)
657{
658 switch (cfi->dw_cfi_opc)
659 {
660 case DW_CFA_def_cfa_offset:
661 loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
662 break;
663 case DW_CFA_def_cfa_offset_sf:
664 loc->offset
665 = cfi->dw_cfi_oprnd1.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT;
666 break;
667 case DW_CFA_def_cfa_register:
668 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
669 break;
670 case DW_CFA_def_cfa:
671 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
672 loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
673 break;
674 case DW_CFA_def_cfa_sf:
675 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
676 loc->offset
677 = cfi->dw_cfi_oprnd2.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT;
678 break;
679 case DW_CFA_def_cfa_expression:
680 get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
681 break;
682 default:
683 break;
684 }
685}
686
687/* Find the previous value for the CFA. */
688
689static void
690lookup_cfa (dw_cfa_location *loc)
691{
692 dw_cfi_ref cfi;
693
694 loc->reg = INVALID_REGNUM;
695 loc->offset = 0;
696 loc->indirect = 0;
697 loc->base_offset = 0;
698
699 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
700 lookup_cfa_1 (cfi, loc);
701
702 if (fde_table_in_use)
703 {
704 dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
705 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
706 lookup_cfa_1 (cfi, loc);
707 }
708}
709
710/* The current rule for calculating the DWARF2 canonical frame address. */
711static dw_cfa_location cfa;
712
713/* The register used for saving registers to the stack, and its offset
714 from the CFA. */
715static dw_cfa_location cfa_store;
716
717/* The running total of the size of arguments pushed onto the stack. */
718static HOST_WIDE_INT args_size;
719
720/* The last args_size we actually output. */
721static HOST_WIDE_INT old_args_size;
722
723/* Entry point to update the canonical frame address (CFA).
724 LABEL is passed to add_fde_cfi. The value of CFA is now to be
725 calculated from REG+OFFSET. */
726
727void
728dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
729{
730 dw_cfa_location loc;
731 loc.indirect = 0;
732 loc.base_offset = 0;
733 loc.reg = reg;
734 loc.offset = offset;
735 def_cfa_1 (label, &loc);
736}
737
738/* Determine if two dw_cfa_location structures define the same data. */
739
740static bool
741cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2)
742{
743 return (loc1->reg == loc2->reg
744 && loc1->offset == loc2->offset
745 && loc1->indirect == loc2->indirect
746 && (loc1->indirect == 0
747 || loc1->base_offset == loc2->base_offset));
748}
749
750/* This routine does the actual work. The CFA is now calculated from
751 the dw_cfa_location structure. */
752
753static void
754def_cfa_1 (const char *label, dw_cfa_location *loc_p)
755{
756 dw_cfi_ref cfi;
757 dw_cfa_location old_cfa, loc;
758
759 cfa = *loc_p;
760 loc = *loc_p;
761
762 if (cfa_store.reg == loc.reg && loc.indirect == 0)
763 cfa_store.offset = loc.offset;
764
765 loc.reg = DWARF_FRAME_REGNUM (loc.reg);
766 lookup_cfa (&old_cfa);
767
768 /* If nothing changed, no need to issue any call frame instructions. */
769 if (cfa_equal_p (&loc, &old_cfa))
770 return;
771
772 cfi = new_cfi ();
773
774 if (loc.reg == old_cfa.reg && !loc.indirect)
775 {
776 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
777 the CFA register did not change but the offset did. */
778 if (loc.offset < 0)
779 {
780 HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT;
781 gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset);
782
783 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf;
784 cfi->dw_cfi_oprnd1.dw_cfi_offset = f_offset;
785 }
786 else
787 {
788 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
789 cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
790 }
791 }
792
793#ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
794 else if (loc.offset == old_cfa.offset
795 && old_cfa.reg != INVALID_REGNUM
796 && !loc.indirect)
797 {
798 /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
799 indicating the CFA register has changed to <register> but the
800 offset has not changed. */
801 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
802 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
803 }
804#endif
805
806 else if (loc.indirect == 0)
807 {
808 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
809 indicating the CFA register has changed to <register> with
810 the specified offset. */
811 if (loc.offset < 0)
812 {
813 HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT;
814 gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset);
815
816 cfi->dw_cfi_opc = DW_CFA_def_cfa_sf;
817 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
818 cfi->dw_cfi_oprnd2.dw_cfi_offset = f_offset;
819 }
820 else
821 {
822 cfi->dw_cfi_opc = DW_CFA_def_cfa;
823 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
824 cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
825 }
826 }
827 else
828 {
829 /* Construct a DW_CFA_def_cfa_expression instruction to
830 calculate the CFA using a full location expression since no
831 register-offset pair is available. */
832 struct dw_loc_descr_struct *loc_list;
833
834 cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
835 loc_list = build_cfa_loc (&loc, 0);
836 cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
837 }
838
839 add_fde_cfi (label, cfi);
840}
841
842/* Add the CFI for saving a register. REG is the CFA column number.
843 LABEL is passed to add_fde_cfi.
844 If SREG is -1, the register is saved at OFFSET from the CFA;
845 otherwise it is saved in SREG. */
846
847static void
848reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
849{
850 dw_cfi_ref cfi = new_cfi ();
851
852 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
853
854 if (sreg == INVALID_REGNUM)
855 {
856 if (reg & ~0x3f)
857 /* The register number won't fit in 6 bits, so we have to use
858 the long form. */
859 cfi->dw_cfi_opc = DW_CFA_offset_extended;
860 else
861 cfi->dw_cfi_opc = DW_CFA_offset;
862
863#ifdef ENABLE_CHECKING
864 {
865 /* If we get an offset that is not a multiple of
866 DWARF_CIE_DATA_ALIGNMENT, there is either a bug in the
867 definition of DWARF_CIE_DATA_ALIGNMENT, or a bug in the machine
868 description. */
869 HOST_WIDE_INT check_offset = offset / DWARF_CIE_DATA_ALIGNMENT;
870
871 gcc_assert (check_offset * DWARF_CIE_DATA_ALIGNMENT == offset);
872 }
873#endif
874 offset /= DWARF_CIE_DATA_ALIGNMENT;
875 if (offset < 0)
876 cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
877
878 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
879 }
880 else if (sreg == reg)
881 cfi->dw_cfi_opc = DW_CFA_same_value;
882 else
883 {
884 cfi->dw_cfi_opc = DW_CFA_register;
885 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
886 }
887
888 add_fde_cfi (label, cfi);
889}
890
891/* Add the CFI for saving a register window. LABEL is passed to reg_save.
892 This CFI tells the unwinder that it needs to restore the window registers
893 from the previous frame's window save area.
894
895 ??? Perhaps we should note in the CIE where windows are saved (instead of
896 assuming 0(cfa)) and what registers are in the window. */
897
898void
899dwarf2out_window_save (const char *label)
900{
901 dw_cfi_ref cfi = new_cfi ();
902
903 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
904 add_fde_cfi (label, cfi);
905}
906
907/* Add a CFI to update the running total of the size of arguments
908 pushed onto the stack. */
909
910void
911dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
912{
913 dw_cfi_ref cfi;
914
915 if (size == old_args_size)
916 return;
917
918 old_args_size = size;
919
920 cfi = new_cfi ();
921 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
922 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
923 add_fde_cfi (label, cfi);
924}
925
926/* Entry point for saving a register to the stack. REG is the GCC register
927 number. LABEL and OFFSET are passed to reg_save. */
928
929void
930dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
931{
932 reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
933}
934
935/* Entry point for saving the return address in the stack.
936 LABEL and OFFSET are passed to reg_save. */
937
938void
939dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
940{
941 reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
942}
943
944/* Entry point for saving the return address in a register.
945 LABEL and SREG are passed to reg_save. */
946
947void
948dwarf2out_return_reg (const char *label, unsigned int sreg)
949{
950 reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
951}
952
953/* Record the initial position of the return address. RTL is
954 INCOMING_RETURN_ADDR_RTX. */
955
956static void
957initial_return_save (rtx rtl)
958{
959 unsigned int reg = INVALID_REGNUM;
960 HOST_WIDE_INT offset = 0;
961
962 switch (GET_CODE (rtl))
963 {
964 case REG:
965 /* RA is in a register. */
966 reg = DWARF_FRAME_REGNUM (REGNO (rtl));
967 break;
968
969 case MEM:
970 /* RA is on the stack. */
971 rtl = XEXP (rtl, 0);
972 switch (GET_CODE (rtl))
973 {
974 case REG:
975 gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
976 offset = 0;
977 break;
978
979 case PLUS:
980 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
981 offset = INTVAL (XEXP (rtl, 1));
982 break;
983
984 case MINUS:
985 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
986 offset = -INTVAL (XEXP (rtl, 1));
987 break;
988
989 default:
990 gcc_unreachable ();
991 }
992
993 break;
994
995 case PLUS:
996 /* The return address is at some offset from any value we can
997 actually load. For instance, on the SPARC it is in %i7+8. Just
998 ignore the offset for now; it doesn't matter for unwinding frames. */
999 gcc_assert (GET_CODE (XEXP (rtl, 1)) == CONST_INT);
1000 initial_return_save (XEXP (rtl, 0));
1001 return;
1002
1003 default:
1004 gcc_unreachable ();
1005 }
1006
1007 if (reg != DWARF_FRAME_RETURN_COLUMN)
1008 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
1009}
1010
1011/* Given a SET, calculate the amount of stack adjustment it
1012 contains. */
1013
1014static HOST_WIDE_INT
1015stack_adjust_offset (rtx pattern)
1016{
1017 rtx src = SET_SRC (pattern);
1018 rtx dest = SET_DEST (pattern);
1019 HOST_WIDE_INT offset = 0;
1020 enum rtx_code code;
1021
1022 if (dest == stack_pointer_rtx)
1023 {
1024 /* (set (reg sp) (plus (reg sp) (const_int))) */
1025 code = GET_CODE (src);
1026 if (! (code == PLUS || code == MINUS)
1027 || XEXP (src, 0) != stack_pointer_rtx
1028 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1029 return 0;
1030
1031 offset = INTVAL (XEXP (src, 1));
1032 if (code == PLUS)
1033 offset = -offset;
1034 }
1035 else if (MEM_P (dest))
1036 {
1037 /* (set (mem (pre_dec (reg sp))) (foo)) */
1038 src = XEXP (dest, 0);
1039 code = GET_CODE (src);
1040
1041 switch (code)
1042 {
1043 case PRE_MODIFY:
1044 case POST_MODIFY:
1045 if (XEXP (src, 0) == stack_pointer_rtx)
1046 {
1047 rtx val = XEXP (XEXP (src, 1), 1);
1048 /* We handle only adjustments by constant amount. */
1049 gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
1050 && GET_CODE (val) == CONST_INT);
1051 offset = -INTVAL (val);
1052 break;
1053 }
1054 return 0;
1055
1056 case PRE_DEC:
1057 case POST_DEC:
1058 if (XEXP (src, 0) == stack_pointer_rtx)
1059 {
1060 offset = GET_MODE_SIZE (GET_MODE (dest));
1061 break;
1062 }
1063 return 0;
1064
1065 case PRE_INC:
1066 case POST_INC:
1067 if (XEXP (src, 0) == stack_pointer_rtx)
1068 {
1069 offset = -GET_MODE_SIZE (GET_MODE (dest));
1070 break;
1071 }
1072 return 0;
1073
1074 default:
1075 return 0;
1076 }
1077 }
1078 else
1079 return 0;
1080
1081 return offset;
1082}
1083
1084/* Check INSN to see if it looks like a push or a stack adjustment, and
1085 make a note of it if it does. EH uses this information to find out how
1086 much extra space it needs to pop off the stack. */
1087
1088static void
1089dwarf2out_stack_adjust (rtx insn, bool after_p)
1090{
1091 HOST_WIDE_INT offset;
1092 const char *label;
1093 int i;
1094
1095 /* Don't handle epilogues at all. Certainly it would be wrong to do so
1096 with this function. Proper support would require all frame-related
1097 insns to be marked, and to be able to handle saving state around
1098 epilogues textually in the middle of the function. */
1099 if (prologue_epilogue_contains (insn) || sibcall_epilogue_contains (insn))
1100 return;
1101
1102 /* If only calls can throw, and we have a frame pointer,
1103 save up adjustments until we see the CALL_INSN. */
1104 if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1105 {
1106 if (CALL_P (insn) && !after_p)
1107 {
1108 /* Extract the size of the args from the CALL rtx itself. */
1109 insn = PATTERN (insn);
1110 if (GET_CODE (insn) == PARALLEL)
1111 insn = XVECEXP (insn, 0, 0);
1112 if (GET_CODE (insn) == SET)
1113 insn = SET_SRC (insn);
1114 gcc_assert (GET_CODE (insn) == CALL);
1115 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1116 }
1117 return;
1118 }
1119
1120 if (CALL_P (insn) && !after_p)
1121 {
1122 if (!flag_asynchronous_unwind_tables)
1123 dwarf2out_args_size ("", args_size);
1124 return;
1125 }
1126 else if (BARRIER_P (insn))
1127 {
1128 /* When we see a BARRIER, we know to reset args_size to 0. Usually
1129 the compiler will have already emitted a stack adjustment, but
1130 doesn't bother for calls to noreturn functions. */
1131#ifdef STACK_GROWS_DOWNWARD
1132 offset = -args_size;
1133#else
1134 offset = args_size;
1135#endif
1136 }
1137 else if (GET_CODE (PATTERN (insn)) == SET)
1138 offset = stack_adjust_offset (PATTERN (insn));
1139 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1140 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1141 {
1142 /* There may be stack adjustments inside compound insns. Search
1143 for them. */
1144 for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1145 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1146 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i));
1147 }
1148 else
1149 return;
1150
1151 if (offset == 0)
1152 return;
1153
1154 if (cfa.reg == STACK_POINTER_REGNUM)
1155 cfa.offset += offset;
1156
1157#ifndef STACK_GROWS_DOWNWARD
1158 offset = -offset;
1159#endif
1160
1161 args_size += offset;
1162 if (args_size < 0)
1163 args_size = 0;
1164
1165 label = dwarf2out_cfi_label ();
1166 def_cfa_1 (label, &cfa);
1167 if (flag_asynchronous_unwind_tables)
1168 dwarf2out_args_size (label, args_size);
1169}
1170
1171#endif
1172
1173/* We delay emitting a register save until either (a) we reach the end
1174 of the prologue or (b) the register is clobbered. This clusters
1175 register saves so that there are fewer pc advances. */
1176
1177struct queued_reg_save GTY(())
1178{
1179 struct queued_reg_save *next;
1180 rtx reg;
1181 HOST_WIDE_INT cfa_offset;
1182 rtx saved_reg;
1183};
1184
1185static GTY(()) struct queued_reg_save *queued_reg_saves;
1186
1187/* The caller's ORIG_REG is saved in SAVED_IN_REG. */
1188struct reg_saved_in_data GTY(()) {
1189 rtx orig_reg;
1190 rtx saved_in_reg;
1191};
1192
1193/* A list of registers saved in other registers.
1194 The list intentionally has a small maximum capacity of 4; if your
1195 port needs more than that, you might consider implementing a
1196 more efficient data structure. */
1197static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1198static GTY(()) size_t num_regs_saved_in_regs;
1199
1200#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1201static const char *last_reg_save_label;
1202
1203/* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1204 SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */
1205
1206static void
1207queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1208{
1209 struct queued_reg_save *q;
1210
1211 /* Duplicates waste space, but it's also necessary to remove them
1212 for correctness, since the queue gets output in reverse
1213 order. */
1214 for (q = queued_reg_saves; q != NULL; q = q->next)
1215 if (REGNO (q->reg) == REGNO (reg))
1216 break;
1217
1218 if (q == NULL)
1219 {
1220 q = ggc_alloc (sizeof (*q));
1221 q->next = queued_reg_saves;
1222 queued_reg_saves = q;
1223 }
1224
1225 q->reg = reg;
1226 q->cfa_offset = offset;
1227 q->saved_reg = sreg;
1228
1229 last_reg_save_label = label;
1230}
1231
1232/* Output all the entries in QUEUED_REG_SAVES. */
1233
1234static void
1235flush_queued_reg_saves (void)
1236{
1237 struct queued_reg_save *q;
1238
1239 for (q = queued_reg_saves; q; q = q->next)
1240 {
1241 size_t i;
1242 unsigned int reg, sreg;
1243
1244 for (i = 0; i < num_regs_saved_in_regs; i++)
1245 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
1246 break;
1247 if (q->saved_reg && i == num_regs_saved_in_regs)
1248 {
1249 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1250 num_regs_saved_in_regs++;
1251 }
1252 if (i != num_regs_saved_in_regs)
1253 {
1254 regs_saved_in_regs[i].orig_reg = q->reg;
1255 regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
1256 }
1257
1258 reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
1259 if (q->saved_reg)
1260 sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
1261 else
1262 sreg = INVALID_REGNUM;
1263 reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
1264 }
1265
1266 queued_reg_saves = NULL;
1267 last_reg_save_label = NULL;
1268}
1269
1270/* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1271 location for? Or, does it clobber a register which we've previously
1272 said that some other register is saved in, and for which we now
1273 have a new location for? */
1274
1275static bool
1276clobbers_queued_reg_save (rtx insn)
1277{
1278 struct queued_reg_save *q;
1279
1280 for (q = queued_reg_saves; q; q = q->next)
1281 {
1282 size_t i;
1283 if (modified_in_p (q->reg, insn))
1284 return true;
1285 for (i = 0; i < num_regs_saved_in_regs; i++)
1286 if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
1287 && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
1288 return true;
1289 }
1290
1291 return false;
1292}
1293
1294/* Entry point for saving the first register into the second. */
1295
1296void
1297dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg)
1298{
1299 size_t i;
1300 unsigned int regno, sregno;
1301
1302 for (i = 0; i < num_regs_saved_in_regs; i++)
1303 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg))
1304 break;
1305 if (i == num_regs_saved_in_regs)
1306 {
1307 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1308 num_regs_saved_in_regs++;
1309 }
1310 regs_saved_in_regs[i].orig_reg = reg;
1311 regs_saved_in_regs[i].saved_in_reg = sreg;
1312
1313 regno = DWARF_FRAME_REGNUM (REGNO (reg));
1314 sregno = DWARF_FRAME_REGNUM (REGNO (sreg));
1315 reg_save (label, regno, sregno, 0);
1316}
1317
1318/* What register, if any, is currently saved in REG? */
1319
1320static rtx
1321reg_saved_in (rtx reg)
1322{
1323 unsigned int regn = REGNO (reg);
1324 size_t i;
1325 struct queued_reg_save *q;
1326
1327 for (q = queued_reg_saves; q; q = q->next)
1328 if (q->saved_reg && regn == REGNO (q->saved_reg))
1329 return q->reg;
1330
1331 for (i = 0; i < num_regs_saved_in_regs; i++)
1332 if (regs_saved_in_regs[i].saved_in_reg
1333 && regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
1334 return regs_saved_in_regs[i].orig_reg;
1335
1336 return NULL_RTX;
1337}
1338
1339
1340/* A temporary register holding an integral value used in adjusting SP
1341 or setting up the store_reg. The "offset" field holds the integer
1342 value, not an offset. */
1343static dw_cfa_location cfa_temp;
1344
1345/* Record call frame debugging information for an expression EXPR,
1346 which either sets SP or FP (adjusting how we calculate the frame
1347 address) or saves a register to the stack or another register.
1348 LABEL indicates the address of EXPR.
1349
1350 This function encodes a state machine mapping rtxes to actions on
1351 cfa, cfa_store, and cfa_temp.reg. We describe these rules so
1352 users need not read the source code.
1353
1354 The High-Level Picture
1355
1356 Changes in the register we use to calculate the CFA: Currently we
1357 assume that if you copy the CFA register into another register, we
1358 should take the other one as the new CFA register; this seems to
1359 work pretty well. If it's wrong for some target, it's simple
1360 enough not to set RTX_FRAME_RELATED_P on the insn in question.
1361
1362 Changes in the register we use for saving registers to the stack:
1363 This is usually SP, but not always. Again, we deduce that if you
1364 copy SP into another register (and SP is not the CFA register),
1365 then the new register is the one we will be using for register
1366 saves. This also seems to work.
1367
1368 Register saves: There's not much guesswork about this one; if
1369 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1370 register save, and the register used to calculate the destination
1371 had better be the one we think we're using for this purpose.
1372 It's also assumed that a copy from a call-saved register to another
1373 register is saving that register if RTX_FRAME_RELATED_P is set on
1374 that instruction. If the copy is from a call-saved register to
1375 the *same* register, that means that the register is now the same
1376 value as in the caller.
1377
1378 Except: If the register being saved is the CFA register, and the
1379 offset is nonzero, we are saving the CFA, so we assume we have to
1380 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
1381 the intent is to save the value of SP from the previous frame.
1382
1383 In addition, if a register has previously been saved to a different
1384 register,
1385
1386 Invariants / Summaries of Rules
1387
1388 cfa current rule for calculating the CFA. It usually
1389 consists of a register and an offset.
1390 cfa_store register used by prologue code to save things to the stack
1391 cfa_store.offset is the offset from the value of
1392 cfa_store.reg to the actual CFA
1393 cfa_temp register holding an integral value. cfa_temp.offset
1394 stores the value, which will be used to adjust the
1395 stack pointer. cfa_temp is also used like cfa_store,
1396 to track stores to the stack via fp or a temp reg.
1397
1398 Rules 1- 4: Setting a register's value to cfa.reg or an expression
1399 with cfa.reg as the first operand changes the cfa.reg and its
1400 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
1401 cfa_temp.offset.
1402
1403 Rules 6- 9: Set a non-cfa.reg register value to a constant or an
1404 expression yielding a constant. This sets cfa_temp.reg
1405 and cfa_temp.offset.
1406
1407 Rule 5: Create a new register cfa_store used to save items to the
1408 stack.
1409
1410 Rules 10-14: Save a register to the stack. Define offset as the
1411 difference of the original location and cfa_store's
1412 location (or cfa_temp's location if cfa_temp is used).
1413
1414 The Rules
1415
1416 "{a,b}" indicates a choice of a xor b.
1417 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
1418
1419 Rule 1:
1420 (set <reg1> <reg2>:cfa.reg)
1421 effects: cfa.reg = <reg1>
1422 cfa.offset unchanged
1423 cfa_temp.reg = <reg1>
1424 cfa_temp.offset = cfa.offset
1425
1426 Rule 2:
1427 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
1428 {<const_int>,<reg>:cfa_temp.reg}))
1429 effects: cfa.reg = sp if fp used
1430 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
1431 cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
1432 if cfa_store.reg==sp
1433
1434 Rule 3:
1435 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
1436 effects: cfa.reg = fp
1437 cfa_offset += +/- <const_int>
1438
1439 Rule 4:
1440 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
1441 constraints: <reg1> != fp
1442 <reg1> != sp
1443 effects: cfa.reg = <reg1>
1444 cfa_temp.reg = <reg1>
1445 cfa_temp.offset = cfa.offset
1446
1447 Rule 5:
1448 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
1449 constraints: <reg1> != fp
1450 <reg1> != sp
1451 effects: cfa_store.reg = <reg1>
1452 cfa_store.offset = cfa.offset - cfa_temp.offset
1453
1454 Rule 6:
1455 (set <reg> <const_int>)
1456 effects: cfa_temp.reg = <reg>
1457 cfa_temp.offset = <const_int>
1458
1459 Rule 7:
1460 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
1461 effects: cfa_temp.reg = <reg1>
1462 cfa_temp.offset |= <const_int>
1463
1464 Rule 8:
1465 (set <reg> (high <exp>))
1466 effects: none
1467
1468 Rule 9:
1469 (set <reg> (lo_sum <exp> <const_int>))
1470 effects: cfa_temp.reg = <reg>
1471 cfa_temp.offset = <const_int>
1472
1473 Rule 10:
1474 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
1475 effects: cfa_store.offset -= <const_int>
1476 cfa.offset = cfa_store.offset if cfa.reg == sp
1477 cfa.reg = sp
1478 cfa.base_offset = -cfa_store.offset
1479
1480 Rule 11:
1481 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
1482 effects: cfa_store.offset += -/+ mode_size(mem)
1483 cfa.offset = cfa_store.offset if cfa.reg == sp
1484 cfa.reg = sp
1485 cfa.base_offset = -cfa_store.offset
1486
1487 Rule 12:
1488 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
1489
1490 <reg2>)
1491 effects: cfa.reg = <reg1>
1492 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
1493
1494 Rule 13:
1495 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
1496 effects: cfa.reg = <reg1>
1497 cfa.base_offset = -{cfa_store,cfa_temp}.offset
1498
1499 Rule 14:
1500 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
1501 effects: cfa.reg = <reg1>
1502 cfa.base_offset = -cfa_temp.offset
1503 cfa_temp.offset -= mode_size(mem)
1504
1505 Rule 15:
1506 (set <reg> {unspec, unspec_volatile})
1507 effects: target-dependent */
1508
1509static void
1510dwarf2out_frame_debug_expr (rtx expr, const char *label)
1511{
1512 rtx src, dest;
1513 HOST_WIDE_INT offset;
1514
1515 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1516 the PARALLEL independently. The first element is always processed if
1517 it is a SET. This is for backward compatibility. Other elements
1518 are processed only if they are SETs and the RTX_FRAME_RELATED_P
1519 flag is set in them. */
1520 if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
1521 {
1522 int par_index;
1523 int limit = XVECLEN (expr, 0);
1524
1525 for (par_index = 0; par_index < limit; par_index++)
1526 if (GET_CODE (XVECEXP (expr, 0, par_index)) == SET
1527 && (RTX_FRAME_RELATED_P (XVECEXP (expr, 0, par_index))
1528 || par_index == 0))
1529 dwarf2out_frame_debug_expr (XVECEXP (expr, 0, par_index), label);
1530
1531 return;
1532 }
1533
1534 gcc_assert (GET_CODE (expr) == SET);
1535
1536 src = SET_SRC (expr);
1537 dest = SET_DEST (expr);
1538
1539 if (REG_P (src))
1540 {
1541 rtx rsi = reg_saved_in (src);
1542 if (rsi)
1543 src = rsi;
1544 }
1545
1546 switch (GET_CODE (dest))
1547 {
1548 case REG:
1549 switch (GET_CODE (src))
1550 {
1551 /* Setting FP from SP. */
1552 case REG:
1553 if (cfa.reg == (unsigned) REGNO (src))
1554 {
1555 /* Rule 1 */
1556 /* Update the CFA rule wrt SP or FP. Make sure src is
1557 relative to the current CFA register.
1558
1559 We used to require that dest be either SP or FP, but the
1560 ARM copies SP to a temporary register, and from there to
1561 FP. So we just rely on the backends to only set
1562 RTX_FRAME_RELATED_P on appropriate insns. */
1563 cfa.reg = REGNO (dest);
1564 cfa_temp.reg = cfa.reg;
1565 cfa_temp.offset = cfa.offset;
1566 }
1567 else
1568 {
1569 /* Saving a register in a register. */
1570 gcc_assert (!fixed_regs [REGNO (dest)]
1571 /* For the SPARC and its register window. */
1572 || (DWARF_FRAME_REGNUM (REGNO (src))
1573 == DWARF_FRAME_RETURN_COLUMN));
1574 queue_reg_save (label, src, dest, 0);
1575 }
1576 break;
1577
1578 case PLUS:
1579 case MINUS:
1580 case LO_SUM:
1581 if (dest == stack_pointer_rtx)
1582 {
1583 /* Rule 2 */
1584 /* Adjusting SP. */
1585 switch (GET_CODE (XEXP (src, 1)))
1586 {
1587 case CONST_INT:
1588 offset = INTVAL (XEXP (src, 1));
1589 break;
1590 case REG:
1591 gcc_assert ((unsigned) REGNO (XEXP (src, 1))
1592 == cfa_temp.reg);
1593 offset = cfa_temp.offset;
1594 break;
1595 default:
1596 gcc_unreachable ();
1597 }
1598
1599 if (XEXP (src, 0) == hard_frame_pointer_rtx)
1600 {
1601 /* Restoring SP from FP in the epilogue. */
1602 gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
1603 cfa.reg = STACK_POINTER_REGNUM;
1604 }
1605 else if (GET_CODE (src) == LO_SUM)
1606 /* Assume we've set the source reg of the LO_SUM from sp. */
1607 ;
1608 else
1609 gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
1610
1611 if (GET_CODE (src) != MINUS)
1612 offset = -offset;
1613 if (cfa.reg == STACK_POINTER_REGNUM)
1614 cfa.offset += offset;
1615 if (cfa_store.reg == STACK_POINTER_REGNUM)
1616 cfa_store.offset += offset;
1617 }
1618 else if (dest == hard_frame_pointer_rtx)
1619 {
1620 /* Rule 3 */
1621 /* Either setting the FP from an offset of the SP,
1622 or adjusting the FP */
1623 gcc_assert (frame_pointer_needed);
1624
1625 gcc_assert (REG_P (XEXP (src, 0))
1626 && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
1627 && GET_CODE (XEXP (src, 1)) == CONST_INT);
1628 offset = INTVAL (XEXP (src, 1));
1629 if (GET_CODE (src) != MINUS)
1630 offset = -offset;
1631 cfa.offset += offset;
1632 cfa.reg = HARD_FRAME_POINTER_REGNUM;
1633 }
1634 else
1635 {
1636 gcc_assert (GET_CODE (src) != MINUS);
1637
1638 /* Rule 4 */
1639 if (REG_P (XEXP (src, 0))
1640 && REGNO (XEXP (src, 0)) == cfa.reg
1641 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1642 {
1643 /* Setting a temporary CFA register that will be copied
1644 into the FP later on. */
1645 offset = - INTVAL (XEXP (src, 1));
1646 cfa.offset += offset;
1647 cfa.reg = REGNO (dest);
1648 /* Or used to save regs to the stack. */
1649 cfa_temp.reg = cfa.reg;
1650 cfa_temp.offset = cfa.offset;
1651 }
1652
1653 /* Rule 5 */
1654 else if (REG_P (XEXP (src, 0))
1655 && REGNO (XEXP (src, 0)) == cfa_temp.reg
1656 && XEXP (src, 1) == stack_pointer_rtx)
1657 {
1658 /* Setting a scratch register that we will use instead
1659 of SP for saving registers to the stack. */
1660 gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
1661 cfa_store.reg = REGNO (dest);
1662 cfa_store.offset = cfa.offset - cfa_temp.offset;
1663 }
1664
1665 /* Rule 9 */
1666 else if (GET_CODE (src) == LO_SUM
1667 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1668 {
1669 cfa_temp.reg = REGNO (dest);
1670 cfa_temp.offset = INTVAL (XEXP (src, 1));
1671 }
1672 else
1673 gcc_unreachable ();
1674 }
1675 break;
1676
1677 /* Rule 6 */
1678 case CONST_INT:
1679 cfa_temp.reg = REGNO (dest);
1680 cfa_temp.offset = INTVAL (src);
1681 break;
1682
1683 /* Rule 7 */
1684 case IOR:
1685 gcc_assert (REG_P (XEXP (src, 0))
1686 && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
1687 && GET_CODE (XEXP (src, 1)) == CONST_INT);
1688
1689 if ((unsigned) REGNO (dest) != cfa_temp.reg)
1690 cfa_temp.reg = REGNO (dest);
1691 cfa_temp.offset |= INTVAL (XEXP (src, 1));
1692 break;
1693
1694 /* Skip over HIGH, assuming it will be followed by a LO_SUM,
1695 which will fill in all of the bits. */
1696 /* Rule 8 */
1697 case HIGH:
1698 break;
1699
1700 /* Rule 15 */
1701 case UNSPEC:
1702 case UNSPEC_VOLATILE:
1703 gcc_assert (targetm.dwarf_handle_frame_unspec);
1704 targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
1705 return;
1706
1707 default:
1708 gcc_unreachable ();
1709 }
1710
1711 def_cfa_1 (label, &cfa);
1712 break;
1713
1714 case MEM:
1715 gcc_assert (REG_P (src));
1716
1717 /* Saving a register to the stack. Make sure dest is relative to the
1718 CFA register. */
1719 switch (GET_CODE (XEXP (dest, 0)))
1720 {
1721 /* Rule 10 */
1722 /* With a push. */
1723 case PRE_MODIFY:
1724 /* We can't handle variable size modifications. */
1725 gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
1726 == CONST_INT);
1727 offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
1728
1729 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
1730 && cfa_store.reg == STACK_POINTER_REGNUM);
1731
1732 cfa_store.offset += offset;
1733 if (cfa.reg == STACK_POINTER_REGNUM)
1734 cfa.offset = cfa_store.offset;
1735
1736 offset = -cfa_store.offset;
1737 break;
1738
1739 /* Rule 11 */
1740 case PRE_INC:
1741 case PRE_DEC:
1742 offset = GET_MODE_SIZE (GET_MODE (dest));
1743 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
1744 offset = -offset;
1745
1746 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
1747 && cfa_store.reg == STACK_POINTER_REGNUM);
1748
1749 cfa_store.offset += offset;
1750 if (cfa.reg == STACK_POINTER_REGNUM)
1751 cfa.offset = cfa_store.offset;
1752
1753 offset = -cfa_store.offset;
1754 break;
1755
1756 /* Rule 12 */
1757 /* With an offset. */
1758 case PLUS:
1759 case MINUS:
1760 case LO_SUM:
1761 {
1762 int regno;
1763
1764 gcc_assert (GET_CODE (XEXP (XEXP (dest, 0), 1)) == CONST_INT
1765 && REG_P (XEXP (XEXP (dest, 0), 0)));
1766 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1767 if (GET_CODE (XEXP (dest, 0)) == MINUS)
1768 offset = -offset;
1769
1770 regno = REGNO (XEXP (XEXP (dest, 0), 0));
1771
1772 if (cfa_store.reg == (unsigned) regno)
1773 offset -= cfa_store.offset;
1774 else
1775 {
1776 gcc_assert (cfa_temp.reg == (unsigned) regno);
1777 offset -= cfa_temp.offset;
1778 }
1779 }
1780 break;
1781
1782 /* Rule 13 */
1783 /* Without an offset. */
1784 case REG:
1785 {
1786 int regno = REGNO (XEXP (dest, 0));
1787
1788 if (cfa_store.reg == (unsigned) regno)
1789 offset = -cfa_store.offset;
1790 else
1791 {
1792 gcc_assert (cfa_temp.reg == (unsigned) regno);
1793 offset = -cfa_temp.offset;
1794 }
1795 }
1796 break;
1797
1798 /* Rule 14 */
1799 case POST_INC:
1800 gcc_assert (cfa_temp.reg
1801 == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
1802 offset = -cfa_temp.offset;
1803 cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
1804 break;
1805
1806 default:
1807 gcc_unreachable ();
1808 }
1809
1810 if (REGNO (src) != STACK_POINTER_REGNUM
1811 && REGNO (src) != HARD_FRAME_POINTER_REGNUM
1812 && (unsigned) REGNO (src) == cfa.reg)
1813 {
1814 /* We're storing the current CFA reg into the stack. */
1815
1816 if (cfa.offset == 0)
1817 {
1818 /* If the source register is exactly the CFA, assume
1819 we're saving SP like any other register; this happens
1820 on the ARM. */
1821 def_cfa_1 (label, &cfa);
1822 queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
1823 break;
1824 }
1825 else
1826 {
1827 /* Otherwise, we'll need to look in the stack to
1828 calculate the CFA. */
1829 rtx x = XEXP (dest, 0);
1830
1831 if (!REG_P (x))
1832 x = XEXP (x, 0);
1833 gcc_assert (REG_P (x));
1834
1835 cfa.reg = REGNO (x);
1836 cfa.base_offset = offset;
1837 cfa.indirect = 1;
1838 def_cfa_1 (label, &cfa);
1839 break;
1840 }
1841 }
1842
1843 def_cfa_1 (label, &cfa);
1844 queue_reg_save (label, src, NULL_RTX, offset);
1845 break;
1846
1847 default:
1848 gcc_unreachable ();
1849 }
1850}
1851
1852/* Record call frame debugging information for INSN, which either
1853 sets SP or FP (adjusting how we calculate the frame address) or saves a
1854 register to the stack. If INSN is NULL_RTX, initialize our state.
1855
1856 If AFTER_P is false, we're being called before the insn is emitted,
1857 otherwise after. Call instructions get invoked twice. */
1858
1859void
1860dwarf2out_frame_debug (rtx insn, bool after_p)
1861{
1862 const char *label;
1863 rtx src;
1864
1865 if (insn == NULL_RTX)
1866 {
1867 size_t i;
1868
1869 /* Flush any queued register saves. */
1870 flush_queued_reg_saves ();
1871
1872 /* Set up state for generating call frame debug info. */
1873 lookup_cfa (&cfa);
1874 gcc_assert (cfa.reg
1875 == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
1876
1877 cfa.reg = STACK_POINTER_REGNUM;
1878 cfa_store = cfa;
1879 cfa_temp.reg = -1;
1880 cfa_temp.offset = 0;
1881
1882 for (i = 0; i < num_regs_saved_in_regs; i++)
1883 {
1884 regs_saved_in_regs[i].orig_reg = NULL_RTX;
1885 regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
1886 }
1887 num_regs_saved_in_regs = 0;
1888 return;
1889 }
1890
1891 if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
1892 flush_queued_reg_saves ();
1893
1894 if (! RTX_FRAME_RELATED_P (insn))
1895 {
1896 if (!ACCUMULATE_OUTGOING_ARGS)
1897 dwarf2out_stack_adjust (insn, after_p);
1898 return;
1899 }
1900
1901 label = dwarf2out_cfi_label ();
1902 src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1903 if (src)
1904 insn = XEXP (src, 0);
1905 else
1906 insn = PATTERN (insn);
1907
1908 dwarf2out_frame_debug_expr (insn, label);
1909}
1910
1911#endif
1912
1913/* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
1914static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
1915 (enum dwarf_call_frame_info cfi);
1916
1917static enum dw_cfi_oprnd_type
1918dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
1919{
1920 switch (cfi)
1921 {
1922 case DW_CFA_nop:
1923 case DW_CFA_GNU_window_save:
1924 return dw_cfi_oprnd_unused;
1925
1926 case DW_CFA_set_loc:
1927 case DW_CFA_advance_loc1:
1928 case DW_CFA_advance_loc2:
1929 case DW_CFA_advance_loc4:
1930 case DW_CFA_MIPS_advance_loc8:
1931 return dw_cfi_oprnd_addr;
1932
1933 case DW_CFA_offset:
1934 case DW_CFA_offset_extended:
1935 case DW_CFA_def_cfa:
1936 case DW_CFA_offset_extended_sf:
1937 case DW_CFA_def_cfa_sf:
1938 case DW_CFA_restore_extended:
1939 case DW_CFA_undefined:
1940 case DW_CFA_same_value:
1941 case DW_CFA_def_cfa_register:
1942 case DW_CFA_register:
1943 return dw_cfi_oprnd_reg_num;
1944
1945 case DW_CFA_def_cfa_offset:
1946 case DW_CFA_GNU_args_size:
1947 case DW_CFA_def_cfa_offset_sf:
1948 return dw_cfi_oprnd_offset;
1949
1950 case DW_CFA_def_cfa_expression:
1951 case DW_CFA_expression:
1952 return dw_cfi_oprnd_loc;
1953
1954 default:
1955 gcc_unreachable ();
1956 }
1957}
1958
1959/* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
1960static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
1961 (enum dwarf_call_frame_info cfi);
1962
1963static enum dw_cfi_oprnd_type
1964dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
1965{
1966 switch (cfi)
1967 {
1968 case DW_CFA_def_cfa:
1969 case DW_CFA_def_cfa_sf:
1970 case DW_CFA_offset:
1971 case DW_CFA_offset_extended_sf:
1972 case DW_CFA_offset_extended:
1973 return dw_cfi_oprnd_offset;
1974
1975 case DW_CFA_register:
1976 return dw_cfi_oprnd_reg_num;
1977
1978 default:
1979 return dw_cfi_oprnd_unused;
1980 }
1981}
1982
1983#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1984
1985/* Switch to eh_frame_section. If we don't have an eh_frame_section,
1986 switch to the data section instead, and write out a synthetic label
1987 for collect2. */
1988
1989static void
1990switch_to_eh_frame_section (void)
1991{
1992 tree label;
1993
1994#ifdef EH_FRAME_SECTION_NAME
1995 if (eh_frame_section == 0)
1996 {
1997 int flags;
1998
1999 if (EH_TABLES_CAN_BE_READ_ONLY)
2000 {
2001 int fde_encoding;
2002 int per_encoding;
2003 int lsda_encoding;
2004
2005 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
2006 /*global=*/0);
2007 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
2008 /*global=*/1);
2009 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
2010 /*global=*/0);
2011 flags = ((! flag_pic
2012 || ((fde_encoding & 0x70) != DW_EH_PE_absptr
2013 && (fde_encoding & 0x70) != DW_EH_PE_aligned
2014 && (per_encoding & 0x70) != DW_EH_PE_absptr
2015 && (per_encoding & 0x70) != DW_EH_PE_aligned
2016 && (lsda_encoding & 0x70) != DW_EH_PE_absptr
2017 && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
2018 ? 0 : SECTION_WRITE);
2019 }
2020 else
2021 flags = SECTION_WRITE;
2022 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
2023 }
2024#endif
2025
2026 if (eh_frame_section)
2027 switch_to_section (eh_frame_section);
2028 else
2029 {
2030 /* We have no special eh_frame section. Put the information in
2031 the data section and emit special labels to guide collect2. */
2032 switch_to_section (data_section);
2033 label = get_file_function_name ('F');
2034 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2035 targetm.asm_out.globalize_label (asm_out_file,
2036 IDENTIFIER_POINTER (label));
2037 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
2038 }
2039}
2040
2041/* Output a Call Frame Information opcode and its operand(s). */
2042
2043static void
2044output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
2045{
2046 unsigned long r;
2047 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
2048 dw2_asm_output_data (1, (cfi->dw_cfi_opc
2049 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
2050 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
2051 cfi->dw_cfi_oprnd1.dw_cfi_offset);
2052 else if (cfi->dw_cfi_opc == DW_CFA_offset)
2053 {
2054 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2055 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2056 "DW_CFA_offset, column 0x%lx", r);
2057 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2058 }
2059 else if (cfi->dw_cfi_opc == DW_CFA_restore)
2060 {
2061 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2062 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2063 "DW_CFA_restore, column 0x%lx", r);
2064 }
2065 else
2066 {
2067 dw2_asm_output_data (1, cfi->dw_cfi_opc,
2068 "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
2069
2070 switch (cfi->dw_cfi_opc)
2071 {
2072 case DW_CFA_set_loc:
2073 if (for_eh)
2074 dw2_asm_output_encoded_addr_rtx (
2075 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
2076 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
2077 false, NULL);
2078 else
2079 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2080 cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
2081 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2082 break;
2083
2084 case DW_CFA_advance_loc1:
2085 dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2086 fde->dw_fde_current_label, NULL);
2087 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2088 break;
2089
2090 case DW_CFA_advance_loc2:
2091 dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2092 fde->dw_fde_current_label, NULL);
2093 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2094 break;
2095
2096 case DW_CFA_advance_loc4:
2097 dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2098 fde->dw_fde_current_label, NULL);
2099 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2100 break;
2101
2102 case DW_CFA_MIPS_advance_loc8:
2103 dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2104 fde->dw_fde_current_label, NULL);
2105 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2106 break;
2107
2108 case DW_CFA_offset_extended:
2109 case DW_CFA_def_cfa:
2110 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2111 dw2_asm_output_data_uleb128 (r, NULL);
2112 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2113 break;
2114
2115 case DW_CFA_offset_extended_sf:
2116 case DW_CFA_def_cfa_sf:
2117 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2118 dw2_asm_output_data_uleb128 (r, NULL);
2119 dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2120 break;
2121
2122 case DW_CFA_restore_extended:
2123 case DW_CFA_undefined:
2124 case DW_CFA_same_value:
2125 case DW_CFA_def_cfa_register:
2126 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2127 dw2_asm_output_data_uleb128 (r, NULL);
2128 break;
2129
2130 case DW_CFA_register:
2131 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2132 dw2_asm_output_data_uleb128 (r, NULL);
2133 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
2134 dw2_asm_output_data_uleb128 (r, NULL);
2135 break;
2136
2137 case DW_CFA_def_cfa_offset:
2138 case DW_CFA_GNU_args_size:
2139 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
2140 break;
2141
2142 case DW_CFA_def_cfa_offset_sf:
2143 dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
2144 break;
2145
2146 case DW_CFA_GNU_window_save:
2147 break;
2148
2149 case DW_CFA_def_cfa_expression:
2150 case DW_CFA_expression:
2151 output_cfa_loc (cfi);
2152 break;
2153
2154 case DW_CFA_GNU_negative_offset_extended:
2155 /* Obsoleted by DW_CFA_offset_extended_sf. */
2156 gcc_unreachable ();
2157
2158 default:
2159 break;
2160 }
2161 }
2162}
2163
2164/* Output the call frame information used to record information
2165 that relates to calculating the frame pointer, and records the
2166 location of saved registers. */
2167
2168static void
2169output_call_frame_info (int for_eh)
2170{
2171 unsigned int i;
2172 dw_fde_ref fde;
2173 dw_cfi_ref cfi;
2174 char l1[20], l2[20], section_start_label[20];
2175 bool any_lsda_needed = false;
2176 char augmentation[6];
2177 int augmentation_size;
2178 int fde_encoding = DW_EH_PE_absptr;
2179 int per_encoding = DW_EH_PE_absptr;
2180 int lsda_encoding = DW_EH_PE_absptr;
2181 int return_reg;
2182
2183 /* Don't emit a CIE if there won't be any FDEs. */
2184 if (fde_table_in_use == 0)
2185 return;
2186
2187 /* If we make FDEs linkonce, we may have to emit an empty label for
2188 an FDE that wouldn't otherwise be emitted. We want to avoid
2189 having an FDE kept around when the function it refers to is
2190 discarded. Example where this matters: a primary function
2191 template in C++ requires EH information, but an explicit
2192 specialization doesn't. */
2193 if (TARGET_USES_WEAK_UNWIND_INFO
2194 && ! flag_asynchronous_unwind_tables
2195 && for_eh)
2196 for (i = 0; i < fde_table_in_use; i++)
2197 if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls)
2198 && !fde_table[i].uses_eh_lsda
2199 && ! DECL_WEAK (fde_table[i].decl))
2200 targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl,
2201 for_eh, /* empty */ 1);
2202
2203 /* If we don't have any functions we'll want to unwind out of, don't
2204 emit any EH unwind information. Note that if exceptions aren't
2205 enabled, we won't have collected nothrow information, and if we
2206 asked for asynchronous tables, we always want this info. */
2207 if (for_eh)
2208 {
2209 bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables;
2210
2211 for (i = 0; i < fde_table_in_use; i++)
2212 if (fde_table[i].uses_eh_lsda)
2213 any_eh_needed = any_lsda_needed = true;
2214 else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
2215 any_eh_needed = true;
2216 else if (! fde_table[i].nothrow
2217 && ! fde_table[i].all_throwers_are_sibcalls)
2218 any_eh_needed = true;
2219
2220 if (! any_eh_needed)
2221 return;
2222 }
2223
2224 /* We're going to be generating comments, so turn on app. */
2225 if (flag_debug_asm)
2226 app_enable ();
2227
2228 if (for_eh)
2229 switch_to_eh_frame_section ();
2230 else
2231 {
2232 if (!debug_frame_section)
2233 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
2234 SECTION_DEBUG, NULL);
2235 switch_to_section (debug_frame_section);
2236 }
2237
2238 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
2239 ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
2240
2241 /* Output the CIE. */
2242 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
2243 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
2244 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
2245 dw2_asm_output_data (4, 0xffffffff,
2246 "Initial length escape value indicating 64-bit DWARF extension");
2247 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2248 "Length of Common Information Entry");
2249 ASM_OUTPUT_LABEL (asm_out_file, l1);
2250
2251 /* Now that the CIE pointer is PC-relative for EH,
2252 use 0 to identify the CIE. */
2253 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
2254 (for_eh ? 0 : DWARF_CIE_ID),
2255 "CIE Identifier Tag");
2256
2257 dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version");
2258
2259 augmentation[0] = 0;
2260 augmentation_size = 0;
2261 if (for_eh)
2262 {
2263 char *p;
2264
2265 /* Augmentation:
2266 z Indicates that a uleb128 is present to size the
2267 augmentation section.
2268 L Indicates the encoding (and thus presence) of
2269 an LSDA pointer in the FDE augmentation.
2270 R Indicates a non-default pointer encoding for
2271 FDE code pointers.
2272 P Indicates the presence of an encoding + language
2273 personality routine in the CIE augmentation. */
2274
2275 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
2276 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
2277 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
2278
2279 p = augmentation + 1;
2280 if (eh_personality_libfunc)
2281 {
2282 *p++ = 'P';
2283 augmentation_size += 1 + size_of_encoded_value (per_encoding);
2284 }
2285 if (any_lsda_needed)
2286 {
2287 *p++ = 'L';
2288 augmentation_size += 1;
2289 }
2290 if (fde_encoding != DW_EH_PE_absptr)
2291 {
2292 *p++ = 'R';
2293 augmentation_size += 1;
2294 }
2295 if (p > augmentation + 1)
2296 {
2297 augmentation[0] = 'z';
2298 *p = '\0';
2299 }
2300
2301 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
2302 if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned)
2303 {
2304 int offset = ( 4 /* Length */
2305 + 4 /* CIE Id */
2306 + 1 /* CIE version */
2307 + strlen (augmentation) + 1 /* Augmentation */
2308 + size_of_uleb128 (1) /* Code alignment */
2309 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
2310 + 1 /* RA column */
2311 + 1 /* Augmentation size */
2312 + 1 /* Personality encoding */ );
2313 int pad = -offset & (PTR_SIZE - 1);
2314
2315 augmentation_size += pad;
2316
2317 /* Augmentations should be small, so there's scarce need to
2318 iterate for a solution. Die if we exceed one uleb128 byte. */
2319 gcc_assert (size_of_uleb128 (augmentation_size) == 1);
2320 }
2321 }
2322
2323 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
2324 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
2325 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
2326 "CIE Data Alignment Factor");
2327
2328 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
2329 if (DW_CIE_VERSION == 1)
2330 dw2_asm_output_data (1, return_reg, "CIE RA Column");
2331 else
2332 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
2333
2334 if (augmentation[0])
2335 {
2336 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
2337 if (eh_personality_libfunc)
2338 {
2339 dw2_asm_output_data (1, per_encoding, "Personality (%s)",
2340 eh_data_format_name (per_encoding));
2341 dw2_asm_output_encoded_addr_rtx (per_encoding,
2342 eh_personality_libfunc,
2343 true, NULL);
2344 }
2345
2346 if (any_lsda_needed)
2347 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
2348 eh_data_format_name (lsda_encoding));
2349
2350 if (fde_encoding != DW_EH_PE_absptr)
2351 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
2352 eh_data_format_name (fde_encoding));
2353 }
2354
2355 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
2356 output_cfi (cfi, NULL, for_eh);
2357
2358 /* Pad the CIE out to an address sized boundary. */
2359 ASM_OUTPUT_ALIGN (asm_out_file,
2360 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
2361 ASM_OUTPUT_LABEL (asm_out_file, l2);
2362
2363 /* Loop through all of the FDE's. */
2364 for (i = 0; i < fde_table_in_use; i++)
2365 {
2366 fde = &fde_table[i];
2367
2368 /* Don't emit EH unwind info for leaf functions that don't need it. */
2369 if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions
2370 && (fde->nothrow || fde->all_throwers_are_sibcalls)
2371 && ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
2372 && !fde->uses_eh_lsda)
2373 continue;
2374
2375 targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh, /* empty */ 0);
2376 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL, for_eh + i * 2);
2377 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2);
2378 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2);
2379 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
2380 dw2_asm_output_data (4, 0xffffffff,
2381 "Initial length escape value indicating 64-bit DWARF extension");
2382 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2383 "FDE Length");
2384 ASM_OUTPUT_LABEL (asm_out_file, l1);
2385
2386 if (for_eh)
2387 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
2388 else
2389 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
2390 debug_frame_section, "FDE CIE offset");
2391
2392 if (for_eh)
2393 {
2394 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin);
2395 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
2396 dw2_asm_output_encoded_addr_rtx (fde_encoding,
2397 sym_ref,
2398 false,
2399 "FDE initial location");
2400 if (fde->dw_fde_switched_sections)
2401 {
2402 rtx sym_ref2 = gen_rtx_SYMBOL_REF (Pmode,
2403 fde->dw_fde_unlikely_section_label);
2404 rtx sym_ref3= gen_rtx_SYMBOL_REF (Pmode,
2405 fde->dw_fde_hot_section_label);
2406 SYMBOL_REF_FLAGS (sym_ref2) |= SYMBOL_FLAG_LOCAL;
2407 SYMBOL_REF_FLAGS (sym_ref3) |= SYMBOL_FLAG_LOCAL;
2408 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref3, false,
2409 "FDE initial location");
2410 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2411 fde->dw_fde_hot_section_end_label,
2412 fde->dw_fde_hot_section_label,
2413 "FDE address range");
2414 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref2, false,
2415 "FDE initial location");
2416 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2417 fde->dw_fde_unlikely_section_end_label,
2418 fde->dw_fde_unlikely_section_label,
2419 "FDE address range");
2420 }
2421 else
2422 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2423 fde->dw_fde_end, fde->dw_fde_begin,
2424 "FDE address range");
2425 }
2426 else
2427 {
2428 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
2429 "FDE initial location");
2430 if (fde->dw_fde_switched_sections)
2431 {
2432 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2433 fde->dw_fde_hot_section_label,
2434 "FDE initial location");
2435 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2436 fde->dw_fde_hot_section_end_label,
2437 fde->dw_fde_hot_section_label,
2438 "FDE address range");
2439 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2440 fde->dw_fde_unlikely_section_label,
2441 "FDE initial location");
2442 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2443 fde->dw_fde_unlikely_section_end_label,
2444 fde->dw_fde_unlikely_section_label,
2445 "FDE address range");
2446 }
2447 else
2448 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2449 fde->dw_fde_end, fde->dw_fde_begin,
2450 "FDE address range");
2451 }
2452
2453 if (augmentation[0])
2454 {
2455 if (any_lsda_needed)
2456 {
2457 int size = size_of_encoded_value (lsda_encoding);
2458
2459 if (lsda_encoding == DW_EH_PE_aligned)
2460 {
2461 int offset = ( 4 /* Length */
2462 + 4 /* CIE offset */
2463 + 2 * size_of_encoded_value (fde_encoding)
2464 + 1 /* Augmentation size */ );
2465 int pad = -offset & (PTR_SIZE - 1);
2466
2467 size += pad;
2468 gcc_assert (size_of_uleb128 (size) == 1);
2469 }
2470
2471 dw2_asm_output_data_uleb128 (size, "Augmentation size");
2472
2473 if (fde->uses_eh_lsda)
2474 {
2475 ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA",
2476 fde->funcdef_number);
2477 dw2_asm_output_encoded_addr_rtx (
2478 lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1),
2479 false, "Language Specific Data Area");
2480 }
2481 else
2482 {
2483 if (lsda_encoding == DW_EH_PE_aligned)
2484 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2485 dw2_asm_output_data
2486 (size_of_encoded_value (lsda_encoding), 0,
2487 "Language Specific Data Area (none)");
2488 }
2489 }
2490 else
2491 dw2_asm_output_data_uleb128 (0, "Augmentation size");
2492 }
2493
2494 /* Loop through the Call Frame Instructions associated with
2495 this FDE. */
2496 fde->dw_fde_current_label = fde->dw_fde_begin;
2497 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
2498 output_cfi (cfi, fde, for_eh);
2499
2500 /* Pad the FDE out to an address sized boundary. */
2501 ASM_OUTPUT_ALIGN (asm_out_file,
2502 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
2503 ASM_OUTPUT_LABEL (asm_out_file, l2);
2504 }
2505
2506 if (for_eh && targetm.terminate_dw2_eh_frame_info)
2507 dw2_asm_output_data (4, 0, "End of Table");
2508#ifdef MIPS_DEBUGGING_INFO
2509 /* Work around Irix 6 assembler bug whereby labels at the end of a section
2510 get a value of 0. Putting .align 0 after the label fixes it. */
2511 ASM_OUTPUT_ALIGN (asm_out_file, 0);
2512#endif
2513
2514 /* Turn off app to make assembly quicker. */
2515 if (flag_debug_asm)
2516 app_disable ();
2517}
2518
2519/* Output a marker (i.e. a label) for the beginning of a function, before
2520 the prologue. */
2521
2522void
2523dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
2524 const char *file ATTRIBUTE_UNUSED)
2525{
2526 char label[MAX_ARTIFICIAL_LABEL_BYTES];
2527 char * dup_label;
2528 dw_fde_ref fde;
2529
2530 current_function_func_begin_label = NULL;
2531
2532#ifdef TARGET_UNWIND_INFO
2533 /* ??? current_function_func_begin_label is also used by except.c
2534 for call-site information. We must emit this label if it might
2535 be used. */
2536 if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS)
2537 && ! dwarf2out_do_frame ())
2538 return;
2539#else
2540 if (! dwarf2out_do_frame ())
2541 return;
2542#endif
2543
2544 switch_to_section (function_section (current_function_decl));
2545 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
2546 current_function_funcdef_no);
2547 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
2548 current_function_funcdef_no);
2549 dup_label = xstrdup (label);
2550 current_function_func_begin_label = dup_label;
2551
2552#ifdef TARGET_UNWIND_INFO
2553 /* We can elide the fde allocation if we're not emitting debug info. */
2554 if (! dwarf2out_do_frame ())
2555 return;
2556#endif
2557
2558 /* Expand the fde table if necessary. */
2559 if (fde_table_in_use == fde_table_allocated)
2560 {
2561 fde_table_allocated += FDE_TABLE_INCREMENT;
2562 fde_table = ggc_realloc (fde_table,
2563 fde_table_allocated * sizeof (dw_fde_node));
2564 memset (fde_table + fde_table_in_use, 0,
2565 FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2566 }
2567
2568 /* Record the FDE associated with this function. */
2569 current_funcdef_fde = fde_table_in_use;
2570
2571 /* Add the new FDE at the end of the fde_table. */
2572 fde = &fde_table[fde_table_in_use++];
2573 fde->decl = current_function_decl;
2574 fde->dw_fde_begin = dup_label;
2575 fde->dw_fde_current_label = dup_label;
2576 fde->dw_fde_hot_section_label = NULL;
2577 fde->dw_fde_hot_section_end_label = NULL;
2578 fde->dw_fde_unlikely_section_label = NULL;
2579 fde->dw_fde_unlikely_section_end_label = NULL;
2580 fde->dw_fde_switched_sections = false;
2581 fde->dw_fde_end = NULL;
2582 fde->dw_fde_cfi = NULL;
2583 fde->funcdef_number = current_function_funcdef_no;
2584 fde->nothrow = TREE_NOTHROW (current_function_decl);
2585 fde->uses_eh_lsda = cfun->uses_eh_lsda;
2586 fde->all_throwers_are_sibcalls = cfun->all_throwers_are_sibcalls;
2587
2588 args_size = old_args_size = 0;
2589
2590 /* We only want to output line number information for the genuine dwarf2
2591 prologue case, not the eh frame case. */
2592#ifdef DWARF2_DEBUGGING_INFO
2593 if (file)
2594 dwarf2out_source_line (line, file);
2595#endif
2596}
2597
2598/* Output a marker (i.e. a label) for the absolute end of the generated code
2599 for a function definition. This gets called *after* the epilogue code has
2600 been generated. */
2601
2602void
2603dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
2604 const char *file ATTRIBUTE_UNUSED)
2605{
2606 dw_fde_ref fde;
2607 char label[MAX_ARTIFICIAL_LABEL_BYTES];
2608
2609 /* Output a label to mark the endpoint of the code generated for this
2610 function. */
2611 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
2612 current_function_funcdef_no);
2613 ASM_OUTPUT_LABEL (asm_out_file, label);
2614 fde = &fde_table[fde_table_in_use - 1];
2615 fde->dw_fde_end = xstrdup (label);
2616}
2617
2618void
2619dwarf2out_frame_init (void)
2620{
2621 /* Allocate the initial hunk of the fde_table. */
2622 fde_table = ggc_alloc_cleared (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2623 fde_table_allocated = FDE_TABLE_INCREMENT;
2624 fde_table_in_use = 0;
2625
2626 /* Generate the CFA instructions common to all FDE's. Do it now for the
2627 sake of lookup_cfa. */
2628
2629 /* On entry, the Canonical Frame Address is at SP. */
2630 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
2631
2632#ifdef DWARF2_UNWIND_INFO
2633 if (DWARF2_UNWIND_INFO)
2634 initial_return_save (INCOMING_RETURN_ADDR_RTX);
2635#endif
2636}
2637
2638void
2639dwarf2out_frame_finish (void)
2640{
2641 /* Output call frame information. */
2642 if (DWARF2_FRAME_INFO)
2643 output_call_frame_info (0);
2644
2645#ifndef TARGET_UNWIND_INFO
2646 /* Output another copy for the unwinder. */
2647 if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
2648 output_call_frame_info (1);
2649#endif
2650}
2651#endif
2652
2653/* And now, the subset of the debugging information support code necessary
2654 for emitting location expressions. */
2655
2656/* Data about a single source file. */
2657struct dwarf_file_data GTY(())
2658{
2659 const char * filename;
2660 int emitted_number;
2661};
2662
2663/* We need some way to distinguish DW_OP_addr with a direct symbol
2664 relocation from DW_OP_addr with a dtp-relative symbol relocation. */
2665#define INTERNAL_DW_OP_tls_addr (0x100 + DW_OP_addr)
2666
2667
2668typedef struct dw_val_struct *dw_val_ref;
2669typedef struct die_struct *dw_die_ref;
2670typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
2671typedef struct dw_loc_list_struct *dw_loc_list_ref;
2672
2673/* Each DIE may have a series of attribute/value pairs. Values
2674 can take on several forms. The forms that are used in this
2675 implementation are listed below. */
2676
2677enum dw_val_class
2678{
2679 dw_val_class_addr,
2680 dw_val_class_offset,
2681 dw_val_class_loc,
2682 dw_val_class_loc_list,
2683 dw_val_class_range_list,
2684 dw_val_class_const,
2685 dw_val_class_unsigned_const,
2686 dw_val_class_long_long,
2687 dw_val_class_vec,
2688 dw_val_class_flag,
2689 dw_val_class_die_ref,
2690 dw_val_class_fde_ref,
2691 dw_val_class_lbl_id,
2692 dw_val_class_lineptr,
2693 dw_val_class_str,
2694 dw_val_class_macptr,
2695 dw_val_class_file
2696};
2697
2698/* Describe a double word constant value. */
2699/* ??? Every instance of long_long in the code really means CONST_DOUBLE. */
2700
2701typedef struct dw_long_long_struct GTY(())
2702{
2703 unsigned long hi;
2704 unsigned long low;
2705}
2706dw_long_long_const;
2707
2708/* Describe a floating point constant value, or a vector constant value. */
2709
2710typedef struct dw_vec_struct GTY(())
2711{
2712 unsigned char * GTY((length ("%h.length"))) array;
2713 unsigned length;
2714 unsigned elt_size;
2715}
2716dw_vec_const;
2717
2718/* The dw_val_node describes an attribute's value, as it is
2719 represented internally. */
2720
2721typedef struct dw_val_struct GTY(())
2722{
2723 enum dw_val_class val_class;
2724 union dw_val_struct_union
2725 {
2726 rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
2727 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
2728 dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
2729 dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
2730 HOST_WIDE_INT GTY ((default)) val_int;
2731 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
2732 dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long;
2733 dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
2734 struct dw_val_die_union
2735 {
2736 dw_die_ref die;
2737 int external;
2738 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
2739 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
2740 struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
2741 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
2742 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
2743 struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file;
2744 }
2745 GTY ((desc ("%1.val_class"))) v;
2746}
2747dw_val_node;
2748
2749/* Locations in memory are described using a sequence of stack machine
2750 operations. */
2751
2752typedef struct dw_loc_descr_struct GTY(())
2753{
2754 dw_loc_descr_ref dw_loc_next;
2755 enum dwarf_location_atom dw_loc_opc;
2756 dw_val_node dw_loc_oprnd1;
2757 dw_val_node dw_loc_oprnd2;
2758 int dw_loc_addr;
2759}
2760dw_loc_descr_node;
2761
2762/* Location lists are ranges + location descriptions for that range,
2763 so you can track variables that are in different places over
2764 their entire life. */
2765typedef struct dw_loc_list_struct GTY(())
2766{
2767 dw_loc_list_ref dw_loc_next;
2768 const char *begin; /* Label for begin address of range */
2769 const char *end; /* Label for end address of range */
2770 char *ll_symbol; /* Label for beginning of location list.
2771 Only on head of list */
2772 const char *section; /* Section this loclist is relative to */
2773 dw_loc_descr_ref expr;
2774} dw_loc_list_node;
2775
2776#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2777
2778static const char *dwarf_stack_op_name (unsigned);
2779static dw_loc_descr_ref new_loc_descr (enum dwarf_location_atom,
2780 unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
2781static void add_loc_descr (dw_loc_descr_ref *, dw_loc_descr_ref);
2782static unsigned long size_of_loc_descr (dw_loc_descr_ref);
2783static unsigned long size_of_locs (dw_loc_descr_ref);
2784static void output_loc_operands (dw_loc_descr_ref);
2785static void output_loc_sequence (dw_loc_descr_ref);
2786
2787/* Convert a DWARF stack opcode into its string name. */
2788
2789static const char *
2790dwarf_stack_op_name (unsigned int op)
2791{
2792 switch (op)
2793 {
2794 case DW_OP_addr:
2795 case INTERNAL_DW_OP_tls_addr:
2796 return "DW_OP_addr";
2797 case DW_OP_deref:
2798 return "DW_OP_deref";
2799 case DW_OP_const1u:
2800 return "DW_OP_const1u";
2801 case DW_OP_const1s:
2802 return "DW_OP_const1s";
2803 case DW_OP_const2u:
2804 return "DW_OP_const2u";
2805 case DW_OP_const2s:
2806 return "DW_OP_const2s";
2807 case DW_OP_const4u:
2808 return "DW_OP_const4u";
2809 case DW_OP_const4s:
2810 return "DW_OP_const4s";
2811 case DW_OP_const8u:
2812 return "DW_OP_const8u";
2813 case DW_OP_const8s:
2814 return "DW_OP_const8s";
2815 case DW_OP_constu:
2816 return "DW_OP_constu";
2817 case DW_OP_consts:
2818 return "DW_OP_consts";
2819 case DW_OP_dup:
2820 return "DW_OP_dup";
2821 case DW_OP_drop:
2822 return "DW_OP_drop";
2823 case DW_OP_over:
2824 return "DW_OP_over";
2825 case DW_OP_pick:
2826 return "DW_OP_pick";
2827 case DW_OP_swap:
2828 return "DW_OP_swap";
2829 case DW_OP_rot:
2830 return "DW_OP_rot";
2831 case DW_OP_xderef:
2832 return "DW_OP_xderef";
2833 case DW_OP_abs:
2834 return "DW_OP_abs";
2835 case DW_OP_and:
2836 return "DW_OP_and";
2837 case DW_OP_div:
2838 return "DW_OP_div";
2839 case DW_OP_minus:
2840 return "DW_OP_minus";
2841 case DW_OP_mod:
2842 return "DW_OP_mod";
2843 case DW_OP_mul:
2844 return "DW_OP_mul";
2845 case DW_OP_neg:
2846 return "DW_OP_neg";
2847 case DW_OP_not:
2848 return "DW_OP_not";
2849 case DW_OP_or:
2850 return "DW_OP_or";
2851 case DW_OP_plus:
2852 return "DW_OP_plus";
2853 case DW_OP_plus_uconst:
2854 return "DW_OP_plus_uconst";
2855 case DW_OP_shl:
2856 return "DW_OP_shl";
2857 case DW_OP_shr:
2858 return "DW_OP_shr";
2859 case DW_OP_shra:
2860 return "DW_OP_shra";
2861 case DW_OP_xor:
2862 return "DW_OP_xor";
2863 case DW_OP_bra:
2864 return "DW_OP_bra";
2865 case DW_OP_eq:
2866 return "DW_OP_eq";
2867 case DW_OP_ge:
2868 return "DW_OP_ge";
2869 case DW_OP_gt:
2870 return "DW_OP_gt";
2871 case DW_OP_le:
2872 return "DW_OP_le";
2873 case DW_OP_lt:
2874 return "DW_OP_lt";
2875 case DW_OP_ne:
2876 return "DW_OP_ne";
2877 case DW_OP_skip:
2878 return "DW_OP_skip";
2879 case DW_OP_lit0:
2880 return "DW_OP_lit0";
2881 case DW_OP_lit1:
2882 return "DW_OP_lit1";
2883 case DW_OP_lit2:
2884 return "DW_OP_lit2";
2885 case DW_OP_lit3:
2886 return "DW_OP_lit3";
2887 case DW_OP_lit4:
2888 return "DW_OP_lit4";
2889 case DW_OP_lit5:
2890 return "DW_OP_lit5";
2891 case DW_OP_lit6:
2892 return "DW_OP_lit6";
2893 case DW_OP_lit7:
2894 return "DW_OP_lit7";
2895 case DW_OP_lit8:
2896 return "DW_OP_lit8";
2897 case DW_OP_lit9:
2898 return "DW_OP_lit9";
2899 case DW_OP_lit10:
2900 return "DW_OP_lit10";
2901 case DW_OP_lit11:
2902 return "DW_OP_lit11";
2903 case DW_OP_lit12:
2904 return "DW_OP_lit12";
2905 case DW_OP_lit13:
2906 return "DW_OP_lit13";
2907 case DW_OP_lit14:
2908 return "DW_OP_lit14";
2909 case DW_OP_lit15:
2910 return "DW_OP_lit15";
2911 case DW_OP_lit16:
2912 return "DW_OP_lit16";
2913 case DW_OP_lit17:
2914 return "DW_OP_lit17";
2915 case DW_OP_lit18:
2916 return "DW_OP_lit18";
2917 case DW_OP_lit19:
2918 return "DW_OP_lit19";
2919 case DW_OP_lit20:
2920 return "DW_OP_lit20";
2921 case DW_OP_lit21:
2922 return "DW_OP_lit21";
2923 case DW_OP_lit22:
2924 return "DW_OP_lit22";
2925 case DW_OP_lit23:
2926 return "DW_OP_lit23";
2927 case DW_OP_lit24:
2928 return "DW_OP_lit24";
2929 case DW_OP_lit25:
2930 return "DW_OP_lit25";
2931 case DW_OP_lit26:
2932 return "DW_OP_lit26";
2933 case DW_OP_lit27:
2934 return "DW_OP_lit27";
2935 case DW_OP_lit28:
2936 return "DW_OP_lit28";
2937 case DW_OP_lit29:
2938 return "DW_OP_lit29";
2939 case DW_OP_lit30:
2940 return "DW_OP_lit30";
2941 case DW_OP_lit31:
2942 return "DW_OP_lit31";
2943 case DW_OP_reg0:
2944 return "DW_OP_reg0";
2945 case DW_OP_reg1:
2946 return "DW_OP_reg1";
2947 case DW_OP_reg2:
2948 return "DW_OP_reg2";
2949 case DW_OP_reg3:
2950 return "DW_OP_reg3";
2951 case DW_OP_reg4:
2952 return "DW_OP_reg4";
2953 case DW_OP_reg5:
2954 return "DW_OP_reg5";
2955 case DW_OP_reg6:
2956 return "DW_OP_reg6";
2957 case DW_OP_reg7:
2958 return "DW_OP_reg7";
2959 case DW_OP_reg8:
2960 return "DW_OP_reg8";
2961 case DW_OP_reg9:
2962 return "DW_OP_reg9";
2963 case DW_OP_reg10:
2964 return "DW_OP_reg10";
2965 case DW_OP_reg11:
2966 return "DW_OP_reg11";
2967 case DW_OP_reg12:
2968 return "DW_OP_reg12";
2969 case DW_OP_reg13:
2970 return "DW_OP_reg13";
2971 case DW_OP_reg14:
2972 return "DW_OP_reg14";
2973 case DW_OP_reg15:
2974 return "DW_OP_reg15";
2975 case DW_OP_reg16:
2976 return "DW_OP_reg16";
2977 case DW_OP_reg17:
2978 return "DW_OP_reg17";
2979 case DW_OP_reg18:
2980 return "DW_OP_reg18";
2981 case DW_OP_reg19:
2982 return "DW_OP_reg19";
2983 case DW_OP_reg20:
2984 return "DW_OP_reg20";
2985 case DW_OP_reg21:
2986 return "DW_OP_reg21";
2987 case DW_OP_reg22:
2988 return "DW_OP_reg22";
2989 case DW_OP_reg23:
2990 return "DW_OP_reg23";
2991 case DW_OP_reg24:
2992 return "DW_OP_reg24";
2993 case DW_OP_reg25:
2994 return "DW_OP_reg25";
2995 case DW_OP_reg26:
2996 return "DW_OP_reg26";
2997 case DW_OP_reg27:
2998 return "DW_OP_reg27";
2999 case DW_OP_reg28:
3000 return "DW_OP_reg28";
3001 case DW_OP_reg29:
3002 return "DW_OP_reg29";
3003 case DW_OP_reg30:
3004 return "DW_OP_reg30";
3005 case DW_OP_reg31:
3006 return "DW_OP_reg31";
3007 case DW_OP_breg0:
3008 return "DW_OP_breg0";
3009 case DW_OP_breg1:
3010 return "DW_OP_breg1";
3011 case DW_OP_breg2:
3012 return "DW_OP_breg2";
3013 case DW_OP_breg3:
3014 return "DW_OP_breg3";
3015 case DW_OP_breg4:
3016 return "DW_OP_breg4";
3017 case DW_OP_breg5:
3018 return "DW_OP_breg5";
3019 case DW_OP_breg6:
3020 return "DW_OP_breg6";
3021 case DW_OP_breg7:
3022 return "DW_OP_breg7";
3023 case DW_OP_breg8:
3024 return "DW_OP_breg8";
3025 case DW_OP_breg9:
3026 return "DW_OP_breg9";
3027 case DW_OP_breg10:
3028 return "DW_OP_breg10";
3029 case DW_OP_breg11:
3030 return "DW_OP_breg11";
3031 case DW_OP_breg12:
3032 return "DW_OP_breg12";
3033 case DW_OP_breg13:
3034 return "DW_OP_breg13";
3035 case DW_OP_breg14:
3036 return "DW_OP_breg14";
3037 case DW_OP_breg15:
3038 return "DW_OP_breg15";
3039 case DW_OP_breg16:
3040 return "DW_OP_breg16";
3041 case DW_OP_breg17:
3042 return "DW_OP_breg17";
3043 case DW_OP_breg18:
3044 return "DW_OP_breg18";
3045 case DW_OP_breg19:
3046 return "DW_OP_breg19";
3047 case DW_OP_breg20:
3048 return "DW_OP_breg20";
3049 case DW_OP_breg21:
3050 return "DW_OP_breg21";
3051 case DW_OP_breg22:
3052 return "DW_OP_breg22";
3053 case DW_OP_breg23:
3054 return "DW_OP_breg23";
3055 case DW_OP_breg24:
3056 return "DW_OP_breg24";
3057 case DW_OP_breg25:
3058 return "DW_OP_breg25";
3059 case DW_OP_breg26:
3060 return "DW_OP_breg26";
3061 case DW_OP_breg27:
3062 return "DW_OP_breg27";
3063 case DW_OP_breg28:
3064 return "DW_OP_breg28";
3065 case DW_OP_breg29:
3066 return "DW_OP_breg29";
3067 case DW_OP_breg30:
3068 return "DW_OP_breg30";
3069 case DW_OP_breg31:
3070 return "DW_OP_breg31";
3071 case DW_OP_regx:
3072 return "DW_OP_regx";
3073 case DW_OP_fbreg:
3074 return "DW_OP_fbreg";
3075 case DW_OP_bregx:
3076 return "DW_OP_bregx";
3077 case DW_OP_piece:
3078 return "DW_OP_piece";
3079 case DW_OP_deref_size:
3080 return "DW_OP_deref_size";
3081 case DW_OP_xderef_size:
3082 return "DW_OP_xderef_size";
3083 case DW_OP_nop:
3084 return "DW_OP_nop";
3085 case DW_OP_push_object_address:
3086 return "DW_OP_push_object_address";
3087 case DW_OP_call2:
3088 return "DW_OP_call2";
3089 case DW_OP_call4:
3090 return "DW_OP_call4";
3091 case DW_OP_call_ref:
3092 return "DW_OP_call_ref";
3093 case DW_OP_GNU_push_tls_address:
3094 return "DW_OP_GNU_push_tls_address";
3095 default:
3096 return "OP_<unknown>";
3097 }
3098}
3099
3100/* Return a pointer to a newly allocated location description. Location
3101 descriptions are simple expression terms that can be strung
3102 together to form more complicated location (address) descriptions. */
3103
3104static inline dw_loc_descr_ref
3105new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
3106 unsigned HOST_WIDE_INT oprnd2)
3107{
3108 dw_loc_descr_ref descr = ggc_alloc_cleared (sizeof (dw_loc_descr_node));
3109
3110 descr->dw_loc_opc = op;
3111 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
3112 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
3113 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
3114 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
3115
3116 return descr;
3117}
3118
3119/* Add a location description term to a location description expression. */
3120
3121static inline void
3122add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
3123{
3124 dw_loc_descr_ref *d;
3125
3126 /* Find the end of the chain. */
3127 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
3128 ;
3129
3130 *d = descr;
3131}
3132
3133/* Return the size of a location descriptor. */
3134
3135static unsigned long
3136size_of_loc_descr (dw_loc_descr_ref loc)
3137{
3138 unsigned long size = 1;
3139
3140 switch (loc->dw_loc_opc)
3141 {
3142 case DW_OP_addr:
3143 case INTERNAL_DW_OP_tls_addr:
3144 size += DWARF2_ADDR_SIZE;
3145 break;
3146 case DW_OP_const1u:
3147 case DW_OP_const1s:
3148 size += 1;
3149 break;
3150 case DW_OP_const2u:
3151 case DW_OP_const2s:
3152 size += 2;
3153 break;
3154 case DW_OP_const4u:
3155 case DW_OP_const4s:
3156 size += 4;
3157 break;
3158 case DW_OP_const8u:
3159 case DW_OP_const8s:
3160 size += 8;
3161 break;
3162 case DW_OP_constu:
3163 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3164 break;
3165 case DW_OP_consts:
3166 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3167 break;
3168 case DW_OP_pick:
3169 size += 1;
3170 break;
3171 case DW_OP_plus_uconst:
3172 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3173 break;
3174 case DW_OP_skip:
3175 case DW_OP_bra:
3176 size += 2;
3177 break;
3178 case DW_OP_breg0:
3179 case DW_OP_breg1:
3180 case DW_OP_breg2:
3181 case DW_OP_breg3:
3182 case DW_OP_breg4:
3183 case DW_OP_breg5:
3184 case DW_OP_breg6:
3185 case DW_OP_breg7:
3186 case DW_OP_breg8:
3187 case DW_OP_breg9:
3188 case DW_OP_breg10:
3189 case DW_OP_breg11:
3190 case DW_OP_breg12:
3191 case DW_OP_breg13:
3192 case DW_OP_breg14:
3193 case DW_OP_breg15:
3194 case DW_OP_breg16:
3195 case DW_OP_breg17:
3196 case DW_OP_breg18:
3197 case DW_OP_breg19:
3198 case DW_OP_breg20:
3199 case DW_OP_breg21:
3200 case DW_OP_breg22:
3201 case DW_OP_breg23:
3202 case DW_OP_breg24:
3203 case DW_OP_breg25:
3204 case DW_OP_breg26:
3205 case DW_OP_breg27:
3206 case DW_OP_breg28:
3207 case DW_OP_breg29:
3208 case DW_OP_breg30:
3209 case DW_OP_breg31:
3210 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3211 break;
3212 case DW_OP_regx:
3213 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3214 break;
3215 case DW_OP_fbreg:
3216 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3217 break;
3218 case DW_OP_bregx:
3219 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3220 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
3221 break;
3222 case DW_OP_piece:
3223 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3224 break;
3225 case DW_OP_deref_size:
3226 case DW_OP_xderef_size:
3227 size += 1;
3228 break;
3229 case DW_OP_call2:
3230 size += 2;
3231 break;
3232 case DW_OP_call4:
3233 size += 4;
3234 break;
3235 case DW_OP_call_ref:
3236 size += DWARF2_ADDR_SIZE;
3237 break;
3238 default:
3239 break;
3240 }
3241
3242 return size;
3243}
3244
3245/* Return the size of a series of location descriptors. */
3246
3247static unsigned long
3248size_of_locs (dw_loc_descr_ref loc)
3249{
3250 dw_loc_descr_ref l;
3251 unsigned long size;
3252
3253 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
3254 field, to avoid writing to a PCH file. */
3255 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
3256 {
3257 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
3258 break;
3259 size += size_of_loc_descr (l);
3260 }
3261 if (! l)
3262 return size;
3263
3264 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
3265 {
3266 l->dw_loc_addr = size;
3267 size += size_of_loc_descr (l);
3268 }
3269
3270 return size;
3271}
3272
3273/* Output location description stack opcode's operands (if any). */
3274
3275static void
3276output_loc_operands (dw_loc_descr_ref loc)
3277{
3278 dw_val_ref val1 = &loc->dw_loc_oprnd1;
3279 dw_val_ref val2 = &loc->dw_loc_oprnd2;
3280
3281 switch (loc->dw_loc_opc)
3282 {
3283#ifdef DWARF2_DEBUGGING_INFO
3284 case DW_OP_addr:
3285 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
3286 break;
3287 case DW_OP_const2u:
3288 case DW_OP_const2s:
3289 dw2_asm_output_data (2, val1->v.val_int, NULL);
3290 break;
3291 case DW_OP_const4u:
3292 case DW_OP_const4s:
3293 dw2_asm_output_data (4, val1->v.val_int, NULL);
3294 break;
3295 case DW_OP_const8u:
3296 case DW_OP_const8s:
3297 gcc_assert (HOST_BITS_PER_LONG >= 64);
3298 dw2_asm_output_data (8, val1->v.val_int, NULL);
3299 break;
3300 case DW_OP_skip:
3301 case DW_OP_bra:
3302 {
3303 int offset;
3304
3305 gcc_assert (val1->val_class == dw_val_class_loc);
3306 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
3307
3308 dw2_asm_output_data (2, offset, NULL);
3309 }
3310 break;
3311#else
3312 case DW_OP_addr:
3313 case DW_OP_const2u:
3314 case DW_OP_const2s:
3315 case DW_OP_const4u:
3316 case DW_OP_const4s:
3317 case DW_OP_const8u:
3318 case DW_OP_const8s:
3319 case DW_OP_skip:
3320 case DW_OP_bra:
3321 /* We currently don't make any attempt to make sure these are
3322 aligned properly like we do for the main unwind info, so
3323 don't support emitting things larger than a byte if we're
3324 only doing unwinding. */
3325 gcc_unreachable ();
3326#endif
3327 case DW_OP_const1u:
3328 case DW_OP_const1s:
3329 dw2_asm_output_data (1, val1->v.val_int, NULL);
3330 break;
3331 case DW_OP_constu:
3332 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3333 break;
3334 case DW_OP_consts:
3335 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3336 break;
3337 case DW_OP_pick:
3338 dw2_asm_output_data (1, val1->v.val_int, NULL);
3339 break;
3340 case DW_OP_plus_uconst:
3341 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3342 break;
3343 case DW_OP_breg0:
3344 case DW_OP_breg1:
3345 case DW_OP_breg2:
3346 case DW_OP_breg3:
3347 case DW_OP_breg4:
3348 case DW_OP_breg5:
3349 case DW_OP_breg6:
3350 case DW_OP_breg7:
3351 case DW_OP_breg8:
3352 case DW_OP_breg9:
3353 case DW_OP_breg10:
3354 case DW_OP_breg11:
3355 case DW_OP_breg12:
3356 case DW_OP_breg13:
3357 case DW_OP_breg14:
3358 case DW_OP_breg15:
3359 case DW_OP_breg16:
3360 case DW_OP_breg17:
3361 case DW_OP_breg18:
3362 case DW_OP_breg19:
3363 case DW_OP_breg20:
3364 case DW_OP_breg21:
3365 case DW_OP_breg22:
3366 case DW_OP_breg23:
3367 case DW_OP_breg24:
3368 case DW_OP_breg25:
3369 case DW_OP_breg26:
3370 case DW_OP_breg27:
3371 case DW_OP_breg28:
3372 case DW_OP_breg29:
3373 case DW_OP_breg30:
3374 case DW_OP_breg31:
3375 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3376 break;
3377 case DW_OP_regx:
3378 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3379 break;
3380 case DW_OP_fbreg:
3381 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3382 break;
3383 case DW_OP_bregx:
3384 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3385 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
3386 break;
3387 case DW_OP_piece:
3388 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3389 break;
3390 case DW_OP_deref_size:
3391 case DW_OP_xderef_size:
3392 dw2_asm_output_data (1, val1->v.val_int, NULL);
3393 break;
3394
3395 case INTERNAL_DW_OP_tls_addr:
3396 if (targetm.asm_out.output_dwarf_dtprel)
3397 {
3398 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
3399 DWARF2_ADDR_SIZE,
3400 val1->v.val_addr);
3401 fputc ('\n', asm_out_file);
3402 }
3403 else
3404 gcc_unreachable ();
3405 break;
3406
3407 default:
3408 /* Other codes have no operands. */
3409 break;
3410 }
3411}
3412
3413/* Output a sequence of location operations. */
3414
3415static void
3416output_loc_sequence (dw_loc_descr_ref loc)
3417{
3418 for (; loc != NULL; loc = loc->dw_loc_next)
3419 {
3420 /* Output the opcode. */
3421 dw2_asm_output_data (1, loc->dw_loc_opc,
3422 "%s", dwarf_stack_op_name (loc->dw_loc_opc));
3423
3424 /* Output the operand(s) (if any). */
3425 output_loc_operands (loc);
3426 }
3427}
3428
3429/* This routine will generate the correct assembly data for a location
3430 description based on a cfi entry with a complex address. */
3431
3432static void
3433output_cfa_loc (dw_cfi_ref cfi)
3434{
3435 dw_loc_descr_ref loc;
3436 unsigned long size;
3437
3438 /* Output the size of the block. */
3439 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
3440 size = size_of_locs (loc);
3441 dw2_asm_output_data_uleb128 (size, NULL);
3442
3443 /* Now output the operations themselves. */
3444 output_loc_sequence (loc);
3445}
3446
3447/* This function builds a dwarf location descriptor sequence from a
3448 dw_cfa_location, adding the given OFFSET to the result of the
3449 expression. */
3450
3451static struct dw_loc_descr_struct *
3452build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
3453{
3454 struct dw_loc_descr_struct *head, *tmp;
3455
3456 offset += cfa->offset;
3457
3458 if (cfa->indirect)
3459 {
3460 if (cfa->base_offset)
3461 {
3462 if (cfa->reg <= 31)
3463 head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0);
3464 else
3465 head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset);
3466 }
3467 else if (cfa->reg <= 31)
3468 head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
3469 else
3470 head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
3471
3472 head->dw_loc_oprnd1.val_class = dw_val_class_const;
3473 tmp = new_loc_descr (DW_OP_deref, 0, 0);
3474 add_loc_descr (&head, tmp);
3475 if (offset != 0)
3476 {
3477 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
3478 add_loc_descr (&head, tmp);
3479 }
3480 }
3481 else
3482 {
3483 if (offset == 0)
3484 if (cfa->reg <= 31)
3485 head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
3486 else
3487 head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
3488 else if (cfa->reg <= 31)
3489 head = new_loc_descr (DW_OP_breg0 + cfa->reg, offset, 0);
3490 else
3491 head = new_loc_descr (DW_OP_bregx, cfa->reg, offset);
3492 }
3493
3494 return head;
3495}
3496
3497/* This function fills in aa dw_cfa_location structure from a dwarf location
3498 descriptor sequence. */
3499
3500static void
3501get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
3502{
3503 struct dw_loc_descr_struct *ptr;
3504 cfa->offset = 0;
3505 cfa->base_offset = 0;
3506 cfa->indirect = 0;
3507 cfa->reg = -1;
3508
3509 for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
3510 {
3511 enum dwarf_location_atom op = ptr->dw_loc_opc;
3512
3513 switch (op)
3514 {
3515 case DW_OP_reg0:
3516 case DW_OP_reg1:
3517 case DW_OP_reg2:
3518 case DW_OP_reg3:
3519 case DW_OP_reg4:
3520 case DW_OP_reg5:
3521 case DW_OP_reg6:
3522 case DW_OP_reg7:
3523 case DW_OP_reg8:
3524 case DW_OP_reg9:
3525 case DW_OP_reg10:
3526 case DW_OP_reg11:
3527 case DW_OP_reg12:
3528 case DW_OP_reg13:
3529 case DW_OP_reg14:
3530 case DW_OP_reg15:
3531 case DW_OP_reg16:
3532 case DW_OP_reg17:
3533 case DW_OP_reg18:
3534 case DW_OP_reg19:
3535 case DW_OP_reg20:
3536 case DW_OP_reg21:
3537 case DW_OP_reg22:
3538 case DW_OP_reg23:
3539 case DW_OP_reg24:
3540 case DW_OP_reg25:
3541 case DW_OP_reg26:
3542 case DW_OP_reg27:
3543 case DW_OP_reg28:
3544 case DW_OP_reg29:
3545 case DW_OP_reg30:
3546 case DW_OP_reg31:
3547 cfa->reg = op - DW_OP_reg0;
3548 break;
3549 case DW_OP_regx:
3550 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3551 break;
3552 case DW_OP_breg0:
3553 case DW_OP_breg1:
3554 case DW_OP_breg2:
3555 case DW_OP_breg3:
3556 case DW_OP_breg4:
3557 case DW_OP_breg5:
3558 case DW_OP_breg6:
3559 case DW_OP_breg7:
3560 case DW_OP_breg8:
3561 case DW_OP_breg9:
3562 case DW_OP_breg10:
3563 case DW_OP_breg11:
3564 case DW_OP_breg12:
3565 case DW_OP_breg13:
3566 case DW_OP_breg14:
3567 case DW_OP_breg15:
3568 case DW_OP_breg16:
3569 case DW_OP_breg17:
3570 case DW_OP_breg18:
3571 case DW_OP_breg19:
3572 case DW_OP_breg20:
3573 case DW_OP_breg21:
3574 case DW_OP_breg22:
3575 case DW_OP_breg23:
3576 case DW_OP_breg24:
3577 case DW_OP_breg25:
3578 case DW_OP_breg26:
3579 case DW_OP_breg27:
3580 case DW_OP_breg28:
3581 case DW_OP_breg29:
3582 case DW_OP_breg30:
3583 case DW_OP_breg31:
3584 cfa->reg = op - DW_OP_breg0;
3585 cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
3586 break;
3587 case DW_OP_bregx:
3588 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3589 cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
3590 break;
3591 case DW_OP_deref:
3592 cfa->indirect = 1;
3593 break;
3594 case DW_OP_plus_uconst:
3595 cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
3596 break;
3597 default:
3598 internal_error ("DW_LOC_OP %s not implemented",
3599 dwarf_stack_op_name (ptr->dw_loc_opc));
3600 }
3601 }
3602}
3603#endif /* .debug_frame support */
3604
3605/* And now, the support for symbolic debugging information. */
3606#ifdef DWARF2_DEBUGGING_INFO
3607
3608/* .debug_str support. */
3609static int output_indirect_string (void **, void *);
3610
3611static void dwarf2out_init (const char *);
3612static void dwarf2out_finish (const char *);
3613static void dwarf2out_define (unsigned int, const char *);
3614static void dwarf2out_undef (unsigned int, const char *);
3615static void dwarf2out_start_source_file (unsigned, const char *);
3616static void dwarf2out_end_source_file (unsigned);
3617static void dwarf2out_begin_block (unsigned, unsigned);
3618static void dwarf2out_end_block (unsigned, unsigned);
3619static bool dwarf2out_ignore_block (tree);
3620static void dwarf2out_global_decl (tree);
3621static void dwarf2out_type_decl (tree, int);
3622static void dwarf2out_imported_module_or_decl (tree, tree);
3623static void dwarf2out_abstract_function (tree);
3624static void dwarf2out_var_location (rtx);
3625static void dwarf2out_begin_function (tree);
3626static void dwarf2out_switch_text_section (void);
3627
3628/* The debug hooks structure. */
3629
3630const struct gcc_debug_hooks dwarf2_debug_hooks =
3631{
3632 dwarf2out_init,
3633 dwarf2out_finish,
3634 dwarf2out_define,
3635 dwarf2out_undef,
3636 dwarf2out_start_source_file,
3637 dwarf2out_end_source_file,
3638 dwarf2out_begin_block,
3639 dwarf2out_end_block,
3640 dwarf2out_ignore_block,
3641 dwarf2out_source_line,
3642 dwarf2out_begin_prologue,
3643 debug_nothing_int_charstar, /* end_prologue */
3644 dwarf2out_end_epilogue,
3645 dwarf2out_begin_function,
3646 debug_nothing_int, /* end_function */
3647 dwarf2out_decl, /* function_decl */
3648 dwarf2out_global_decl,
3649 dwarf2out_type_decl, /* type_decl */
3650 dwarf2out_imported_module_or_decl,
3651 debug_nothing_tree, /* deferred_inline_function */
3652 /* The DWARF 2 backend tries to reduce debugging bloat by not
3653 emitting the abstract description of inline functions until
3654 something tries to reference them. */
3655 dwarf2out_abstract_function, /* outlining_inline_function */
3656 debug_nothing_rtx, /* label */
3657 debug_nothing_int, /* handle_pch */
3658 dwarf2out_var_location,
3659 dwarf2out_switch_text_section,
3660 1 /* start_end_main_source_file */
3661};
3662#endif
3663
3664/* NOTE: In the comments in this file, many references are made to
3665 "Debugging Information Entries". This term is abbreviated as `DIE'
3666 throughout the remainder of this file. */
3667
3668/* An internal representation of the DWARF output is built, and then
3669 walked to generate the DWARF debugging info. The walk of the internal
3670 representation is done after the entire program has been compiled.
3671 The types below are used to describe the internal representation. */
3672
3673/* Various DIE's use offsets relative to the beginning of the
3674 .debug_info section to refer to each other. */
3675
3676typedef long int dw_offset;
3677
3678/* Define typedefs here to avoid circular dependencies. */
3679
3680typedef struct dw_attr_struct *dw_attr_ref;
3681typedef struct dw_line_info_struct *dw_line_info_ref;
3682typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
3683typedef struct pubname_struct *pubname_ref;
3684typedef struct dw_ranges_struct *dw_ranges_ref;
3685
3686/* Each entry in the line_info_table maintains the file and
3687 line number associated with the label generated for that
3688 entry. The label gives the PC value associated with
3689 the line number entry. */
3690
3691typedef struct dw_line_info_struct GTY(())
3692{
3693 unsigned long dw_file_num;
3694 unsigned long dw_line_num;
3695}
3696dw_line_info_entry;
3697
3698/* Line information for functions in separate sections; each one gets its
3699 own sequence. */
3700typedef struct dw_separate_line_info_struct GTY(())
3701{
3702 unsigned long dw_file_num;
3703 unsigned long dw_line_num;
3704 unsigned long function;
3705}
3706dw_separate_line_info_entry;
3707
3708/* Each DIE attribute has a field specifying the attribute kind,
3709 a link to the next attribute in the chain, and an attribute value.
3710 Attributes are typically linked below the DIE they modify. */
3711
3712typedef struct dw_attr_struct GTY(())
3713{
3714 enum dwarf_attribute dw_attr;
3715 dw_val_node dw_attr_val;
3716}
3717dw_attr_node;
3718
3719DEF_VEC_O(dw_attr_node);
3720DEF_VEC_ALLOC_O(dw_attr_node,gc);
3721
3722/* The Debugging Information Entry (DIE) structure. DIEs form a tree.
3723 The children of each node form a circular list linked by
3724 die_sib. die_child points to the node *before* the "first" child node. */
3725
3726typedef struct die_struct GTY(())
3727{
3728 enum dwarf_tag die_tag;
3729 char *die_symbol;
3730 VEC(dw_attr_node,gc) * die_attr;
3731 dw_die_ref die_parent;
3732 dw_die_ref die_child;
3733 dw_die_ref die_sib;
3734 dw_die_ref die_definition; /* ref from a specification to its definition */
3735 dw_offset die_offset;
3736 unsigned long die_abbrev;
3737 int die_mark;
3738 /* Die is used and must not be pruned as unused. */
3739 int die_perennial_p;
3740 unsigned int decl_id;
3741}
3742die_node;
3743
3744/* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
3745#define FOR_EACH_CHILD(die, c, expr) do { \
3746 c = die->die_child; \
3747 if (c) do { \
3748 c = c->die_sib; \
3749 expr; \
3750 } while (c != die->die_child); \
3751} while (0)
3752
3753/* The pubname structure */
3754
3755typedef struct pubname_struct GTY(())
3756{
3757 dw_die_ref die;
3758 char *name;
3759}
3760pubname_entry;
3761
3762struct dw_ranges_struct GTY(())
3763{
3764 int block_num;
3765};
3766
3767/* The limbo die list structure. */
3768typedef struct limbo_die_struct GTY(())
3769{
3770 dw_die_ref die;
3771 tree created_for;
3772 struct limbo_die_struct *next;
3773}
3774limbo_die_node;
3775
3776/* How to start an assembler comment. */
3777#ifndef ASM_COMMENT_START
3778#define ASM_COMMENT_START ";#"
3779#endif
3780
3781/* Define a macro which returns nonzero for a TYPE_DECL which was
3782 implicitly generated for a tagged type.
3783
3784 Note that unlike the gcc front end (which generates a NULL named
3785 TYPE_DECL node for each complete tagged type, each array type, and
3786 each function type node created) the g++ front end generates a
3787 _named_ TYPE_DECL node for each tagged type node created.
3788 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3789 generate a DW_TAG_typedef DIE for them. */
3790
3791#define TYPE_DECL_IS_STUB(decl) \
3792 (DECL_NAME (decl) == NULL_TREE \
3793 || (DECL_ARTIFICIAL (decl) \
3794 && is_tagged_type (TREE_TYPE (decl)) \
3795 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
3796 /* This is necessary for stub decls that \
3797 appear in nested inline functions. */ \
3798 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3799 && (decl_ultimate_origin (decl) \
3800 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3801
3802/* Information concerning the compilation unit's programming
3803 language, and compiler version. */
3804
3805/* Fixed size portion of the DWARF compilation unit header. */
3806#define DWARF_COMPILE_UNIT_HEADER_SIZE \
3807 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
3808
3809/* Fixed size portion of public names info. */
3810#define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3811
3812/* Fixed size portion of the address range info. */
3813#define DWARF_ARANGES_HEADER_SIZE \
3814 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3815 DWARF2_ADDR_SIZE * 2) \
3816 - DWARF_INITIAL_LENGTH_SIZE)
3817
3818/* Size of padding portion in the address range info. It must be
3819 aligned to twice the pointer size. */
3820#define DWARF_ARANGES_PAD_SIZE \
3821 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3822 DWARF2_ADDR_SIZE * 2) \
3823 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
3824
3825/* Use assembler line directives if available. */
3826#ifndef DWARF2_ASM_LINE_DEBUG_INFO
3827#ifdef HAVE_AS_DWARF2_DEBUG_LINE
3828#define DWARF2_ASM_LINE_DEBUG_INFO 1
3829#else
3830#define DWARF2_ASM_LINE_DEBUG_INFO 0
3831#endif
3832#endif
3833
3834/* Minimum line offset in a special line info. opcode.
3835 This value was chosen to give a reasonable range of values. */
3836#define DWARF_LINE_BASE -10
3837
3838/* First special line opcode - leave room for the standard opcodes. */
3839#define DWARF_LINE_OPCODE_BASE 10
3840
3841/* Range of line offsets in a special line info. opcode. */
3842#define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
3843
3844/* Flag that indicates the initial value of the is_stmt_start flag.
3845 In the present implementation, we do not mark any lines as
3846 the beginning of a source statement, because that information
3847 is not made available by the GCC front-end. */
3848#define DWARF_LINE_DEFAULT_IS_STMT_START 1
3849
3850#ifdef DWARF2_DEBUGGING_INFO
3851/* This location is used by calc_die_sizes() to keep track
3852 the offset of each DIE within the .debug_info section. */
3853static unsigned long next_die_offset;
3854#endif
3855
3856/* Record the root of the DIE's built for the current compilation unit. */
3857static GTY(()) dw_die_ref comp_unit_die;
3858
3859/* A list of DIEs with a NULL parent waiting to be relocated. */
3860static GTY(()) limbo_die_node *limbo_die_list;
3861
3862/* Filenames referenced by this compilation unit. */
3863static GTY((param_is (struct dwarf_file_data))) htab_t file_table;
3864
3865/* A hash table of references to DIE's that describe declarations.
3866 The key is a DECL_UID() which is a unique number identifying each decl. */
3867static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
3868
3869/* Node of the variable location list. */
3870struct var_loc_node GTY ((chain_next ("%h.next")))
3871{
3872 rtx GTY (()) var_loc_note;
3873 const char * GTY (()) label;
3874 const char * GTY (()) section_label;
3875 struct var_loc_node * GTY (()) next;
3876};
3877
3878/* Variable location list. */
3879struct var_loc_list_def GTY (())
3880{
3881 struct var_loc_node * GTY (()) first;
3882
3883 /* Do not mark the last element of the chained list because
3884 it is marked through the chain. */
3885 struct var_loc_node * GTY ((skip ("%h"))) last;
3886
3887 /* DECL_UID of the variable decl. */
3888 unsigned int decl_id;
3889};
3890typedef struct var_loc_list_def var_loc_list;
3891
3892
3893/* Table of decl location linked lists. */
3894static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
3895
3896/* A pointer to the base of a list of references to DIE's that
3897 are uniquely identified by their tag, presence/absence of
3898 children DIE's, and list of attribute/value pairs. */
3899static GTY((length ("abbrev_die_table_allocated")))
3900 dw_die_ref *abbrev_die_table;
3901
3902/* Number of elements currently allocated for abbrev_die_table. */
3903static GTY(()) unsigned abbrev_die_table_allocated;
3904
3905/* Number of elements in type_die_table currently in use. */
3906static GTY(()) unsigned abbrev_die_table_in_use;
3907
3908/* Size (in elements) of increments by which we may expand the
3909 abbrev_die_table. */
3910#define ABBREV_DIE_TABLE_INCREMENT 256
3911
3912/* A pointer to the base of a table that contains line information
3913 for each source code line in .text in the compilation unit. */
3914static GTY((length ("line_info_table_allocated")))
3915 dw_line_info_ref line_info_table;
3916
3917/* Number of elements currently allocated for line_info_table. */
3918static GTY(()) unsigned line_info_table_allocated;
3919
3920/* Number of elements in line_info_table currently in use. */
3921static GTY(()) unsigned line_info_table_in_use;
3922
3923/* True if the compilation unit places functions in more than one section. */
3924static GTY(()) bool have_multiple_function_sections = false;
3925
3926/* A pointer to the base of a table that contains line information
3927 for each source code line outside of .text in the compilation unit. */
3928static GTY ((length ("separate_line_info_table_allocated")))
3929 dw_separate_line_info_ref separate_line_info_table;
3930
3931/* Number of elements currently allocated for separate_line_info_table. */
3932static GTY(()) unsigned separate_line_info_table_allocated;
3933
3934/* Number of elements in separate_line_info_table currently in use. */
3935static GTY(()) unsigned separate_line_info_table_in_use;
3936
3937/* Size (in elements) of increments by which we may expand the
3938 line_info_table. */
3939#define LINE_INFO_TABLE_INCREMENT 1024
3940
3941/* A pointer to the base of a table that contains a list of publicly
3942 accessible names. */
3943static GTY ((length ("pubname_table_allocated"))) pubname_ref pubname_table;
3944
3945/* Number of elements currently allocated for pubname_table. */
3946static GTY(()) unsigned pubname_table_allocated;
3947
3948/* Number of elements in pubname_table currently in use. */
3949static GTY(()) unsigned pubname_table_in_use;
3950
3951/* Size (in elements) of increments by which we may expand the
3952 pubname_table. */
3953#define PUBNAME_TABLE_INCREMENT 64
3954
3955/* Array of dies for which we should generate .debug_arange info. */
3956static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
3957
3958/* Number of elements currently allocated for arange_table. */
3959static GTY(()) unsigned arange_table_allocated;
3960
3961/* Number of elements in arange_table currently in use. */
3962static GTY(()) unsigned arange_table_in_use;
3963
3964/* Size (in elements) of increments by which we may expand the
3965 arange_table. */
3966#define ARANGE_TABLE_INCREMENT 64
3967
3968/* Array of dies for which we should generate .debug_ranges info. */
3969static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
3970
3971/* Number of elements currently allocated for ranges_table. */
3972static GTY(()) unsigned ranges_table_allocated;
3973
3974/* Number of elements in ranges_table currently in use. */
3975static GTY(()) unsigned ranges_table_in_use;
3976
3977/* Size (in elements) of increments by which we may expand the
3978 ranges_table. */
3979#define RANGES_TABLE_INCREMENT 64
3980
3981/* Whether we have location lists that need outputting */
3982static GTY(()) bool have_location_lists;
3983
3984/* Unique label counter. */
3985static GTY(()) unsigned int loclabel_num;
3986
3987#ifdef DWARF2_DEBUGGING_INFO
3988/* Record whether the function being analyzed contains inlined functions. */
3989static int current_function_has_inlines;
3990#endif
3991#if 0 && defined (MIPS_DEBUGGING_INFO)
3992static int comp_unit_has_inlines;
3993#endif
3994
3995/* The last file entry emitted by maybe_emit_file(). */
3996static GTY(()) struct dwarf_file_data * last_emitted_file;
3997
3998/* Number of internal labels generated by gen_internal_sym(). */
3999static GTY(()) int label_num;
4000
4001/* Cached result of previous call to lookup_filename. */
4002static GTY(()) struct dwarf_file_data * file_table_last_lookup;
4003
4004#ifdef DWARF2_DEBUGGING_INFO
4005
4006/* Offset from the "steady-state frame pointer" to the frame base,
4007 within the current function. */
4008static HOST_WIDE_INT frame_pointer_fb_offset;
4009
4010/* Forward declarations for functions defined in this file. */
4011
4012static int is_pseudo_reg (rtx);
4013static tree type_main_variant (tree);
4014static int is_tagged_type (tree);
4015static const char *dwarf_tag_name (unsigned);
4016static const char *dwarf_attr_name (unsigned);
4017static const char *dwarf_form_name (unsigned);
4018static tree decl_ultimate_origin (tree);
4019static tree block_ultimate_origin (tree);
4020static tree decl_class_context (tree);
4021static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
4022static inline enum dw_val_class AT_class (dw_attr_ref);
4023static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
4024static inline unsigned AT_flag (dw_attr_ref);
4025static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
4026static inline HOST_WIDE_INT AT_int (dw_attr_ref);
4027static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
4028static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
4029static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long,
4030 unsigned long);
4031static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
4032 unsigned int, unsigned char *);
4033static hashval_t debug_str_do_hash (const void *);
4034static int debug_str_eq (const void *, const void *);
4035static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
4036static inline const char *AT_string (dw_attr_ref);
4037static int AT_string_form (dw_attr_ref);
4038static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
4039static void add_AT_specification (dw_die_ref, dw_die_ref);
4040static inline dw_die_ref AT_ref (dw_attr_ref);
4041static inline int AT_ref_external (dw_attr_ref);
4042static inline void set_AT_ref_external (dw_attr_ref, int);
4043static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
4044static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
4045static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
4046static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
4047 dw_loc_list_ref);
4048static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
4049static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
4050static inline rtx AT_addr (dw_attr_ref);
4051static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
4052static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
4053static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
4054static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
4055 unsigned HOST_WIDE_INT);
4056static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
4057 unsigned long);
4058static inline const char *AT_lbl (dw_attr_ref);
4059static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
4060static const char *get_AT_low_pc (dw_die_ref);
4061static const char *get_AT_hi_pc (dw_die_ref);
4062static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
4063static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
4064static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
4065static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
4066static bool is_c_family (void);
4067static bool is_cxx (void);
4068static bool is_java (void);
4069static bool is_fortran (void);
4070static bool is_ada (void);
4071static void remove_AT (dw_die_ref, enum dwarf_attribute);
4072static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
4073static void add_child_die (dw_die_ref, dw_die_ref);
4074static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
4075static dw_die_ref lookup_type_die (tree);
4076static void equate_type_number_to_die (tree, dw_die_ref);
4077static hashval_t decl_die_table_hash (const void *);
4078static int decl_die_table_eq (const void *, const void *);
4079static dw_die_ref lookup_decl_die (tree);
4080static hashval_t decl_loc_table_hash (const void *);
4081static int decl_loc_table_eq (const void *, const void *);
4082static var_loc_list *lookup_decl_loc (tree);
4083static void equate_decl_number_to_die (tree, dw_die_ref);
4084static void add_var_loc_to_decl (tree, struct var_loc_node *);
4085static void print_spaces (FILE *);
4086static void print_die (dw_die_ref, FILE *);
4087static void print_dwarf_line_table (FILE *);
4088static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
4089static dw_die_ref pop_compile_unit (dw_die_ref);
4090static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
4091static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
4092static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
4093static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
4094static int same_dw_val_p (dw_val_node *, dw_val_node *, int *);
4095static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
4096static int same_die_p (dw_die_ref, dw_die_ref, int *);
4097static int same_die_p_wrap (dw_die_ref, dw_die_ref);
4098static void compute_section_prefix (dw_die_ref);
4099static int is_type_die (dw_die_ref);
4100static int is_comdat_die (dw_die_ref);
4101static int is_symbol_die (dw_die_ref);
4102static void assign_symbol_names (dw_die_ref);
4103static void break_out_includes (dw_die_ref);
4104static hashval_t htab_cu_hash (const void *);
4105static int htab_cu_eq (const void *, const void *);
4106static void htab_cu_del (void *);
4107static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
4108static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
4109static void add_sibling_attributes (dw_die_ref);
4110static void build_abbrev_table (dw_die_ref);
4111static void output_location_lists (dw_die_ref);
4112static int constant_size (long unsigned);
4113static unsigned long size_of_die (dw_die_ref);
4114static void calc_die_sizes (dw_die_ref);
4115static void mark_dies (dw_die_ref);
4116static void unmark_dies (dw_die_ref);
4117static void unmark_all_dies (dw_die_ref);
4118static unsigned long size_of_pubnames (void);
4119static unsigned long size_of_aranges (void);
4120static enum dwarf_form value_format (dw_attr_ref);
4121static void output_value_format (dw_attr_ref);
4122static void output_abbrev_section (void);
4123static void output_die_symbol (dw_die_ref);
4124static void output_die (dw_die_ref);
4125static void output_compilation_unit_header (void);
4126static void output_comp_unit (dw_die_ref, int);
4127static const char *dwarf2_name (tree, int);
4128static void add_pubname (tree, dw_die_ref);
4129static void output_pubnames (void);
4130static void add_arange (tree, dw_die_ref);
4131static void output_aranges (void);
4132static unsigned int add_ranges (tree);
4133static void output_ranges (void);
4134static void output_line_info (void);
4135static void output_file_names (void);
4136static dw_die_ref base_type_die (tree);
4137static tree root_type (tree);
4138static int is_base_type (tree);
4139static bool is_subrange_type (tree);
4140static dw_die_ref subrange_type_die (tree, dw_die_ref);
4141static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
4142static int type_is_enum (tree);
4143static unsigned int dbx_reg_number (rtx);
4144static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
4145static dw_loc_descr_ref reg_loc_descriptor (rtx);
4146static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int);
4147static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx);
4148static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
4149static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT);
4150static int is_based_loc (rtx);
4151static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode);
4152static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx);
4153static dw_loc_descr_ref loc_descriptor (rtx);
4154static dw_loc_descr_ref loc_descriptor_from_tree_1 (tree, int);
4155static dw_loc_descr_ref loc_descriptor_from_tree (tree);
4156static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
4157static tree field_type (tree);
4158static unsigned int simple_type_align_in_bits (tree);
4159static unsigned int simple_decl_align_in_bits (tree);
4160static unsigned HOST_WIDE_INT simple_type_size_in_bits (tree);
4161static HOST_WIDE_INT field_byte_offset (tree);
4162static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
4163 dw_loc_descr_ref);
4164static void add_data_member_location_attribute (dw_die_ref, tree);
4165static void add_const_value_attribute (dw_die_ref, rtx);
4166static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
4167static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
4168static void insert_float (rtx, unsigned char *);
4169static rtx rtl_for_decl_location (tree);
4170static void add_location_or_const_value_attribute (dw_die_ref, tree,
4171 enum dwarf_attribute);
4172static void tree_add_const_value_attribute (dw_die_ref, tree);
4173static void add_name_attribute (dw_die_ref, const char *);
4174static void add_comp_dir_attribute (dw_die_ref);
4175static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
4176static void add_subscript_info (dw_die_ref, tree);
4177static void add_byte_size_attribute (dw_die_ref, tree);
4178static void add_bit_offset_attribute (dw_die_ref, tree);
4179static void add_bit_size_attribute (dw_die_ref, tree);
4180static void add_prototyped_attribute (dw_die_ref, tree);
4181static void add_abstract_origin_attribute (dw_die_ref, tree);
4182static void add_pure_or_virtual_attribute (dw_die_ref, tree);
4183static void add_src_coords_attributes (dw_die_ref, tree);
4184static void add_name_and_src_coords_attributes (dw_die_ref, tree);
4185static void push_decl_scope (tree);
4186static void pop_decl_scope (void);
4187static dw_die_ref scope_die_for (tree, dw_die_ref);
4188static inline int local_scope_p (dw_die_ref);
4189static inline int class_or_namespace_scope_p (dw_die_ref);
4190static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
4191static void add_calling_convention_attribute (dw_die_ref, tree);
4192static const char *type_tag (tree);
4193static tree member_declared_type (tree);
4194#if 0
4195static const char *decl_start_label (tree);
4196#endif
4197static void gen_array_type_die (tree, dw_die_ref);
4198#if 0
4199static void gen_entry_point_die (tree, dw_die_ref);
4200#endif
4201static void gen_inlined_enumeration_type_die (tree, dw_die_ref);
4202static void gen_inlined_structure_type_die (tree, dw_die_ref);
4203static void gen_inlined_union_type_die (tree, dw_die_ref);
4204static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
4205static dw_die_ref gen_formal_parameter_die (tree, dw_die_ref);
4206static void gen_unspecified_parameters_die (tree, dw_die_ref);
4207static void gen_formal_types_die (tree, dw_die_ref);
4208static void gen_subprogram_die (tree, dw_die_ref);
4209static void gen_variable_die (tree, dw_die_ref);
4210static void gen_label_die (tree, dw_die_ref);
4211static void gen_lexical_block_die (tree, dw_die_ref, int);
4212static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
4213static void gen_field_die (tree, dw_die_ref);
4214static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
4215static dw_die_ref gen_compile_unit_die (const char *);
4216static void gen_inheritance_die (tree, tree, dw_die_ref);
4217static void gen_member_die (tree, dw_die_ref);
4218static void gen_struct_or_union_type_die (tree, dw_die_ref,
4219 enum debug_info_usage);
4220static void gen_subroutine_type_die (tree, dw_die_ref);
4221static void gen_typedef_die (tree, dw_die_ref);
4222static void gen_type_die (tree, dw_die_ref);
4223static void gen_tagged_type_instantiation_die (tree, dw_die_ref);
4224static void gen_block_die (tree, dw_die_ref, int);
4225static void decls_for_scope (tree, dw_die_ref, int);
4226static int is_redundant_typedef (tree);
4227static void gen_namespace_die (tree);
4228static void gen_decl_die (tree, dw_die_ref);
4229static dw_die_ref force_decl_die (tree);
4230static dw_die_ref force_type_die (tree);
4231static dw_die_ref setup_namespace_context (tree, dw_die_ref);
4232static void declare_in_namespace (tree, dw_die_ref);
4233static struct dwarf_file_data * lookup_filename (const char *);
4234static void retry_incomplete_types (void);
4235static void gen_type_die_for_member (tree, tree, dw_die_ref);
4236static void splice_child_die (dw_die_ref, dw_die_ref);
4237static int file_info_cmp (const void *, const void *);
4238static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
4239 const char *, const char *, unsigned);
4240static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref,
4241 const char *, const char *,
4242 const char *);
4243static void output_loc_list (dw_loc_list_ref);
4244static char *gen_internal_sym (const char *);
4245
4246static void prune_unmark_dies (dw_die_ref);
4247static void prune_unused_types_mark (dw_die_ref, int);
4248static void prune_unused_types_walk (dw_die_ref);
4249static void prune_unused_types_walk_attribs (dw_die_ref);
4250static void prune_unused_types_prune (dw_die_ref);
4251static void prune_unused_types (void);
4252static int maybe_emit_file (struct dwarf_file_data *fd);
4253
4254/* Section names used to hold DWARF debugging information. */
4255#ifndef DEBUG_INFO_SECTION
4256#define DEBUG_INFO_SECTION ".debug_info"
4257#endif
4258#ifndef DEBUG_ABBREV_SECTION
4259#define DEBUG_ABBREV_SECTION ".debug_abbrev"
4260#endif
4261#ifndef DEBUG_ARANGES_SECTION
4262#define DEBUG_ARANGES_SECTION ".debug_aranges"
4263#endif
4264#ifndef DEBUG_MACINFO_SECTION
4265#define DEBUG_MACINFO_SECTION ".debug_macinfo"
4266#endif
4267#ifndef DEBUG_LINE_SECTION
4268#define DEBUG_LINE_SECTION ".debug_line"
4269#endif
4270#ifndef DEBUG_LOC_SECTION
4271#define DEBUG_LOC_SECTION ".debug_loc"
4272#endif
4273#ifndef DEBUG_PUBNAMES_SECTION
4274#define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
4275#endif
4276#ifndef DEBUG_STR_SECTION
4277#define DEBUG_STR_SECTION ".debug_str"
4278#endif
4279#ifndef DEBUG_RANGES_SECTION
4280#define DEBUG_RANGES_SECTION ".debug_ranges"
4281#endif
4282
4283/* Standard ELF section names for compiled code and data. */
4284#ifndef TEXT_SECTION_NAME
4285#define TEXT_SECTION_NAME ".text"
4286#endif
4287
4288/* Section flags for .debug_str section. */
4289#define DEBUG_STR_SECTION_FLAGS \
4290 (HAVE_GAS_SHF_MERGE && flag_merge_constants \
4291 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
4292 : SECTION_DEBUG)
4293
4294/* Labels we insert at beginning sections we can reference instead of
4295 the section names themselves. */
4296
4297#ifndef TEXT_SECTION_LABEL
4298#define TEXT_SECTION_LABEL "Ltext"
4299#endif
4300#ifndef COLD_TEXT_SECTION_LABEL
4301#define COLD_TEXT_SECTION_LABEL "Ltext_cold"
4302#endif
4303#ifndef DEBUG_LINE_SECTION_LABEL
4304#define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
4305#endif
4306#ifndef DEBUG_INFO_SECTION_LABEL
4307#define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
4308#endif
4309#ifndef DEBUG_ABBREV_SECTION_LABEL
4310#define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
4311#endif
4312#ifndef DEBUG_LOC_SECTION_LABEL
4313#define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
4314#endif
4315#ifndef DEBUG_RANGES_SECTION_LABEL
4316#define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
4317#endif
4318#ifndef DEBUG_MACINFO_SECTION_LABEL
4319#define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
4320#endif
4321
4322/* Definitions of defaults for formats and names of various special
4323 (artificial) labels which may be generated within this file (when the -g
4324 options is used and DWARF2_DEBUGGING_INFO is in effect.
4325 If necessary, these may be overridden from within the tm.h file, but
4326 typically, overriding these defaults is unnecessary. */
4327
4328static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4329static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4330static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4331static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4332static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4333static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4334static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4335static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4336static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4337static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
4338
4339#ifndef TEXT_END_LABEL
4340#define TEXT_END_LABEL "Letext"
4341#endif
4342#ifndef COLD_END_LABEL
4343#define COLD_END_LABEL "Letext_cold"
4344#endif
4345#ifndef BLOCK_BEGIN_LABEL
4346#define BLOCK_BEGIN_LABEL "LBB"
4347#endif
4348#ifndef BLOCK_END_LABEL
4349#define BLOCK_END_LABEL "LBE"
4350#endif
4351#ifndef LINE_CODE_LABEL
4352#define LINE_CODE_LABEL "LM"
4353#endif
4354#ifndef SEPARATE_LINE_CODE_LABEL
4355#define SEPARATE_LINE_CODE_LABEL "LSM"
4356#endif
4357
4358/* We allow a language front-end to designate a function that is to be
4359 called to "demangle" any name before it is put into a DIE. */
4360
4361static const char *(*demangle_name_func) (const char *);
4362
4363void
4364dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
4365{
4366 demangle_name_func = func;
4367}
4368
4369/* Test if rtl node points to a pseudo register. */
4370
4371static inline int
4372is_pseudo_reg (rtx rtl)
4373{
4374 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
4375 || (GET_CODE (rtl) == SUBREG
4376 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
4377}
4378
4379/* Return a reference to a type, with its const and volatile qualifiers
4380 removed. */
4381
4382static inline tree
4383type_main_variant (tree type)
4384{
4385 type = TYPE_MAIN_VARIANT (type);
4386
4387 /* ??? There really should be only one main variant among any group of
4388 variants of a given type (and all of the MAIN_VARIANT values for all
4389 members of the group should point to that one type) but sometimes the C
4390 front-end messes this up for array types, so we work around that bug
4391 here. */
4392 if (TREE_CODE (type) == ARRAY_TYPE)
4393 while (type != TYPE_MAIN_VARIANT (type))
4394 type = TYPE_MAIN_VARIANT (type);
4395
4396 return type;
4397}
4398
4399/* Return nonzero if the given type node represents a tagged type. */
4400
4401static inline int
4402is_tagged_type (tree type)
4403{
4404 enum tree_code code = TREE_CODE (type);
4405
4406 return (code == RECORD_TYPE || code == UNION_TYPE
4407 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
4408}
4409
4410/* Convert a DIE tag into its string name. */
4411
4412static const char *
4413dwarf_tag_name (unsigned int tag)
4414{
4415 switch (tag)
4416 {
4417 case DW_TAG_padding:
4418 return "DW_TAG_padding";
4419 case DW_TAG_array_type:
4420 return "DW_TAG_array_type";
4421 case DW_TAG_class_type:
4422 return "DW_TAG_class_type";
4423 case DW_TAG_entry_point:
4424 return "DW_TAG_entry_point";
4425 case DW_TAG_enumeration_type:
4426 return "DW_TAG_enumeration_type";
4427 case DW_TAG_formal_parameter:
4428 return "DW_TAG_formal_parameter";
4429 case DW_TAG_imported_declaration:
4430 return "DW_TAG_imported_declaration";
4431 case DW_TAG_label:
4432 return "DW_TAG_label";
4433 case DW_TAG_lexical_block:
4434 return "DW_TAG_lexical_block";
4435 case DW_TAG_member:
4436 return "DW_TAG_member";
4437 case DW_TAG_pointer_type:
4438 return "DW_TAG_pointer_type";
4439 case DW_TAG_reference_type:
4440 return "DW_TAG_reference_type";
4441 case DW_TAG_compile_unit:
4442 return "DW_TAG_compile_unit";
4443 case DW_TAG_string_type:
4444 return "DW_TAG_string_type";
4445 case DW_TAG_structure_type:
4446 return "DW_TAG_structure_type";
4447 case DW_TAG_subroutine_type:
4448 return "DW_TAG_subroutine_type";
4449 case DW_TAG_typedef:
4450 return "DW_TAG_typedef";
4451 case DW_TAG_union_type:
4452 return "DW_TAG_union_type";
4453 case DW_TAG_unspecified_parameters:
4454 return "DW_TAG_unspecified_parameters";
4455 case DW_TAG_variant:
4456 return "DW_TAG_variant";
4457 case DW_TAG_common_block:
4458 return "DW_TAG_common_block";
4459 case DW_TAG_common_inclusion:
4460 return "DW_TAG_common_inclusion";
4461 case DW_TAG_inheritance:
4462 return "DW_TAG_inheritance";
4463 case DW_TAG_inlined_subroutine:
4464 return "DW_TAG_inlined_subroutine";
4465 case DW_TAG_module:
4466 return "DW_TAG_module";
4467 case DW_TAG_ptr_to_member_type:
4468 return "DW_TAG_ptr_to_member_type";
4469 case DW_TAG_set_type:
4470 return "DW_TAG_set_type";
4471 case DW_TAG_subrange_type:
4472 return "DW_TAG_subrange_type";
4473 case DW_TAG_with_stmt:
4474 return "DW_TAG_with_stmt";
4475 case DW_TAG_access_declaration:
4476 return "DW_TAG_access_declaration";
4477 case DW_TAG_base_type:
4478 return "DW_TAG_base_type";
4479 case DW_TAG_catch_block:
4480 return "DW_TAG_catch_block";
4481 case DW_TAG_const_type:
4482 return "DW_TAG_const_type";
4483 case DW_TAG_constant:
4484 return "DW_TAG_constant";
4485 case DW_TAG_enumerator:
4486 return "DW_TAG_enumerator";
4487 case DW_TAG_file_type:
4488 return "DW_TAG_file_type";
4489 case DW_TAG_friend:
4490 return "DW_TAG_friend";
4491 case DW_TAG_namelist:
4492 return "DW_TAG_namelist";
4493 case DW_TAG_namelist_item:
4494 return "DW_TAG_namelist_item";
4495 case DW_TAG_namespace:
4496 return "DW_TAG_namespace";
4497 case DW_TAG_packed_type:
4498 return "DW_TAG_packed_type";
4499 case DW_TAG_subprogram:
4500 return "DW_TAG_subprogram";
4501 case DW_TAG_template_type_param:
4502 return "DW_TAG_template_type_param";
4503 case DW_TAG_template_value_param:
4504 return "DW_TAG_template_value_param";
4505 case DW_TAG_thrown_type:
4506 return "DW_TAG_thrown_type";
4507 case DW_TAG_try_block:
4508 return "DW_TAG_try_block";
4509 case DW_TAG_variant_part:
4510 return "DW_TAG_variant_part";
4511 case DW_TAG_variable:
4512 return "DW_TAG_variable";
4513 case DW_TAG_volatile_type:
4514 return "DW_TAG_volatile_type";
4515 case DW_TAG_imported_module:
4516 return "DW_TAG_imported_module";
4517 case DW_TAG_MIPS_loop:
4518 return "DW_TAG_MIPS_loop";
4519 case DW_TAG_format_label:
4520 return "DW_TAG_format_label";
4521 case DW_TAG_function_template:
4522 return "DW_TAG_function_template";
4523 case DW_TAG_class_template:
4524 return "DW_TAG_class_template";
4525 case DW_TAG_GNU_BINCL:
4526 return "DW_TAG_GNU_BINCL";
4527 case DW_TAG_GNU_EINCL:
4528 return "DW_TAG_GNU_EINCL";
4529 default:
4530 return "DW_TAG_<unknown>";
4531 }
4532}
4533
4534/* Convert a DWARF attribute code into its string name. */
4535
4536static const char *
4537dwarf_attr_name (unsigned int attr)
4538{
4539 switch (attr)
4540 {
4541 case DW_AT_sibling:
4542 return "DW_AT_sibling";
4543 case DW_AT_location:
4544 return "DW_AT_location";
4545 case DW_AT_name:
4546 return "DW_AT_name";
4547 case DW_AT_ordering:
4548 return "DW_AT_ordering";
4549 case DW_AT_subscr_data:
4550 return "DW_AT_subscr_data";
4551 case DW_AT_byte_size:
4552 return "DW_AT_byte_size";
4553 case DW_AT_bit_offset:
4554 return "DW_AT_bit_offset";
4555 case DW_AT_bit_size:
4556 return "DW_AT_bit_size";
4557 case DW_AT_element_list:
4558 return "DW_AT_element_list";
4559 case DW_AT_stmt_list:
4560 return "DW_AT_stmt_list";
4561 case DW_AT_low_pc:
4562 return "DW_AT_low_pc";
4563 case DW_AT_high_pc:
4564 return "DW_AT_high_pc";
4565 case DW_AT_language:
4566 return "DW_AT_language";
4567 case DW_AT_member:
4568 return "DW_AT_member";
4569 case DW_AT_discr:
4570 return "DW_AT_discr";
4571 case DW_AT_discr_value:
4572 return "DW_AT_discr_value";
4573 case DW_AT_visibility:
4574 return "DW_AT_visibility";
4575 case DW_AT_import:
4576 return "DW_AT_import";
4577 case DW_AT_string_length:
4578 return "DW_AT_string_length";
4579 case DW_AT_common_reference:
4580 return "DW_AT_common_reference";
4581 case DW_AT_comp_dir:
4582 return "DW_AT_comp_dir";
4583 case DW_AT_const_value:
4584 return "DW_AT_const_value";
4585 case DW_AT_containing_type:
4586 return "DW_AT_containing_type";
4587 case DW_AT_default_value:
4588 return "DW_AT_default_value";
4589 case DW_AT_inline:
4590 return "DW_AT_inline";
4591 case DW_AT_is_optional:
4592 return "DW_AT_is_optional";
4593 case DW_AT_lower_bound:
4594 return "DW_AT_lower_bound";
4595 case DW_AT_producer:
4596 return "DW_AT_producer";
4597 case DW_AT_prototyped:
4598 return "DW_AT_prototyped";
4599 case DW_AT_return_addr:
4600 return "DW_AT_return_addr";
4601 case DW_AT_start_scope:
4602 return "DW_AT_start_scope";
4603 case DW_AT_stride_size:
4604 return "DW_AT_stride_size";
4605 case DW_AT_upper_bound:
4606 return "DW_AT_upper_bound";
4607 case DW_AT_abstract_origin:
4608 return "DW_AT_abstract_origin";
4609 case DW_AT_accessibility:
4610 return "DW_AT_accessibility";
4611 case DW_AT_address_class:
4612 return "DW_AT_address_class";
4613 case DW_AT_artificial:
4614 return "DW_AT_artificial";
4615 case DW_AT_base_types:
4616 return "DW_AT_base_types";
4617 case DW_AT_calling_convention:
4618 return "DW_AT_calling_convention";
4619 case DW_AT_count:
4620 return "DW_AT_count";
4621 case DW_AT_data_member_location:
4622 return "DW_AT_data_member_location";
4623 case DW_AT_decl_column:
4624 return "DW_AT_decl_column";
4625 case DW_AT_decl_file:
4626 return "DW_AT_decl_file";
4627 case DW_AT_decl_line:
4628 return "DW_AT_decl_line";
4629 case DW_AT_declaration:
4630 return "DW_AT_declaration";
4631 case DW_AT_discr_list:
4632 return "DW_AT_discr_list";
4633 case DW_AT_encoding:
4634 return "DW_AT_encoding";
4635 case DW_AT_external:
4636 return "DW_AT_external";
4637 case DW_AT_frame_base:
4638 return "DW_AT_frame_base";
4639 case DW_AT_friend:
4640 return "DW_AT_friend";
4641 case DW_AT_identifier_case:
4642 return "DW_AT_identifier_case";
4643 case DW_AT_macro_info:
4644 return "DW_AT_macro_info";
4645 case DW_AT_namelist_items:
4646 return "DW_AT_namelist_items";
4647 case DW_AT_priority:
4648 return "DW_AT_priority";
4649 case DW_AT_segment:
4650 return "DW_AT_segment";
4651 case DW_AT_specification:
4652 return "DW_AT_specification";
4653 case DW_AT_static_link:
4654 return "DW_AT_static_link";
4655 case DW_AT_type:
4656 return "DW_AT_type";
4657 case DW_AT_use_location:
4658 return "DW_AT_use_location";
4659 case DW_AT_variable_parameter:
4660 return "DW_AT_variable_parameter";
4661 case DW_AT_virtuality:
4662 return "DW_AT_virtuality";
4663 case DW_AT_vtable_elem_location:
4664 return "DW_AT_vtable_elem_location";
4665
4666 case DW_AT_allocated:
4667 return "DW_AT_allocated";
4668 case DW_AT_associated:
4669 return "DW_AT_associated";
4670 case DW_AT_data_location:
4671 return "DW_AT_data_location";
4672 case DW_AT_stride:
4673 return "DW_AT_stride";
4674 case DW_AT_entry_pc:
4675 return "DW_AT_entry_pc";
4676 case DW_AT_use_UTF8:
4677 return "DW_AT_use_UTF8";
4678 case DW_AT_extension:
4679 return "DW_AT_extension";
4680 case DW_AT_ranges:
4681 return "DW_AT_ranges";
4682 case DW_AT_trampoline:
4683 return "DW_AT_trampoline";
4684 case DW_AT_call_column:
4685 return "DW_AT_call_column";
4686 case DW_AT_call_file:
4687 return "DW_AT_call_file";
4688 case DW_AT_call_line:
4689 return "DW_AT_call_line";
4690
4691 case DW_AT_MIPS_fde:
4692 return "DW_AT_MIPS_fde";
4693 case DW_AT_MIPS_loop_begin:
4694 return "DW_AT_MIPS_loop_begin";
4695 case DW_AT_MIPS_tail_loop_begin:
4696 return "DW_AT_MIPS_tail_loop_begin";
4697 case DW_AT_MIPS_epilog_begin:
4698 return "DW_AT_MIPS_epilog_begin";
4699 case DW_AT_MIPS_loop_unroll_factor:
4700 return "DW_AT_MIPS_loop_unroll_factor";
4701 case DW_AT_MIPS_software_pipeline_depth:
4702 return "DW_AT_MIPS_software_pipeline_depth";
4703 case DW_AT_MIPS_linkage_name:
4704 return "DW_AT_MIPS_linkage_name";
4705 case DW_AT_MIPS_stride:
4706 return "DW_AT_MIPS_stride";
4707 case DW_AT_MIPS_abstract_name:
4708 return "DW_AT_MIPS_abstract_name";
4709 case DW_AT_MIPS_clone_origin:
4710 return "DW_AT_MIPS_clone_origin";
4711 case DW_AT_MIPS_has_inlines:
4712 return "DW_AT_MIPS_has_inlines";
4713
4714 case DW_AT_sf_names:
4715 return "DW_AT_sf_names";
4716 case DW_AT_src_info:
4717 return "DW_AT_src_info";
4718 case DW_AT_mac_info:
4719 return "DW_AT_mac_info";
4720 case DW_AT_src_coords:
4721 return "DW_AT_src_coords";
4722 case DW_AT_body_begin:
4723 return "DW_AT_body_begin";
4724 case DW_AT_body_end:
4725 return "DW_AT_body_end";
4726 case DW_AT_GNU_vector:
4727 return "DW_AT_GNU_vector";
4728
4729 case DW_AT_VMS_rtnbeg_pd_address:
4730 return "DW_AT_VMS_rtnbeg_pd_address";
4731
4732 default:
4733 return "DW_AT_<unknown>";
4734 }
4735}
4736
4737/* Convert a DWARF value form code into its string name. */
4738
4739static const char *
4740dwarf_form_name (unsigned int form)
4741{
4742 switch (form)
4743 {
4744 case DW_FORM_addr:
4745 return "DW_FORM_addr";
4746 case DW_FORM_block2:
4747 return "DW_FORM_block2";
4748 case DW_FORM_block4:
4749 return "DW_FORM_block4";
4750 case DW_FORM_data2:
4751 return "DW_FORM_data2";
4752 case DW_FORM_data4:
4753 return "DW_FORM_data4";
4754 case DW_FORM_data8:
4755 return "DW_FORM_data8";
4756 case DW_FORM_string:
4757 return "DW_FORM_string";
4758 case DW_FORM_block:
4759 return "DW_FORM_block";
4760 case DW_FORM_block1:
4761 return "DW_FORM_block1";
4762 case DW_FORM_data1:
4763 return "DW_FORM_data1";
4764 case DW_FORM_flag:
4765 return "DW_FORM_flag";
4766 case DW_FORM_sdata:
4767 return "DW_FORM_sdata";
4768 case DW_FORM_strp:
4769 return "DW_FORM_strp";
4770 case DW_FORM_udata:
4771 return "DW_FORM_udata";
4772 case DW_FORM_ref_addr:
4773 return "DW_FORM_ref_addr";
4774 case DW_FORM_ref1:
4775 return "DW_FORM_ref1";
4776 case DW_FORM_ref2:
4777 return "DW_FORM_ref2";
4778 case DW_FORM_ref4:
4779 return "DW_FORM_ref4";
4780 case DW_FORM_ref8:
4781 return "DW_FORM_ref8";
4782 case DW_FORM_ref_udata:
4783 return "DW_FORM_ref_udata";
4784 case DW_FORM_indirect:
4785 return "DW_FORM_indirect";
4786 default:
4787 return "DW_FORM_<unknown>";
4788 }
4789}
4790
4791/* Determine the "ultimate origin" of a decl. The decl may be an inlined
4792 instance of an inlined instance of a decl which is local to an inline
4793 function, so we have to trace all of the way back through the origin chain
4794 to find out what sort of node actually served as the original seed for the
4795 given block. */
4796
4797static tree
4798decl_ultimate_origin (tree decl)
4799{
4800 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
4801 return NULL_TREE;
4802
4803 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
4804 nodes in the function to point to themselves; ignore that if
4805 we're trying to output the abstract instance of this function. */
4806 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
4807 return NULL_TREE;
4808
4809 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4810 most distant ancestor, this should never happen. */
4811 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
4812
4813 return DECL_ABSTRACT_ORIGIN (decl);
4814}
4815
4816/* Determine the "ultimate origin" of a block. The block may be an inlined
4817 instance of an inlined instance of a block which is local to an inline
4818 function, so we have to trace all of the way back through the origin chain
4819 to find out what sort of node actually served as the original seed for the
4820 given block. */
4821
4822static tree
4823block_ultimate_origin (tree block)
4824{
4825 tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
4826
4827 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
4828 nodes in the function to point to themselves; ignore that if
4829 we're trying to output the abstract instance of this function. */
4830 if (BLOCK_ABSTRACT (block) && immediate_origin == block)
4831 return NULL_TREE;
4832
4833 if (immediate_origin == NULL_TREE)
4834 return NULL_TREE;
4835 else
4836 {
4837 tree ret_val;
4838 tree lookahead = immediate_origin;
4839
4840 do
4841 {
4842 ret_val = lookahead;
4843 lookahead = (TREE_CODE (ret_val) == BLOCK
4844 ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
4845 }
4846 while (lookahead != NULL && lookahead != ret_val);
4847
4848 /* The block's abstract origin chain may not be the *ultimate* origin of
4849 the block. It could lead to a DECL that has an abstract origin set.
4850 If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
4851 will give us if it has one). Note that DECL's abstract origins are
4852 supposed to be the most distant ancestor (or so decl_ultimate_origin
4853 claims), so we don't need to loop following the DECL origins. */
4854 if (DECL_P (ret_val))
4855 return DECL_ORIGIN (ret_val);
4856
4857 return ret_val;
4858 }
4859}
4860
4861/* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
4862 of a virtual function may refer to a base class, so we check the 'this'
4863 parameter. */
4864
4865static tree
4866decl_class_context (tree decl)
4867{
4868 tree context = NULL_TREE;
4869
4870 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
4871 context = DECL_CONTEXT (decl);
4872 else
4873 context = TYPE_MAIN_VARIANT
4874 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
4875
4876 if (context && !TYPE_P (context))
4877 context = NULL_TREE;
4878
4879 return context;
4880}
4881
4882/* Add an attribute/value pair to a DIE. */
4883
4884static inline void
4885add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
4886{
4887 /* Maybe this should be an assert? */
4888 if (die == NULL)
4889 return;
4890
4891 if (die->die_attr == NULL)
4892 die->die_attr = VEC_alloc (dw_attr_node, gc, 1);
4893 VEC_safe_push (dw_attr_node, gc, die->die_attr, attr);
4894}
4895
4896static inline enum dw_val_class
4897AT_class (dw_attr_ref a)
4898{
4899 return a->dw_attr_val.val_class;
4900}
4901
4902/* Add a flag value attribute to a DIE. */
4903
4904static inline void
4905add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
4906{
4907 dw_attr_node attr;
4908
4909 attr.dw_attr = attr_kind;
4910 attr.dw_attr_val.val_class = dw_val_class_flag;
4911 attr.dw_attr_val.v.val_flag = flag;
4912 add_dwarf_attr (die, &attr);
4913}
4914
4915static inline unsigned
4916AT_flag (dw_attr_ref a)
4917{
4918 gcc_assert (a && AT_class (a) == dw_val_class_flag);
4919 return a->dw_attr_val.v.val_flag;
4920}
4921
4922/* Add a signed integer attribute value to a DIE. */
4923
4924static inline void
4925add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
4926{
4927 dw_attr_node attr;
4928
4929 attr.dw_attr = attr_kind;
4930 attr.dw_attr_val.val_class = dw_val_class_const;
4931 attr.dw_attr_val.v.val_int = int_val;
4932 add_dwarf_attr (die, &attr);
4933}
4934
4935static inline HOST_WIDE_INT
4936AT_int (dw_attr_ref a)
4937{
4938 gcc_assert (a && AT_class (a) == dw_val_class_const);
4939 return a->dw_attr_val.v.val_int;
4940}
4941
4942/* Add an unsigned integer attribute value to a DIE. */
4943
4944static inline void
4945add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
4946 unsigned HOST_WIDE_INT unsigned_val)
4947{
4948 dw_attr_node attr;
4949
4950 attr.dw_attr = attr_kind;
4951 attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
4952 attr.dw_attr_val.v.val_unsigned = unsigned_val;
4953 add_dwarf_attr (die, &attr);
4954}
4955
4956static inline unsigned HOST_WIDE_INT
4957AT_unsigned (dw_attr_ref a)
4958{
4959 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
4960 return a->dw_attr_val.v.val_unsigned;
4961}
4962
4963/* Add an unsigned double integer attribute value to a DIE. */
4964
4965static inline void
4966add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind,
4967 long unsigned int val_hi, long unsigned int val_low)
4968{
4969 dw_attr_node attr;
4970
4971 attr.dw_attr = attr_kind;
4972 attr.dw_attr_val.val_class = dw_val_class_long_long;
4973 attr.dw_attr_val.v.val_long_long.hi = val_hi;
4974 attr.dw_attr_val.v.val_long_long.low = val_low;
4975 add_dwarf_attr (die, &attr);
4976}
4977
4978/* Add a floating point attribute value to a DIE and return it. */
4979
4980static inline void
4981add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
4982 unsigned int length, unsigned int elt_size, unsigned char *array)
4983{
4984 dw_attr_node attr;
4985
4986 attr.dw_attr = attr_kind;
4987 attr.dw_attr_val.val_class = dw_val_class_vec;
4988 attr.dw_attr_val.v.val_vec.length = length;
4989 attr.dw_attr_val.v.val_vec.elt_size = elt_size;
4990 attr.dw_attr_val.v.val_vec.array = array;
4991 add_dwarf_attr (die, &attr);
4992}
4993
4994/* Hash and equality functions for debug_str_hash. */
4995
4996static hashval_t
4997debug_str_do_hash (const void *x)
4998{
4999 return htab_hash_string (((const struct indirect_string_node *)x)->str);
5000}
5001
5002static int
5003debug_str_eq (const void *x1, const void *x2)
5004{
5005 return strcmp ((((const struct indirect_string_node *)x1)->str),
5006 (const char *)x2) == 0;
5007}
5008
5009/* Add a string attribute value to a DIE. */
5010
5011static inline void
5012add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
5013{
5014 dw_attr_node attr;
5015 struct indirect_string_node *node;
5016 void **slot;
5017
5018 if (! debug_str_hash)
5019 debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
5020 debug_str_eq, NULL);
5021
5022 slot = htab_find_slot_with_hash (debug_str_hash, str,
5023 htab_hash_string (str), INSERT);
5024 if (*slot == NULL)
5025 *slot = ggc_alloc_cleared (sizeof (struct indirect_string_node));
5026 node = (struct indirect_string_node *) *slot;
5027 node->str = ggc_strdup (str);
5028 node->refcount++;
5029
5030 attr.dw_attr = attr_kind;
5031 attr.dw_attr_val.val_class = dw_val_class_str;
5032 attr.dw_attr_val.v.val_str = node;
5033 add_dwarf_attr (die, &attr);
5034}
5035
5036static inline const char *
5037AT_string (dw_attr_ref a)
5038{
5039 gcc_assert (a && AT_class (a) == dw_val_class_str);
5040 return a->dw_attr_val.v.val_str->str;
5041}
5042
5043/* Find out whether a string should be output inline in DIE
5044 or out-of-line in .debug_str section. */
5045
5046static int
5047AT_string_form (dw_attr_ref a)
5048{
5049 struct indirect_string_node *node;
5050 unsigned int len;
5051 char label[32];
5052
5053 gcc_assert (a && AT_class (a) == dw_val_class_str);
5054
5055 node = a->dw_attr_val.v.val_str;
5056 if (node->form)
5057 return node->form;
5058
5059 len = strlen (node->str) + 1;
5060
5061 /* If the string is shorter or equal to the size of the reference, it is
5062 always better to put it inline. */
5063 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
5064 return node->form = DW_FORM_string;
5065
5066 /* If we cannot expect the linker to merge strings in .debug_str
5067 section, only put it into .debug_str if it is worth even in this
5068 single module. */
5069 if ((debug_str_section->common.flags & SECTION_MERGE) == 0
5070 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len)
5071 return node->form = DW_FORM_string;
5072
5073 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
5074 ++dw2_string_counter;
5075 node->label = xstrdup (label);
5076
5077 return node->form = DW_FORM_strp;
5078}
5079
5080/* Add a DIE reference attribute value to a DIE. */
5081
5082static inline void
5083add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
5084{
5085 dw_attr_node attr;
5086
5087 attr.dw_attr = attr_kind;
5088 attr.dw_attr_val.val_class = dw_val_class_die_ref;
5089 attr.dw_attr_val.v.val_die_ref.die = targ_die;
5090 attr.dw_attr_val.v.val_die_ref.external = 0;
5091 add_dwarf_attr (die, &attr);
5092}
5093
5094/* Add an AT_specification attribute to a DIE, and also make the back
5095 pointer from the specification to the definition. */
5096
5097static inline void
5098add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
5099{
5100 add_AT_die_ref (die, DW_AT_specification, targ_die);
5101 gcc_assert (!targ_die->die_definition);
5102 targ_die->die_definition = die;
5103}
5104
5105static inline dw_die_ref
5106AT_ref (dw_attr_ref a)
5107{
5108 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
5109 return a->dw_attr_val.v.val_die_ref.die;
5110}
5111
5112static inline int
5113AT_ref_external (dw_attr_ref a)
5114{
5115 if (a && AT_class (a) == dw_val_class_die_ref)
5116 return a->dw_attr_val.v.val_die_ref.external;
5117
5118 return 0;
5119}
5120
5121static inline void
5122set_AT_ref_external (dw_attr_ref a, int i)
5123{
5124 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
5125 a->dw_attr_val.v.val_die_ref.external = i;
5126}
5127
5128/* Add an FDE reference attribute value to a DIE. */
5129
5130static inline void
5131add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
5132{
5133 dw_attr_node attr;
5134
5135 attr.dw_attr = attr_kind;
5136 attr.dw_attr_val.val_class = dw_val_class_fde_ref;
5137 attr.dw_attr_val.v.val_fde_index = targ_fde;
5138 add_dwarf_attr (die, &attr);
5139}
5140
5141/* Add a location description attribute value to a DIE. */
5142
5143static inline void
5144add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
5145{
5146 dw_attr_node attr;
5147
5148 attr.dw_attr = attr_kind;
5149 attr.dw_attr_val.val_class = dw_val_class_loc;
5150 attr.dw_attr_val.v.val_loc = loc;
5151 add_dwarf_attr (die, &attr);
5152}
5153
5154static inline dw_loc_descr_ref
5155AT_loc (dw_attr_ref a)
5156{
5157 gcc_assert (a && AT_class (a) == dw_val_class_loc);
5158 return a->dw_attr_val.v.val_loc;
5159}
5160
5161static inline void
5162add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
5163{
5164 dw_attr_node attr;
5165
5166 attr.dw_attr = attr_kind;
5167 attr.dw_attr_val.val_class = dw_val_class_loc_list;
5168 attr.dw_attr_val.v.val_loc_list = loc_list;
5169 add_dwarf_attr (die, &attr);
5170 have_location_lists = true;
5171}
5172
5173static inline dw_loc_list_ref
5174AT_loc_list (dw_attr_ref a)
5175{
5176 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
5177 return a->dw_attr_val.v.val_loc_list;
5178}
5179
5180/* Add an address constant attribute value to a DIE. */
5181
5182static inline void
5183add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
5184{
5185 dw_attr_node attr;
5186
5187 attr.dw_attr = attr_kind;
5188 attr.dw_attr_val.val_class = dw_val_class_addr;
5189 attr.dw_attr_val.v.val_addr = addr;
5190 add_dwarf_attr (die, &attr);
5191}
5192
5193/* Get the RTX from to an address DIE attribute. */
5194
5195static inline rtx
5196AT_addr (dw_attr_ref a)
5197{
5198 gcc_assert (a && AT_class (a) == dw_val_class_addr);
5199 return a->dw_attr_val.v.val_addr;
5200}
5201
5202/* Add a file attribute value to a DIE. */
5203
5204static inline void
5205add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
5206 struct dwarf_file_data *fd)
5207{
5208 dw_attr_node attr;
5209
5210 attr.dw_attr = attr_kind;
5211 attr.dw_attr_val.val_class = dw_val_class_file;
5212 attr.dw_attr_val.v.val_file = fd;
5213 add_dwarf_attr (die, &attr);
5214}
5215
5216/* Get the dwarf_file_data from a file DIE attribute. */
5217
5218static inline struct dwarf_file_data *
5219AT_file (dw_attr_ref a)
5220{
5221 gcc_assert (a && AT_class (a) == dw_val_class_file);
5222 return a->dw_attr_val.v.val_file;
5223}
5224
5225/* Add a label identifier attribute value to a DIE. */
5226
5227static inline void
5228add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
5229{
5230 dw_attr_node attr;
5231
5232 attr.dw_attr = attr_kind;
5233 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
5234 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
5235 add_dwarf_attr (die, &attr);
5236}
5237
5238/* Add a section offset attribute value to a DIE, an offset into the
5239 debug_line section. */
5240
5241static inline void
5242add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
5243 const char *label)
5244{
5245 dw_attr_node attr;
5246
5247 attr.dw_attr = attr_kind;
5248 attr.dw_attr_val.val_class = dw_val_class_lineptr;
5249 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
5250 add_dwarf_attr (die, &attr);
5251}
5252
5253/* Add a section offset attribute value to a DIE, an offset into the
5254 debug_macinfo section. */
5255
5256static inline void
5257add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
5258 const char *label)
5259{
5260 dw_attr_node attr;
5261
5262 attr.dw_attr = attr_kind;
5263 attr.dw_attr_val.val_class = dw_val_class_macptr;
5264 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
5265 add_dwarf_attr (die, &attr);
5266}
5267
5268/* Add an offset attribute value to a DIE. */
5269
5270static inline void
5271add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
5272 unsigned HOST_WIDE_INT offset)
5273{
5274 dw_attr_node attr;
5275
5276 attr.dw_attr = attr_kind;
5277 attr.dw_attr_val.val_class = dw_val_class_offset;
5278 attr.dw_attr_val.v.val_offset = offset;
5279 add_dwarf_attr (die, &attr);
5280}
5281
5282/* Add an range_list attribute value to a DIE. */
5283
5284static void
5285add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
5286 long unsigned int offset)
5287{
5288 dw_attr_node attr;
5289
5290 attr.dw_attr = attr_kind;
5291 attr.dw_attr_val.val_class = dw_val_class_range_list;
5292 attr.dw_attr_val.v.val_offset = offset;
5293 add_dwarf_attr (die, &attr);
5294}
5295
5296static inline const char *
5297AT_lbl (dw_attr_ref a)
5298{
5299 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
5300 || AT_class (a) == dw_val_class_lineptr
5301 || AT_class (a) == dw_val_class_macptr));
5302 return a->dw_attr_val.v.val_lbl_id;
5303}
5304
5305/* Get the attribute of type attr_kind. */
5306
5307static dw_attr_ref
5308get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5309{
5310 dw_attr_ref a;
5311 unsigned ix;
5312 dw_die_ref spec = NULL;
5313
5314 if (! die)
5315 return NULL;
5316
5317 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
5318 if (a->dw_attr == attr_kind)
5319 return a;
5320 else if (a->dw_attr == DW_AT_specification
5321 || a->dw_attr == DW_AT_abstract_origin)
5322 spec = AT_ref (a);
5323
5324 if (spec)
5325 return get_AT (spec, attr_kind);
5326
5327 return NULL;
5328}
5329
5330/* Return the "low pc" attribute value, typically associated with a subprogram
5331 DIE. Return null if the "low pc" attribute is either not present, or if it
5332 cannot be represented as an assembler label identifier. */
5333
5334static inline const char *
5335get_AT_low_pc (dw_die_ref die)
5336{
5337 dw_attr_ref a = get_AT (die, DW_AT_low_pc);
5338
5339 return a ? AT_lbl (a) : NULL;
5340}
5341
5342/* Return the "high pc" attribute value, typically associated with a subprogram
5343 DIE. Return null if the "high pc" attribute is either not present, or if it
5344 cannot be represented as an assembler label identifier. */
5345
5346static inline const char *
5347get_AT_hi_pc (dw_die_ref die)
5348{
5349 dw_attr_ref a = get_AT (die, DW_AT_high_pc);
5350
5351 return a ? AT_lbl (a) : NULL;
5352}
5353
5354/* Return the value of the string attribute designated by ATTR_KIND, or
5355 NULL if it is not present. */
5356
5357static inline const char *
5358get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
5359{
5360 dw_attr_ref a = get_AT (die, attr_kind);
5361
5362 return a ? AT_string (a) : NULL;
5363}
5364
5365/* Return the value of the flag attribute designated by ATTR_KIND, or -1
5366 if it is not present. */
5367
5368static inline int
5369get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
5370{
5371 dw_attr_ref a = get_AT (die, attr_kind);
5372
5373 return a ? AT_flag (a) : 0;
5374}
5375
5376/* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5377 if it is not present. */
5378
5379static inline unsigned
5380get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
5381{
5382 dw_attr_ref a = get_AT (die, attr_kind);
5383
5384 return a ? AT_unsigned (a) : 0;
5385}
5386
5387static inline dw_die_ref
5388get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
5389{
5390 dw_attr_ref a = get_AT (die, attr_kind);
5391
5392 return a ? AT_ref (a) : NULL;
5393}
5394
5395static inline struct dwarf_file_data *
5396get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
5397{
5398 dw_attr_ref a = get_AT (die, attr_kind);
5399
5400 return a ? AT_file (a) : NULL;
5401}
5402
5403/* Return TRUE if the language is C or C++. */
5404
5405static inline bool
5406is_c_family (void)
5407{
5408 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5409
5410 return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_ObjC
5411 || lang == DW_LANG_C99
5412 || lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus);
5413}
5414
5415/* Return TRUE if the language is C++. */
5416
5417static inline bool
5418is_cxx (void)
5419{
5420 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5421
5422 return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
5423}
5424
5425/* Return TRUE if the language is Fortran. */
5426
5427static inline bool
5428is_fortran (void)
5429{
5430 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5431
5432 return (lang == DW_LANG_Fortran77
5433 || lang == DW_LANG_Fortran90
5434 || lang == DW_LANG_Fortran95);
5435}
5436
5437/* Return TRUE if the language is Java. */
5438
5439static inline bool
5440is_java (void)
5441{
5442 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5443
5444 return lang == DW_LANG_Java;
5445}
5446
5447/* Return TRUE if the language is Ada. */
5448
5449static inline bool
5450is_ada (void)
5451{
5452 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5453
5454 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
5455}
5456
5457/* Remove the specified attribute if present. */
5458
5459static void
5460remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5461{
5462 dw_attr_ref a;
5463 unsigned ix;
5464
5465 if (! die)
5466 return;
5467
5468 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
5469 if (a->dw_attr == attr_kind)
5470 {
5471 if (AT_class (a) == dw_val_class_str)
5472 if (a->dw_attr_val.v.val_str->refcount)
5473 a->dw_attr_val.v.val_str->refcount--;
5474
5475 /* VEC_ordered_remove should help reduce the number of abbrevs
5476 that are needed. */
5477 VEC_ordered_remove (dw_attr_node, die->die_attr, ix);
5478 return;
5479 }
5480}
5481
5482/* Remove CHILD from its parent. PREV must have the property that
5483 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
5484
5485static void
5486remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
5487{
5488 gcc_assert (child->die_parent == prev->die_parent);
5489 gcc_assert (prev->die_sib == child);
5490 if (prev == child)
5491 {
5492 gcc_assert (child->die_parent->die_child == child);
5493 prev = NULL;
5494 }
5495 else
5496 prev->die_sib = child->die_sib;
5497 if (child->die_parent->die_child == child)
5498 child->die_parent->die_child = prev;
5499}
5500
5501/* Remove child DIE whose die_tag is TAG. Do nothing if no child
5502 matches TAG. */
5503
5504static void
5505remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
5506{
5507 dw_die_ref c;
5508
5509 c = die->die_child;
5510 if (c) do {
5511 dw_die_ref prev = c;
5512 c = c->die_sib;
5513 while (c->die_tag == tag)
5514 {
5515 remove_child_with_prev (c, prev);
5516 /* Might have removed every child. */
5517 if (c == c->die_sib)
5518 return;
5519 c = c->die_sib;
5520 }
5521 } while (c != die->die_child);
5522}
5523
5524/* Add a CHILD_DIE as the last child of DIE. */
5525
5526static void
5527add_child_die (dw_die_ref die, dw_die_ref child_die)
5528{
5529 /* FIXME this should probably be an assert. */
5530 if (! die || ! child_die)
5531 return;
5532 gcc_assert (die != child_die);
5533
5534 child_die->die_parent = die;
5535 if (die->die_child)
5536 {
5537 child_die->die_sib = die->die_child->die_sib;
5538 die->die_child->die_sib = child_die;
5539 }
5540 else
5541 child_die->die_sib = child_die;
5542 die->die_child = child_die;
5543}
5544
5545/* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5546 is the specification, to the end of PARENT's list of children.
5547 This is done by removing and re-adding it. */
5548
5549static void
5550splice_child_die (dw_die_ref parent, dw_die_ref child)
5551{
5552 dw_die_ref p;
5553
5554 /* We want the declaration DIE from inside the class, not the
5555 specification DIE at toplevel. */
5556 if (child->die_parent != parent)
5557 {
5558 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
5559
5560 if (tmp)
5561 child = tmp;
5562 }
5563
5564 gcc_assert (child->die_parent == parent
5565 || (child->die_parent
5566 == get_AT_ref (parent, DW_AT_specification)));
5567
5568 for (p = child->die_parent->die_child; ; p = p->die_sib)
5569 if (p->die_sib == child)
5570 {
5571 remove_child_with_prev (child, p);
5572 break;
5573 }
5574
5575 add_child_die (parent, child);
5576}
5577
5578/* Return a pointer to a newly created DIE node. */
5579
5580static inline dw_die_ref
5581new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
5582{
5583 dw_die_ref die = ggc_alloc_cleared (sizeof (die_node));
5584
5585 die->die_tag = tag_value;
5586
5587 if (parent_die != NULL)
5588 add_child_die (parent_die, die);
5589 else
5590 {
5591 limbo_die_node *limbo_node;
5592
5593 limbo_node = ggc_alloc_cleared (sizeof (limbo_die_node));
5594 limbo_node->die = die;
5595 limbo_node->created_for = t;
5596 limbo_node->next = limbo_die_list;
5597 limbo_die_list = limbo_node;
5598 }
5599
5600 return die;
5601}
5602
5603/* Return the DIE associated with the given type specifier. */
5604
5605static inline dw_die_ref
5606lookup_type_die (tree type)
5607{
5608 return TYPE_SYMTAB_DIE (type);
5609}
5610
5611/* Equate a DIE to a given type specifier. */
5612
5613static inline void
5614equate_type_number_to_die (tree type, dw_die_ref type_die)
5615{
5616 TYPE_SYMTAB_DIE (type) = type_die;
5617}
5618
5619/* Returns a hash value for X (which really is a die_struct). */
5620
5621static hashval_t
5622decl_die_table_hash (const void *x)
5623{
5624 return (hashval_t) ((const dw_die_ref) x)->decl_id;
5625}
5626
5627/* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
5628
5629static int
5630decl_die_table_eq (const void *x, const void *y)
5631{
5632 return (((const dw_die_ref) x)->decl_id == DECL_UID ((const tree) y));
5633}
5634
5635/* Return the DIE associated with a given declaration. */
5636
5637static inline dw_die_ref
5638lookup_decl_die (tree decl)
5639{
5640 return htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
5641}
5642
5643/* Returns a hash value for X (which really is a var_loc_list). */
5644
5645static hashval_t
5646decl_loc_table_hash (const void *x)
5647{
5648 return (hashval_t) ((const var_loc_list *) x)->decl_id;
5649}
5650
5651/* Return nonzero if decl_id of var_loc_list X is the same as
5652 UID of decl *Y. */
5653
5654static int
5655decl_loc_table_eq (const void *x, const void *y)
5656{
5657 return (((const var_loc_list *) x)->decl_id == DECL_UID ((const tree) y));
5658}
5659
5660/* Return the var_loc list associated with a given declaration. */
5661
5662static inline var_loc_list *
5663lookup_decl_loc (tree decl)
5664{
5665 return htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
5666}
5667
5668/* Equate a DIE to a particular declaration. */
5669
5670static void
5671equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
5672{
5673 unsigned int decl_id = DECL_UID (decl);
5674 void **slot;
5675
5676 slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
5677 *slot = decl_die;
5678 decl_die->decl_id = decl_id;
5679}
5680
5681/* Add a variable location node to the linked list for DECL. */
5682
5683static void
5684add_var_loc_to_decl (tree decl, struct var_loc_node *loc)
5685{
5686 unsigned int decl_id = DECL_UID (decl);
5687 var_loc_list *temp;
5688 void **slot;
5689
5690 slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
5691 if (*slot == NULL)
5692 {
5693 temp = ggc_alloc_cleared (sizeof (var_loc_list));
5694 temp->decl_id = decl_id;
5695 *slot = temp;
5696 }
5697 else
5698 temp = *slot;
5699
5700 if (temp->last)
5701 {
5702 /* If the current location is the same as the end of the list,
5703 we have nothing to do. */
5704 if (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note),
5705 NOTE_VAR_LOCATION_LOC (loc->var_loc_note)))
5706 {
5707 /* Add LOC to the end of list and update LAST. */
5708 temp->last->next = loc;
5709 temp->last = loc;
5710 }
5711 }
5712 /* Do not add empty location to the beginning of the list. */
5713 else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX)
5714 {
5715 temp->first = loc;
5716 temp->last = loc;
5717 }
5718}
5719
5720/* Keep track of the number of spaces used to indent the
5721 output of the debugging routines that print the structure of
5722 the DIE internal representation. */
5723static int print_indent;
5724
5725/* Indent the line the number of spaces given by print_indent. */
5726
5727static inline void
5728print_spaces (FILE *outfile)
5729{
5730 fprintf (outfile, "%*s", print_indent, "");
5731}
5732
5733/* Print the information associated with a given DIE, and its children.
5734 This routine is a debugging aid only. */
5735
5736static void
5737print_die (dw_die_ref die, FILE *outfile)
5738{
5739 dw_attr_ref a;
5740 dw_die_ref c;
5741 unsigned ix;
5742
5743 print_spaces (outfile);
5744 fprintf (outfile, "DIE %4lu: %s\n",
5745 die->die_offset, dwarf_tag_name (die->die_tag));
5746 print_spaces (outfile);
5747 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
5748 fprintf (outfile, " offset: %lu\n", die->die_offset);
5749
5750 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
5751 {
5752 print_spaces (outfile);
5753 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
5754
5755 switch (AT_class (a))
5756 {
5757 case dw_val_class_addr:
5758 fprintf (outfile, "address");
5759 break;
5760 case dw_val_class_offset:
5761 fprintf (outfile, "offset");
5762 break;
5763 case dw_val_class_loc:
5764 fprintf (outfile, "location descriptor");
5765 break;
5766 case dw_val_class_loc_list:
5767 fprintf (outfile, "location list -> label:%s",
5768 AT_loc_list (a)->ll_symbol);
5769 break;
5770 case dw_val_class_range_list:
5771 fprintf (outfile, "range list");
5772 break;
5773 case dw_val_class_const:
5774 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
5775 break;
5776 case dw_val_class_unsigned_const:
5777 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
5778 break;
5779 case dw_val_class_long_long:
5780 fprintf (outfile, "constant (%lu,%lu)",
5781 a->dw_attr_val.v.val_long_long.hi,
5782 a->dw_attr_val.v.val_long_long.low);
5783 break;
5784 case dw_val_class_vec:
5785 fprintf (outfile, "floating-point or vector constant");
5786 break;
5787 case dw_val_class_flag:
5788 fprintf (outfile, "%u", AT_flag (a));
5789 break;
5790 case dw_val_class_die_ref:
5791 if (AT_ref (a) != NULL)
5792 {
5793 if (AT_ref (a)->die_symbol)
5794 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
5795 else
5796 fprintf (outfile, "die -> %lu", AT_ref (a)->die_offset);
5797 }
5798 else
5799 fprintf (outfile, "die -> <null>");
5800 break;
5801 case dw_val_class_lbl_id:
5802 case dw_val_class_lineptr:
5803 case dw_val_class_macptr:
5804 fprintf (outfile, "label: %s", AT_lbl (a));
5805 break;
5806 case dw_val_class_str:
5807 if (AT_string (a) != NULL)
5808 fprintf (outfile, "\"%s\"", AT_string (a));
5809 else
5810 fprintf (outfile, "<null>");
5811 break;
5812 case dw_val_class_file:
5813 fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename,
5814 AT_file (a)->emitted_number);
5815 break;
5816 default:
5817 break;
5818 }
5819
5820 fprintf (outfile, "\n");
5821 }
5822
5823 if (die->die_child != NULL)
5824 {
5825 print_indent += 4;
5826 FOR_EACH_CHILD (die, c, print_die (c, outfile));
5827 print_indent -= 4;
5828 }
5829 if (print_indent == 0)
5830 fprintf (outfile, "\n");
5831}
5832
5833/* Print the contents of the source code line number correspondence table.
5834 This routine is a debugging aid only. */
5835
5836static void
5837print_dwarf_line_table (FILE *outfile)
5838{
5839 unsigned i;
5840 dw_line_info_ref line_info;
5841
5842 fprintf (outfile, "\n\nDWARF source line information\n");
5843 for (i = 1; i < line_info_table_in_use; i++)
5844 {
5845 line_info = &line_info_table[i];
5846 fprintf (outfile, "%5d: %4ld %6ld\n", i,
5847 line_info->dw_file_num,
5848 line_info->dw_line_num);
5849 }
5850
5851 fprintf (outfile, "\n\n");
5852}
5853
5854/* Print the information collected for a given DIE. */
5855
5856void
5857debug_dwarf_die (dw_die_ref die)
5858{
5859 print_die (die, stderr);
5860}
5861
5862/* Print all DWARF information collected for the compilation unit.
5863 This routine is a debugging aid only. */
5864
5865void
5866debug_dwarf (void)
5867{
5868 print_indent = 0;
5869 print_die (comp_unit_die, stderr);
5870 if (! DWARF2_ASM_LINE_DEBUG_INFO)
5871 print_dwarf_line_table (stderr);
5872}
5873
5874/* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
5875 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
5876 DIE that marks the start of the DIEs for this include file. */
5877
5878static dw_die_ref
5879push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
5880{
5881 const char *filename = get_AT_string (bincl_die, DW_AT_name);
5882 dw_die_ref new_unit = gen_compile_unit_die (filename);
5883
5884 new_unit->die_sib = old_unit;
5885 return new_unit;
5886}
5887
5888/* Close an include-file CU and reopen the enclosing one. */
5889
5890static dw_die_ref
5891pop_compile_unit (dw_die_ref old_unit)
5892{
5893 dw_die_ref new_unit = old_unit->die_sib;
5894
5895 old_unit->die_sib = NULL;
5896 return new_unit;
5897}
5898
5899#define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5900#define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5901
5902/* Calculate the checksum of a location expression. */
5903
5904static inline void
5905loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
5906{
5907 CHECKSUM (loc->dw_loc_opc);
5908 CHECKSUM (loc->dw_loc_oprnd1);
5909 CHECKSUM (loc->dw_loc_oprnd2);
5910}
5911
5912/* Calculate the checksum of an attribute. */
5913
5914static void
5915attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
5916{
5917 dw_loc_descr_ref loc;
5918 rtx r;
5919
5920 CHECKSUM (at->dw_attr);
5921
5922 /* We don't care that this was compiled with a different compiler
5923 snapshot; if the output is the same, that's what matters. */
5924 if (at->dw_attr == DW_AT_producer)
5925 return;
5926
5927 switch (AT_class (at))
5928 {
5929 case dw_val_class_const:
5930 CHECKSUM (at->dw_attr_val.v.val_int);
5931 break;
5932 case dw_val_class_unsigned_const:
5933 CHECKSUM (at->dw_attr_val.v.val_unsigned);
5934 break;
5935 case dw_val_class_long_long:
5936 CHECKSUM (at->dw_attr_val.v.val_long_long);
5937 break;
5938 case dw_val_class_vec:
5939 CHECKSUM (at->dw_attr_val.v.val_vec);
5940 break;
5941 case dw_val_class_flag:
5942 CHECKSUM (at->dw_attr_val.v.val_flag);
5943 break;
5944 case dw_val_class_str:
5945 CHECKSUM_STRING (AT_string (at));
5946 break;
5947
5948 case dw_val_class_addr:
5949 r = AT_addr (at);
5950 gcc_assert (GET_CODE (r) == SYMBOL_REF);
5951 CHECKSUM_STRING (XSTR (r, 0));
5952 break;
5953
5954 case dw_val_class_offset:
5955 CHECKSUM (at->dw_attr_val.v.val_offset);
5956 break;
5957
5958 case dw_val_class_loc:
5959 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
5960 loc_checksum (loc, ctx);
5961 break;
5962
5963 case dw_val_class_die_ref:
5964 die_checksum (AT_ref (at), ctx, mark);
5965 break;
5966
5967 case dw_val_class_fde_ref:
5968 case dw_val_class_lbl_id:
5969 case dw_val_class_lineptr:
5970 case dw_val_class_macptr:
5971 break;
5972
5973 case dw_val_class_file:
5974 CHECKSUM_STRING (AT_file (at)->filename);
5975 break;
5976
5977 default:
5978 break;
5979 }
5980}
5981
5982/* Calculate the checksum of a DIE. */
5983
5984static void
5985die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
5986{
5987 dw_die_ref c;
5988 dw_attr_ref a;
5989 unsigned ix;
5990
5991 /* To avoid infinite recursion. */
5992 if (die->die_mark)
5993 {
5994 CHECKSUM (die->die_mark);
5995 return;
5996 }
5997 die->die_mark = ++(*mark);
5998
5999 CHECKSUM (die->die_tag);
6000
6001 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6002 attr_checksum (a, ctx, mark);
6003
6004 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
6005}
6006
6007#undef CHECKSUM
6008#undef CHECKSUM_STRING
6009
6010/* Do the location expressions look same? */
6011static inline int
6012same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
6013{
6014 return loc1->dw_loc_opc == loc2->dw_loc_opc
6015 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
6016 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
6017}
6018
6019/* Do the values look the same? */
6020static int
6021same_dw_val_p (dw_val_node *v1, dw_val_node *v2, int *mark)
6022{
6023 dw_loc_descr_ref loc1, loc2;
6024 rtx r1, r2;
6025
6026 if (v1->val_class != v2->val_class)
6027 return 0;
6028
6029 switch (v1->val_class)
6030 {
6031 case dw_val_class_const:
6032 return v1->v.val_int == v2->v.val_int;
6033 case dw_val_class_unsigned_const:
6034 return v1->v.val_unsigned == v2->v.val_unsigned;
6035 case dw_val_class_long_long:
6036 return v1->v.val_long_long.hi == v2->v.val_long_long.hi
6037 && v1->v.val_long_long.low == v2->v.val_long_long.low;
6038 case dw_val_class_vec:
6039 if (v1->v.val_vec.length != v2->v.val_vec.length
6040 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
6041 return 0;
6042 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
6043 v1->v.val_vec.length * v1->v.val_vec.elt_size))
6044 return 0;
6045 return 1;
6046 case dw_val_class_flag:
6047 return v1->v.val_flag == v2->v.val_flag;
6048 case dw_val_class_str:
6049 return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
6050
6051 case dw_val_class_addr:
6052 r1 = v1->v.val_addr;
6053 r2 = v2->v.val_addr;
6054 if (GET_CODE (r1) != GET_CODE (r2))
6055 return 0;
6056 gcc_assert (GET_CODE (r1) == SYMBOL_REF);
6057 return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
6058
6059 case dw_val_class_offset:
6060 return v1->v.val_offset == v2->v.val_offset;
6061
6062 case dw_val_class_loc:
6063 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
6064 loc1 && loc2;
6065 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
6066 if (!same_loc_p (loc1, loc2, mark))
6067 return 0;
6068 return !loc1 && !loc2;
6069
6070 case dw_val_class_die_ref:
6071 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
6072
6073 case dw_val_class_fde_ref:
6074 case dw_val_class_lbl_id:
6075 case dw_val_class_lineptr:
6076 case dw_val_class_macptr:
6077 return 1;
6078
6079 case dw_val_class_file:
6080 return v1->v.val_file == v2->v.val_file;
6081
6082 default:
6083 return 1;
6084 }
6085}
6086
6087/* Do the attributes look the same? */
6088
6089static int
6090same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
6091{
6092 if (at1->dw_attr != at2->dw_attr)
6093 return 0;
6094
6095 /* We don't care that this was compiled with a different compiler
6096 snapshot; if the output is the same, that's what matters. */
6097 if (at1->dw_attr == DW_AT_producer)
6098 return 1;
6099
6100 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
6101}
6102
6103/* Do the dies look the same? */
6104
6105static int
6106same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
6107{
6108 dw_die_ref c1, c2;
6109 dw_attr_ref a1;
6110 unsigned ix;
6111
6112 /* To avoid infinite recursion. */
6113 if (die1->die_mark)
6114 return die1->die_mark == die2->die_mark;
6115 die1->die_mark = die2->die_mark = ++(*mark);
6116
6117 if (die1->die_tag != die2->die_tag)
6118 return 0;
6119
6120 if (VEC_length (dw_attr_node, die1->die_attr)
6121 != VEC_length (dw_attr_node, die2->die_attr))
6122 return 0;
6123
6124 for (ix = 0; VEC_iterate (dw_attr_node, die1->die_attr, ix, a1); ix++)
6125 if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark))
6126 return 0;
6127
6128 c1 = die1->die_child;
6129 c2 = die2->die_child;
6130 if (! c1)
6131 {
6132 if (c2)
6133 return 0;
6134 }
6135 else
6136 for (;;)
6137 {
6138 if (!same_die_p (c1, c2, mark))
6139 return 0;
6140 c1 = c1->die_sib;
6141 c2 = c2->die_sib;
6142 if (c1 == die1->die_child)
6143 {
6144 if (c2 == die2->die_child)
6145 break;
6146 else
6147 return 0;
6148 }
6149 }
6150
6151 return 1;
6152}
6153
6154/* Do the dies look the same? Wrapper around same_die_p. */
6155
6156static int
6157same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
6158{
6159 int mark = 0;
6160 int ret = same_die_p (die1, die2, &mark);
6161
6162 unmark_all_dies (die1);
6163 unmark_all_dies (die2);
6164
6165 return ret;
6166}
6167
6168/* The prefix to attach to symbols on DIEs in the current comdat debug
6169 info section. */
6170static char *comdat_symbol_id;
6171
6172/* The index of the current symbol within the current comdat CU. */
6173static unsigned int comdat_symbol_number;
6174
6175/* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
6176 children, and set comdat_symbol_id accordingly. */
6177
6178static void
6179compute_section_prefix (dw_die_ref unit_die)
6180{
6181 const char *die_name = get_AT_string (unit_die, DW_AT_name);
6182 const char *base = die_name ? lbasename (die_name) : "anonymous";
6183 char *name = alloca (strlen (base) + 64);
6184 char *p;
6185 int i, mark;
6186 unsigned char checksum[16];
6187 struct md5_ctx ctx;
6188
6189 /* Compute the checksum of the DIE, then append part of it as hex digits to
6190 the name filename of the unit. */
6191
6192 md5_init_ctx (&ctx);
6193 mark = 0;
6194 die_checksum (unit_die, &ctx, &mark);
6195 unmark_all_dies (unit_die);
6196 md5_finish_ctx (&ctx, checksum);
6197
6198 sprintf (name, "%s.", base);
6199 clean_symbol_name (name);
6200
6201 p = name + strlen (name);
6202 for (i = 0; i < 4; i++)
6203 {
6204 sprintf (p, "%.2x", checksum[i]);
6205 p += 2;
6206 }
6207
6208 comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
6209 comdat_symbol_number = 0;
6210}
6211
6212/* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
6213
6214static int
6215is_type_die (dw_die_ref die)
6216{
6217 switch (die->die_tag)
6218 {
6219 case DW_TAG_array_type:
6220 case DW_TAG_class_type:
6221 case DW_TAG_enumeration_type:
6222 case DW_TAG_pointer_type:
6223 case DW_TAG_reference_type:
6224 case DW_TAG_string_type:
6225 case DW_TAG_structure_type:
6226 case DW_TAG_subroutine_type:
6227 case DW_TAG_union_type:
6228 case DW_TAG_ptr_to_member_type:
6229 case DW_TAG_set_type:
6230 case DW_TAG_subrange_type:
6231 case DW_TAG_base_type:
6232 case DW_TAG_const_type:
6233 case DW_TAG_file_type:
6234 case DW_TAG_packed_type:
6235 case DW_TAG_volatile_type:
6236 case DW_TAG_typedef:
6237 return 1;
6238 default:
6239 return 0;
6240 }
6241}
6242
6243/* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
6244 Basically, we want to choose the bits that are likely to be shared between
6245 compilations (types) and leave out the bits that are specific to individual
6246 compilations (functions). */
6247
6248static int
6249is_comdat_die (dw_die_ref c)
6250{
6251 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
6252 we do for stabs. The advantage is a greater likelihood of sharing between
6253 objects that don't include headers in the same order (and therefore would
6254 put the base types in a different comdat). jason 8/28/00 */
6255
6256 if (c->die_tag == DW_TAG_base_type)
6257 return 0;
6258
6259 if (c->die_tag == DW_TAG_pointer_type
6260 || c->die_tag == DW_TAG_reference_type
6261 || c->die_tag == DW_TAG_const_type
6262 || c->die_tag == DW_TAG_volatile_type)
6263 {
6264 dw_die_ref t = get_AT_ref (c, DW_AT_type);
6265
6266 return t ? is_comdat_die (t) : 0;
6267 }
6268
6269 return is_type_die (c);
6270}
6271
6272/* Returns 1 iff C is the sort of DIE that might be referred to from another
6273 compilation unit. */
6274
6275static int
6276is_symbol_die (dw_die_ref c)
6277{
6278 return (is_type_die (c)
6279 || (get_AT (c, DW_AT_declaration)
6280 && !get_AT (c, DW_AT_specification))
6281 || c->die_tag == DW_TAG_namespace);
6282}
6283
6284static char *
6285gen_internal_sym (const char *prefix)
6286{
6287 char buf[256];
6288
6289 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
6290 return xstrdup (buf);
6291}
6292
6293/* Assign symbols to all worthy DIEs under DIE. */
6294
6295static void
6296assign_symbol_names (dw_die_ref die)
6297{
6298 dw_die_ref c;
6299
6300 if (is_symbol_die (die))
6301 {
6302 if (comdat_symbol_id)
6303 {
6304 char *p = alloca (strlen (comdat_symbol_id) + 64);
6305
6306 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
6307 comdat_symbol_id, comdat_symbol_number++);
6308 die->die_symbol = xstrdup (p);
6309 }
6310 else
6311 die->die_symbol = gen_internal_sym ("LDIE");
6312 }
6313
6314 FOR_EACH_CHILD (die, c, assign_symbol_names (c));
6315}
6316
6317struct cu_hash_table_entry
6318{
6319 dw_die_ref cu;
6320 unsigned min_comdat_num, max_comdat_num;
6321 struct cu_hash_table_entry *next;
6322};
6323
6324/* Routines to manipulate hash table of CUs. */
6325static hashval_t
6326htab_cu_hash (const void *of)
6327{
6328 const struct cu_hash_table_entry *entry = of;
6329
6330 return htab_hash_string (entry->cu->die_symbol);
6331}
6332
6333static int
6334htab_cu_eq (const void *of1, const void *of2)
6335{
6336 const struct cu_hash_table_entry *entry1 = of1;
6337 const struct die_struct *entry2 = of2;
6338
6339 return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
6340}
6341
6342static void
6343htab_cu_del (void *what)
6344{
6345 struct cu_hash_table_entry *next, *entry = what;
6346
6347 while (entry)
6348 {
6349 next = entry->next;
6350 free (entry);
6351 entry = next;
6352 }
6353}
6354
6355/* Check whether we have already seen this CU and set up SYM_NUM
6356 accordingly. */
6357static int
6358check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
6359{
6360 struct cu_hash_table_entry dummy;
6361 struct cu_hash_table_entry **slot, *entry, *last = &dummy;
6362
6363 dummy.max_comdat_num = 0;
6364
6365 slot = (struct cu_hash_table_entry **)
6366 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6367 INSERT);
6368 entry = *slot;
6369
6370 for (; entry; last = entry, entry = entry->next)
6371 {
6372 if (same_die_p_wrap (cu, entry->cu))
6373 break;
6374 }
6375
6376 if (entry)
6377 {
6378 *sym_num = entry->min_comdat_num;
6379 return 1;
6380 }
6381
6382 entry = XCNEW (struct cu_hash_table_entry);
6383 entry->cu = cu;
6384 entry->min_comdat_num = *sym_num = last->max_comdat_num;
6385 entry->next = *slot;
6386 *slot = entry;
6387
6388 return 0;
6389}
6390
6391/* Record SYM_NUM to record of CU in HTABLE. */
6392static void
6393record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
6394{
6395 struct cu_hash_table_entry **slot, *entry;
6396
6397 slot = (struct cu_hash_table_entry **)
6398 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6399 NO_INSERT);
6400 entry = *slot;
6401
6402 entry->max_comdat_num = sym_num;
6403}
6404
6405/* Traverse the DIE (which is always comp_unit_die), and set up
6406 additional compilation units for each of the include files we see
6407 bracketed by BINCL/EINCL. */
6408
6409static void
6410break_out_includes (dw_die_ref die)
6411{
6412 dw_die_ref c;
6413 dw_die_ref unit = NULL;
6414 limbo_die_node *node, **pnode;
6415 htab_t cu_hash_table;
6416
6417 c = die->die_child;
6418 if (c) do {
6419 dw_die_ref prev = c;
6420 c = c->die_sib;
6421 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
6422 || (unit && is_comdat_die (c)))
6423 {
6424 dw_die_ref next = c->die_sib;
6425
6426 /* This DIE is for a secondary CU; remove it from the main one. */
6427 remove_child_with_prev (c, prev);
6428
6429 if (c->die_tag == DW_TAG_GNU_BINCL)
6430 unit = push_new_compile_unit (unit, c);
6431 else if (c->die_tag == DW_TAG_GNU_EINCL)
6432 unit = pop_compile_unit (unit);
6433 else
6434 add_child_die (unit, c);
6435 c = next;
6436 if (c == die->die_child)
6437 break;
6438 }
6439 } while (c != die->die_child);
6440
6441#if 0
6442 /* We can only use this in debugging, since the frontend doesn't check
6443 to make sure that we leave every include file we enter. */
6444 gcc_assert (!unit);
6445#endif
6446
6447 assign_symbol_names (die);
6448 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
6449 for (node = limbo_die_list, pnode = &limbo_die_list;
6450 node;
6451 node = node->next)
6452 {
6453 int is_dupl;
6454
6455 compute_section_prefix (node->die);
6456 is_dupl = check_duplicate_cu (node->die, cu_hash_table,
6457 &comdat_symbol_number);
6458 assign_symbol_names (node->die);
6459 if (is_dupl)
6460 *pnode = node->next;
6461 else
6462 {
6463 pnode = &node->next;
6464 record_comdat_symbol_number (node->die, cu_hash_table,
6465 comdat_symbol_number);
6466 }
6467 }
6468 htab_delete (cu_hash_table);
6469}
6470
6471/* Traverse the DIE and add a sibling attribute if it may have the
6472 effect of speeding up access to siblings. To save some space,
6473 avoid generating sibling attributes for DIE's without children. */
6474
6475static void
6476add_sibling_attributes (dw_die_ref die)
6477{
6478 dw_die_ref c;
6479
6480 if (! die->die_child)
6481 return;
6482
6483 if (die->die_parent && die != die->die_parent->die_child)
6484 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
6485
6486 FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
6487}
6488
6489/* Output all location lists for the DIE and its children. */
6490
6491static void
6492output_location_lists (dw_die_ref die)
6493{
6494 dw_die_ref c;
6495 dw_attr_ref a;
6496 unsigned ix;
6497
6498 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6499 if (AT_class (a) == dw_val_class_loc_list)
6500 output_loc_list (AT_loc_list (a));
6501
6502 FOR_EACH_CHILD (die, c, output_location_lists (c));
6503}
6504
6505/* The format of each DIE (and its attribute value pairs) is encoded in an
6506 abbreviation table. This routine builds the abbreviation table and assigns
6507 a unique abbreviation id for each abbreviation entry. The children of each
6508 die are visited recursively. */
6509
6510static void
6511build_abbrev_table (dw_die_ref die)
6512{
6513 unsigned long abbrev_id;
6514 unsigned int n_alloc;
6515 dw_die_ref c;
6516 dw_attr_ref a;
6517 unsigned ix;
6518
6519 /* Scan the DIE references, and mark as external any that refer to
6520 DIEs from other CUs (i.e. those which are not marked). */
6521 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6522 if (AT_class (a) == dw_val_class_die_ref
6523 && AT_ref (a)->die_mark == 0)
6524 {
6525 gcc_assert (AT_ref (a)->die_symbol);
6526
6527 set_AT_ref_external (a, 1);
6528 }
6529
6530 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6531 {
6532 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6533 dw_attr_ref die_a, abbrev_a;
6534 unsigned ix;
6535 bool ok = true;
6536
6537 if (abbrev->die_tag != die->die_tag)
6538 continue;
6539 if ((abbrev->die_child != NULL) != (die->die_child != NULL))
6540 continue;
6541
6542 if (VEC_length (dw_attr_node, abbrev->die_attr)
6543 != VEC_length (dw_attr_node, die->die_attr))
6544 continue;
6545
6546 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, die_a); ix++)
6547 {
6548 abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix);
6549 if ((abbrev_a->dw_attr != die_a->dw_attr)
6550 || (value_format (abbrev_a) != value_format (die_a)))
6551 {
6552 ok = false;
6553 break;
6554 }
6555 }
6556 if (ok)
6557 break;
6558 }
6559
6560 if (abbrev_id >= abbrev_die_table_in_use)
6561 {
6562 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
6563 {
6564 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
6565 abbrev_die_table = ggc_realloc (abbrev_die_table,
6566 sizeof (dw_die_ref) * n_alloc);
6567
6568 memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
6569 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
6570 abbrev_die_table_allocated = n_alloc;
6571 }
6572
6573 ++abbrev_die_table_in_use;
6574 abbrev_die_table[abbrev_id] = die;
6575 }
6576
6577 die->die_abbrev = abbrev_id;
6578 FOR_EACH_CHILD (die, c, build_abbrev_table (c));
6579}
6580
6581/* Return the power-of-two number of bytes necessary to represent VALUE. */
6582
6583static int
6584constant_size (long unsigned int value)
6585{
6586 int log;
6587
6588 if (value == 0)
6589 log = 0;
6590 else
6591 log = floor_log2 (value);
6592
6593 log = log / 8;
6594 log = 1 << (floor_log2 (log) + 1);
6595
6596 return log;
6597}
6598
6599/* Return the size of a DIE as it is represented in the
6600 .debug_info section. */
6601
6602static unsigned long
6603size_of_die (dw_die_ref die)
6604{
6605 unsigned long size = 0;
6606 dw_attr_ref a;
6607 unsigned ix;
6608
6609 size += size_of_uleb128 (die->die_abbrev);
6610 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6611 {
6612 switch (AT_class (a))
6613 {
6614 case dw_val_class_addr:
6615 size += DWARF2_ADDR_SIZE;
6616 break;
6617 case dw_val_class_offset:
6618 size += DWARF_OFFSET_SIZE;
6619 break;
6620 case dw_val_class_loc:
6621 {
6622 unsigned long lsize = size_of_locs (AT_loc (a));
6623
6624 /* Block length. */
6625 size += constant_size (lsize);
6626 size += lsize;
6627 }
6628 break;
6629 case dw_val_class_loc_list:
6630 size += DWARF_OFFSET_SIZE;
6631 break;
6632 case dw_val_class_range_list:
6633 size += DWARF_OFFSET_SIZE;
6634 break;
6635 case dw_val_class_const:
6636 size += size_of_sleb128 (AT_int (a));
6637 break;
6638 case dw_val_class_unsigned_const:
6639 size += constant_size (AT_unsigned (a));
6640 break;
6641 case dw_val_class_long_long:
6642 size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */
6643 break;
6644 case dw_val_class_vec:
6645 size += 1 + (a->dw_attr_val.v.val_vec.length
6646 * a->dw_attr_val.v.val_vec.elt_size); /* block */
6647 break;
6648 case dw_val_class_flag:
6649 size += 1;
6650 break;
6651 case dw_val_class_die_ref:
6652 if (AT_ref_external (a))
6653 size += DWARF2_ADDR_SIZE;
6654 else
6655 size += DWARF_OFFSET_SIZE;
6656 break;
6657 case dw_val_class_fde_ref:
6658 size += DWARF_OFFSET_SIZE;
6659 break;
6660 case dw_val_class_lbl_id:
6661 size += DWARF2_ADDR_SIZE;
6662 break;
6663 case dw_val_class_lineptr:
6664 case dw_val_class_macptr:
6665 size += DWARF_OFFSET_SIZE;
6666 break;
6667 case dw_val_class_str:
6668 if (AT_string_form (a) == DW_FORM_strp)
6669 size += DWARF_OFFSET_SIZE;
6670 else
6671 size += strlen (a->dw_attr_val.v.val_str->str) + 1;
6672 break;
6673 case dw_val_class_file:
6674 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
6675 break;
6676 default:
6677 gcc_unreachable ();
6678 }
6679 }
6680
6681 return size;
6682}
6683
6684/* Size the debugging information associated with a given DIE. Visits the
6685 DIE's children recursively. Updates the global variable next_die_offset, on
6686 each time through. Uses the current value of next_die_offset to update the
6687 die_offset field in each DIE. */
6688
6689static void
6690calc_die_sizes (dw_die_ref die)
6691{
6692 dw_die_ref c;
6693
6694 die->die_offset = next_die_offset;
6695 next_die_offset += size_of_die (die);
6696
6697 FOR_EACH_CHILD (die, c, calc_die_sizes (c));
6698
6699 if (die->die_child != NULL)
6700 /* Count the null byte used to terminate sibling lists. */
6701 next_die_offset += 1;
6702}
6703
6704/* Set the marks for a die and its children. We do this so
6705 that we know whether or not a reference needs to use FORM_ref_addr; only
6706 DIEs in the same CU will be marked. We used to clear out the offset
6707 and use that as the flag, but ran into ordering problems. */
6708
6709static void
6710mark_dies (dw_die_ref die)
6711{
6712 dw_die_ref c;
6713
6714 gcc_assert (!die->die_mark);
6715
6716 die->die_mark = 1;
6717 FOR_EACH_CHILD (die, c, mark_dies (c));
6718}
6719
6720/* Clear the marks for a die and its children. */
6721
6722static void
6723unmark_dies (dw_die_ref die)
6724{
6725 dw_die_ref c;
6726
6727 gcc_assert (die->die_mark);
6728
6729 die->die_mark = 0;
6730 FOR_EACH_CHILD (die, c, unmark_dies (c));
6731}
6732
6733/* Clear the marks for a die, its children and referred dies. */
6734
6735static void
6736unmark_all_dies (dw_die_ref die)
6737{
6738 dw_die_ref c;
6739 dw_attr_ref a;
6740 unsigned ix;
6741
6742 if (!die->die_mark)
6743 return;
6744 die->die_mark = 0;
6745
6746 FOR_EACH_CHILD (die, c, unmark_all_dies (c));
6747
6748 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6749 if (AT_class (a) == dw_val_class_die_ref)
6750 unmark_all_dies (AT_ref (a));
6751}
6752
6753/* Return the size of the .debug_pubnames table generated for the
6754 compilation unit. */
6755
6756static unsigned long
6757size_of_pubnames (void)
6758{
6759 unsigned long size;
6760 unsigned i;
6761
6762 size = DWARF_PUBNAMES_HEADER_SIZE;
6763 for (i = 0; i < pubname_table_in_use; i++)
6764 {
6765 pubname_ref p = &pubname_table[i];
6766 size += DWARF_OFFSET_SIZE + strlen (p->name) + 1;
6767 }
6768
6769 size += DWARF_OFFSET_SIZE;
6770 return size;
6771}
6772
6773/* Return the size of the information in the .debug_aranges section. */
6774
6775static unsigned long
6776size_of_aranges (void)
6777{
6778 unsigned long size;
6779
6780 size = DWARF_ARANGES_HEADER_SIZE;
6781
6782 /* Count the address/length pair for this compilation unit. */
6783 size += 2 * DWARF2_ADDR_SIZE;
6784 size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
6785
6786 /* Count the two zero words used to terminated the address range table. */
6787 size += 2 * DWARF2_ADDR_SIZE;
6788 return size;
6789}
6790
6791/* Select the encoding of an attribute value. */
6792
6793static enum dwarf_form
6794value_format (dw_attr_ref a)
6795{
6796 switch (a->dw_attr_val.val_class)
6797 {
6798 case dw_val_class_addr:
6799 return DW_FORM_addr;
6800 case dw_val_class_range_list:
6801 case dw_val_class_offset:
6802 case dw_val_class_loc_list:
6803 switch (DWARF_OFFSET_SIZE)
6804 {
6805 case 4:
6806 return DW_FORM_data4;
6807 case 8:
6808 return DW_FORM_data8;
6809 default:
6810 gcc_unreachable ();
6811 }
6812 case dw_val_class_loc:
6813 switch (constant_size (size_of_locs (AT_loc (a))))
6814 {
6815 case 1:
6816 return DW_FORM_block1;
6817 case 2:
6818 return DW_FORM_block2;
6819 default:
6820 gcc_unreachable ();
6821 }
6822 case dw_val_class_const:
6823 return DW_FORM_sdata;
6824 case dw_val_class_unsigned_const:
6825 switch (constant_size (AT_unsigned (a)))
6826 {
6827 case 1:
6828 return DW_FORM_data1;
6829 case 2:
6830 return DW_FORM_data2;
6831 case 4:
6832 return DW_FORM_data4;
6833 case 8:
6834 return DW_FORM_data8;
6835 default:
6836 gcc_unreachable ();
6837 }
6838 case dw_val_class_long_long:
6839 return DW_FORM_block1;
6840 case dw_val_class_vec:
6841 return DW_FORM_block1;
6842 case dw_val_class_flag:
6843 return DW_FORM_flag;
6844 case dw_val_class_die_ref:
6845 if (AT_ref_external (a))
6846 return DW_FORM_ref_addr;
6847 else
6848 return DW_FORM_ref;
6849 case dw_val_class_fde_ref:
6850 return DW_FORM_data;
6851 case dw_val_class_lbl_id:
6852 return DW_FORM_addr;
6853 case dw_val_class_lineptr:
6854 case dw_val_class_macptr:
6855 return DW_FORM_data;
6856 case dw_val_class_str:
6857 return AT_string_form (a);
6858 case dw_val_class_file:
6859 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
6860 {
6861 case 1:
6862 return DW_FORM_data1;
6863 case 2:
6864 return DW_FORM_data2;
6865 case 4:
6866 return DW_FORM_data4;
6867 default:
6868 gcc_unreachable ();
6869 }
6870
6871 default:
6872 gcc_unreachable ();
6873 }
6874}
6875
6876/* Output the encoding of an attribute value. */
6877
6878static void
6879output_value_format (dw_attr_ref a)
6880{
6881 enum dwarf_form form = value_format (a);
6882
6883 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
6884}
6885
6886/* Output the .debug_abbrev section which defines the DIE abbreviation
6887 table. */
6888
6889static void
6890output_abbrev_section (void)
6891{
6892 unsigned long abbrev_id;
6893
6894 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6895 {
6896 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6897 unsigned ix;
6898 dw_attr_ref a_attr;
6899
6900 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
6901 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
6902 dwarf_tag_name (abbrev->die_tag));
6903
6904 if (abbrev->die_child != NULL)
6905 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
6906 else
6907 dw2_asm_output_data (1, DW_children_no, "DW_children_no");
6908
6909 for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr);
6910 ix++)
6911 {
6912 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
6913 dwarf_attr_name (a_attr->dw_attr));
6914 output_value_format (a_attr);
6915 }
6916
6917 dw2_asm_output_data (1, 0, NULL);
6918 dw2_asm_output_data (1, 0, NULL);
6919 }
6920
6921 /* Terminate the table. */
6922 dw2_asm_output_data (1, 0, NULL);
6923}
6924
6925/* Output a symbol we can use to refer to this DIE from another CU. */
6926
6927static inline void
6928output_die_symbol (dw_die_ref die)
6929{
6930 char *sym = die->die_symbol;
6931
6932 if (sym == 0)
6933 return;
6934
6935 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
6936 /* We make these global, not weak; if the target doesn't support
6937 .linkonce, it doesn't support combining the sections, so debugging
6938 will break. */
6939 targetm.asm_out.globalize_label (asm_out_file, sym);
6940
6941 ASM_OUTPUT_LABEL (asm_out_file, sym);
6942}
6943
6944/* Return a new location list, given the begin and end range, and the
6945 expression. gensym tells us whether to generate a new internal symbol for
6946 this location list node, which is done for the head of the list only. */
6947
6948static inline dw_loc_list_ref
6949new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
6950 const char *section, unsigned int gensym)
6951{
6952 dw_loc_list_ref retlist = ggc_alloc_cleared (sizeof (dw_loc_list_node));
6953
6954 retlist->begin = begin;
6955 retlist->end = end;
6956 retlist->expr = expr;
6957 retlist->section = section;
6958 if (gensym)
6959 retlist->ll_symbol = gen_internal_sym ("LLST");
6960
6961 return retlist;
6962}
6963
6964/* Add a location description expression to a location list. */
6965
6966static inline void
6967add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr,
6968 const char *begin, const char *end,
6969 const char *section)
6970{
6971 dw_loc_list_ref *d;
6972
6973 /* Find the end of the chain. */
6974 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
6975 ;
6976
6977 /* Add a new location list node to the list. */
6978 *d = new_loc_list (descr, begin, end, section, 0);
6979}
6980
6981static void
6982dwarf2out_switch_text_section (void)
6983{
6984 dw_fde_ref fde;
6985
6986 gcc_assert (cfun);
6987
6988 fde = &fde_table[fde_table_in_use - 1];
6989 fde->dw_fde_switched_sections = true;
6990 fde->dw_fde_hot_section_label = cfun->hot_section_label;
6991 fde->dw_fde_hot_section_end_label = cfun->hot_section_end_label;
6992 fde->dw_fde_unlikely_section_label = cfun->cold_section_label;
6993 fde->dw_fde_unlikely_section_end_label = cfun->cold_section_end_label;
6994 have_multiple_function_sections = true;
6995
6996 /* Reset the current label on switching text sections, so that we
6997 don't attempt to advance_loc4 between labels in different sections. */
6998 fde->dw_fde_current_label = NULL;
6999}
7000
7001/* Output the location list given to us. */
7002
7003static void
7004output_loc_list (dw_loc_list_ref list_head)
7005{
7006 dw_loc_list_ref curr = list_head;
7007
7008 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
7009
7010 /* Walk the location list, and output each range + expression. */
7011 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
7012 {
7013 unsigned long size;
7014 if (!have_multiple_function_sections)
7015 {
7016 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
7017 "Location list begin address (%s)",
7018 list_head->ll_symbol);
7019 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
7020 "Location list end address (%s)",
7021 list_head->ll_symbol);
7022 }
7023 else
7024 {
7025 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
7026 "Location list begin address (%s)",
7027 list_head->ll_symbol);
7028 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
7029 "Location list end address (%s)",
7030 list_head->ll_symbol);
7031 }
7032 size = size_of_locs (curr->expr);
7033
7034 /* Output the block length for this list of location operations. */
7035 gcc_assert (size <= 0xffff);
7036 dw2_asm_output_data (2, size, "%s", "Location expression size");
7037
7038 output_loc_sequence (curr->expr);
7039 }
7040
7041 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7042 "Location list terminator begin (%s)",
7043 list_head->ll_symbol);
7044 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7045 "Location list terminator end (%s)",
7046 list_head->ll_symbol);
7047}
7048
7049/* Output the DIE and its attributes. Called recursively to generate
7050 the definitions of each child DIE. */
7051
7052static void
7053output_die (dw_die_ref die)
7054{
7055 dw_attr_ref a;
7056 dw_die_ref c;
7057 unsigned long size;
7058 unsigned ix;
7059
7060 /* If someone in another CU might refer to us, set up a symbol for
7061 them to point to. */
7062 if (die->die_symbol)
7063 output_die_symbol (die);
7064
7065 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
7066 die->die_offset, dwarf_tag_name (die->die_tag));
7067
7068 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7069 {
7070 const char *name = dwarf_attr_name (a->dw_attr);
7071
7072 switch (AT_class (a))
7073 {
7074 case dw_val_class_addr:
7075 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
7076 break;
7077
7078 case dw_val_class_offset:
7079 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
7080 "%s", name);
7081 break;
7082
7083 case dw_val_class_range_list:
7084 {
7085 char *p = strchr (ranges_section_label, '\0');
7086
7087 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
7088 a->dw_attr_val.v.val_offset);
7089 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
7090 debug_ranges_section, "%s", name);
7091 *p = '\0';
7092 }
7093 break;
7094
7095 case dw_val_class_loc:
7096 size = size_of_locs (AT_loc (a));
7097
7098 /* Output the block length for this list of location operations. */
7099 dw2_asm_output_data (constant_size (size), size, "%s", name);
7100
7101 output_loc_sequence (AT_loc (a));
7102 break;
7103
7104 case dw_val_class_const:
7105 /* ??? It would be slightly more efficient to use a scheme like is
7106 used for unsigned constants below, but gdb 4.x does not sign
7107 extend. Gdb 5.x does sign extend. */
7108 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
7109 break;
7110
7111 case dw_val_class_unsigned_const:
7112 dw2_asm_output_data (constant_size (AT_unsigned (a)),
7113 AT_unsigned (a), "%s", name);
7114 break;
7115
7116 case dw_val_class_long_long:
7117 {
7118 unsigned HOST_WIDE_INT first, second;
7119
7120 dw2_asm_output_data (1,
7121 2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7122 "%s", name);
7123
7124 if (WORDS_BIG_ENDIAN)
7125 {
7126 first = a->dw_attr_val.v.val_long_long.hi;
7127 second = a->dw_attr_val.v.val_long_long.low;
7128 }
7129 else
7130 {
7131 first = a->dw_attr_val.v.val_long_long.low;
7132 second = a->dw_attr_val.v.val_long_long.hi;
7133 }
7134
7135 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7136 first, "long long constant");
7137 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7138 second, NULL);
7139 }
7140 break;
7141
7142 case dw_val_class_vec:
7143 {
7144 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
7145 unsigned int len = a->dw_attr_val.v.val_vec.length;
7146 unsigned int i;
7147 unsigned char *p;
7148
7149 dw2_asm_output_data (1, len * elt_size, "%s", name);
7150 if (elt_size > sizeof (HOST_WIDE_INT))
7151 {
7152 elt_size /= 2;
7153 len *= 2;
7154 }
7155 for (i = 0, p = a->dw_attr_val.v.val_vec.array;
7156 i < len;
7157 i++, p += elt_size)
7158 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
7159 "fp or vector constant word %u", i);
7160 break;
7161 }
7162
7163 case dw_val_class_flag:
7164 dw2_asm_output_data (1, AT_flag (a), "%s", name);
7165 break;
7166
7167 case dw_val_class_loc_list:
7168 {
7169 char *sym = AT_loc_list (a)->ll_symbol;
7170
7171 gcc_assert (sym);
7172 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
7173 "%s", name);
7174 }
7175 break;
7176
7177 case dw_val_class_die_ref:
7178 if (AT_ref_external (a))
7179 {
7180 char *sym = AT_ref (a)->die_symbol;
7181
7182 gcc_assert (sym);
7183 dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, debug_info_section,
7184 "%s", name);
7185 }
7186 else
7187 {
7188 gcc_assert (AT_ref (a)->die_offset);
7189 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
7190 "%s", name);
7191 }
7192 break;
7193
7194 case dw_val_class_fde_ref:
7195 {
7196 char l1[20];
7197
7198 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
7199 a->dw_attr_val.v.val_fde_index * 2);
7200 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
7201 "%s", name);
7202 }
7203 break;
7204
7205 case dw_val_class_lbl_id:
7206 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
7207 break;
7208
7209 case dw_val_class_lineptr:
7210 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
7211 debug_line_section, "%s", name);
7212 break;
7213
7214 case dw_val_class_macptr:
7215 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
7216 debug_macinfo_section, "%s", name);
7217 break;
7218
7219 case dw_val_class_str:
7220 if (AT_string_form (a) == DW_FORM_strp)
7221 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
7222 a->dw_attr_val.v.val_str->label,
7223 debug_str_section,
7224 "%s: \"%s\"", name, AT_string (a));
7225 else
7226 dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
7227 break;
7228
7229 case dw_val_class_file:
7230 {
7231 int f = maybe_emit_file (a->dw_attr_val.v.val_file);
7232
7233 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
7234 a->dw_attr_val.v.val_file->filename);
7235 break;
7236 }
7237
7238 default:
7239 gcc_unreachable ();
7240 }
7241 }
7242
7243 FOR_EACH_CHILD (die, c, output_die (c));
7244
7245 /* Add null byte to terminate sibling list. */
7246 if (die->die_child != NULL)
7247 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
7248 die->die_offset);
7249}
7250
7251/* Output the compilation unit that appears at the beginning of the
7252 .debug_info section, and precedes the DIE descriptions. */
7253
7254static void
7255output_compilation_unit_header (void)
7256{
7257 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7258 dw2_asm_output_data (4, 0xffffffff,
7259 "Initial length escape value indicating 64-bit DWARF extension");
7260 dw2_asm_output_data (DWARF_OFFSET_SIZE,
7261 next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
7262 "Length of Compilation Unit Info");
7263 dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number");
7264 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
7265 debug_abbrev_section,
7266 "Offset Into Abbrev. Section");
7267 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
7268}
7269
7270/* Output the compilation unit DIE and its children. */
7271
7272static void
7273output_comp_unit (dw_die_ref die, int output_if_empty)
7274{
7275 const char *secname;
7276 char *oldsym, *tmp;
7277
7278 /* Unless we are outputting main CU, we may throw away empty ones. */
7279 if (!output_if_empty && die->die_child == NULL)
7280 return;
7281
7282 /* Even if there are no children of this DIE, we must output the information
7283 about the compilation unit. Otherwise, on an empty translation unit, we
7284 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
7285 will then complain when examining the file. First mark all the DIEs in
7286 this CU so we know which get local refs. */
7287 mark_dies (die);
7288
7289 build_abbrev_table (die);
7290
7291 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
7292 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
7293 calc_die_sizes (die);
7294
7295 oldsym = die->die_symbol;
7296 if (oldsym)
7297 {
7298 tmp = alloca (strlen (oldsym) + 24);
7299
7300 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
7301 secname = tmp;
7302 die->die_symbol = NULL;
7303 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
7304 }
7305 else
7306 switch_to_section (debug_info_section);
7307
7308 /* Output debugging information. */
7309 output_compilation_unit_header ();
7310 output_die (die);
7311
7312 /* Leave the marks on the main CU, so we can check them in
7313 output_pubnames. */
7314 if (oldsym)
7315 {
7316 unmark_dies (die);
7317 die->die_symbol = oldsym;
7318 }
7319}
7320
7321/* Return the DWARF2/3 pubname associated with a decl. */
7322
7323static const char *
7324dwarf2_name (tree decl, int scope)
7325{
7326 return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
7327}
7328
7329/* Add a new entry to .debug_pubnames if appropriate. */
7330
7331static void
7332add_pubname (tree decl, dw_die_ref die)
7333{
7334 pubname_ref p;
7335
7336 if (! TREE_PUBLIC (decl))
7337 return;
7338
7339 if (pubname_table_in_use == pubname_table_allocated)
7340 {
7341 pubname_table_allocated += PUBNAME_TABLE_INCREMENT;
7342 pubname_table
7343 = ggc_realloc (pubname_table,
7344 (pubname_table_allocated * sizeof (pubname_entry)));
7345 memset (pubname_table + pubname_table_in_use, 0,
7346 PUBNAME_TABLE_INCREMENT * sizeof (pubname_entry));
7347 }
7348
7349 p = &pubname_table[pubname_table_in_use++];
7350 p->die = die;
7351 p->name = xstrdup (dwarf2_name (decl, 1));
7352}
7353
7354/* Output the public names table used to speed up access to externally
7355 visible names. For now, only generate entries for externally
7356 visible procedures. */
7357
7358static void
7359output_pubnames (void)
7360{
7361 unsigned i;
7362 unsigned long pubnames_length = size_of_pubnames ();
7363
7364 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7365 dw2_asm_output_data (4, 0xffffffff,
7366 "Initial length escape value indicating 64-bit DWARF extension");
7367 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
7368 "Length of Public Names Info");
7369 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7370 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7371 debug_info_section,
7372 "Offset of Compilation Unit Info");
7373 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
7374 "Compilation Unit Length");
7375
7376 for (i = 0; i < pubname_table_in_use; i++)
7377 {
7378 pubname_ref pub = &pubname_table[i];
7379
7380 /* We shouldn't see pubnames for DIEs outside of the main CU. */
7381 gcc_assert (pub->die->die_mark);
7382
7383 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
7384 "DIE offset");
7385
7386 dw2_asm_output_nstring (pub->name, -1, "external name");
7387 }
7388
7389 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
7390}
7391
7392/* Add a new entry to .debug_aranges if appropriate. */
7393
7394static void
7395add_arange (tree decl, dw_die_ref die)
7396{
7397 if (! DECL_SECTION_NAME (decl))
7398 return;
7399
7400 if (arange_table_in_use == arange_table_allocated)
7401 {
7402 arange_table_allocated += ARANGE_TABLE_INCREMENT;
7403 arange_table = ggc_realloc (arange_table,
7404 (arange_table_allocated
7405 * sizeof (dw_die_ref)));
7406 memset (arange_table + arange_table_in_use, 0,
7407 ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
7408 }
7409
7410 arange_table[arange_table_in_use++] = die;
7411}
7412
7413/* Output the information that goes into the .debug_aranges table.
7414 Namely, define the beginning and ending address range of the
7415 text section generated for this compilation unit. */
7416
7417static void
7418output_aranges (void)
7419{
7420 unsigned i;
7421 unsigned long aranges_length = size_of_aranges ();
7422
7423 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7424 dw2_asm_output_data (4, 0xffffffff,
7425 "Initial length escape value indicating 64-bit DWARF extension");
7426 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
7427 "Length of Address Ranges Info");
7428 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7429 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7430 debug_info_section,
7431 "Offset of Compilation Unit Info");
7432 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
7433 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
7434
7435 /* We need to align to twice the pointer size here. */
7436 if (DWARF_ARANGES_PAD_SIZE)
7437 {
7438 /* Pad using a 2 byte words so that padding is correct for any
7439 pointer size. */
7440 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
7441 2 * DWARF2_ADDR_SIZE);
7442 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
7443 dw2_asm_output_data (2, 0, NULL);
7444 }
7445
7446 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
7447 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
7448 text_section_label, "Length");
7449 if (flag_reorder_blocks_and_partition)
7450 {
7451 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
7452 "Address");
7453 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
7454 cold_text_section_label, "Length");
7455 }
7456
7457 for (i = 0; i < arange_table_in_use; i++)
7458 {
7459 dw_die_ref die = arange_table[i];
7460
7461 /* We shouldn't see aranges for DIEs outside of the main CU. */
7462 gcc_assert (die->die_mark);
7463
7464 if (die->die_tag == DW_TAG_subprogram)
7465 {
7466 dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
7467 "Address");
7468 dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
7469 get_AT_low_pc (die), "Length");
7470 }
7471 else
7472 {
7473 /* A static variable; extract the symbol from DW_AT_location.
7474 Note that this code isn't currently hit, as we only emit
7475 aranges for functions (jason 9/23/99). */
7476 dw_attr_ref a = get_AT (die, DW_AT_location);
7477 dw_loc_descr_ref loc;
7478
7479 gcc_assert (a && AT_class (a) == dw_val_class_loc);
7480
7481 loc = AT_loc (a);
7482 gcc_assert (loc->dw_loc_opc == DW_OP_addr);
7483
7484 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
7485 loc->dw_loc_oprnd1.v.val_addr, "Address");
7486 dw2_asm_output_data (DWARF2_ADDR_SIZE,
7487 get_AT_unsigned (die, DW_AT_byte_size),
7488 "Length");
7489 }
7490 }
7491
7492 /* Output the terminator words. */
7493 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7494 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7495}
7496
7497/* Add a new entry to .debug_ranges. Return the offset at which it
7498 was placed. */
7499
7500static unsigned int
7501add_ranges (tree block)
7502{
7503 unsigned int in_use = ranges_table_in_use;
7504
7505 if (in_use == ranges_table_allocated)
7506 {
7507 ranges_table_allocated += RANGES_TABLE_INCREMENT;
7508 ranges_table
7509 = ggc_realloc (ranges_table, (ranges_table_allocated
7510 * sizeof (struct dw_ranges_struct)));
7511 memset (ranges_table + ranges_table_in_use, 0,
7512 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
7513 }
7514
7515 ranges_table[in_use].block_num = (block ? BLOCK_NUMBER (block) : 0);
7516 ranges_table_in_use = in_use + 1;
7517
7518 return in_use * 2 * DWARF2_ADDR_SIZE;
7519}
7520
7521static void
7522output_ranges (void)
7523{
7524 unsigned i;
7525 static const char *const start_fmt = "Offset 0x%x";
7526 const char *fmt = start_fmt;
7527
7528 for (i = 0; i < ranges_table_in_use; i++)
7529 {
7530 int block_num = ranges_table[i].block_num;
7531
7532 if (block_num)
7533 {
7534 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
7535 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
7536
7537 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
7538 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
7539
7540 /* If all code is in the text section, then the compilation
7541 unit base address defaults to DW_AT_low_pc, which is the
7542 base of the text section. */
7543 if (!have_multiple_function_sections)
7544 {
7545 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
7546 text_section_label,
7547 fmt, i * 2 * DWARF2_ADDR_SIZE);
7548 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
7549 text_section_label, NULL);
7550 }
7551
7552 /* Otherwise, we add a DW_AT_entry_pc attribute to force the
7553 compilation unit base address to zero, which allows us to
7554 use absolute addresses, and not worry about whether the
7555 target supports cross-section arithmetic. */
7556 else
7557 {
7558 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
7559 fmt, i * 2 * DWARF2_ADDR_SIZE);
7560 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
7561 }
7562
7563 fmt = NULL;
7564 }
7565 else
7566 {
7567 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7568 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7569 fmt = start_fmt;
7570 }
7571 }
7572}
7573
7574/* Data structure containing information about input files. */
7575struct file_info
7576{
7577 const char *path; /* Complete file name. */
7578 const char *fname; /* File name part. */
7579 int length; /* Length of entire string. */
7580 struct dwarf_file_data * file_idx; /* Index in input file table. */
7581 int dir_idx; /* Index in directory table. */
7582};
7583
7584/* Data structure containing information about directories with source
7585 files. */
7586struct dir_info
7587{
7588 const char *path; /* Path including directory name. */
7589 int length; /* Path length. */
7590 int prefix; /* Index of directory entry which is a prefix. */
7591 int count; /* Number of files in this directory. */
7592 int dir_idx; /* Index of directory used as base. */
7593};
7594
7595/* Callback function for file_info comparison. We sort by looking at
7596 the directories in the path. */
7597
7598static int
7599file_info_cmp (const void *p1, const void *p2)
7600{
7601 const struct file_info *s1 = p1;
7602 const struct file_info *s2 = p2;
7603 unsigned char *cp1;
7604 unsigned char *cp2;
7605
7606 /* Take care of file names without directories. We need to make sure that
7607 we return consistent values to qsort since some will get confused if
7608 we return the same value when identical operands are passed in opposite
7609 orders. So if neither has a directory, return 0 and otherwise return
7610 1 or -1 depending on which one has the directory. */
7611 if ((s1->path == s1->fname || s2->path == s2->fname))
7612 return (s2->path == s2->fname) - (s1->path == s1->fname);
7613
7614 cp1 = (unsigned char *) s1->path;
7615 cp2 = (unsigned char *) s2->path;
7616
7617 while (1)
7618 {
7619 ++cp1;
7620 ++cp2;
7621 /* Reached the end of the first path? If so, handle like above. */
7622 if ((cp1 == (unsigned char *) s1->fname)
7623 || (cp2 == (unsigned char *) s2->fname))
7624 return ((cp2 == (unsigned char *) s2->fname)
7625 - (cp1 == (unsigned char *) s1->fname));
7626
7627 /* Character of current path component the same? */
7628 else if (*cp1 != *cp2)
7629 return *cp1 - *cp2;
7630 }
7631}
7632
7633struct file_name_acquire_data
7634{
7635 struct file_info *files;
7636 int used_files;
7637 int max_files;
7638};
7639
7640/* Traversal function for the hash table. */
7641
7642static int
7643file_name_acquire (void ** slot, void *data)
7644{
7645 struct file_name_acquire_data *fnad = data;
7646 struct dwarf_file_data *d = *slot;
7647 struct file_info *fi;
7648 const char *f;
7649
7650 gcc_assert (fnad->max_files >= d->emitted_number);
7651
7652 if (! d->emitted_number)
7653 return 1;
7654
7655 gcc_assert (fnad->max_files != fnad->used_files);
7656
7657 fi = fnad->files + fnad->used_files++;
7658
7659 /* Skip all leading "./". */
7660 f = d->filename;
7661 while (f[0] == '.' && f[1] == '/')
7662 f += 2;
7663
7664 /* Create a new array entry. */
7665 fi->path = f;
7666 fi->length = strlen (f);
7667 fi->file_idx = d;
7668
7669 /* Search for the file name part. */
7670 f = strrchr (f, '/');
7671 fi->fname = f == NULL ? fi->path : f + 1;
7672 return 1;
7673}
7674
7675/* Output the directory table and the file name table. We try to minimize
7676 the total amount of memory needed. A heuristic is used to avoid large
7677 slowdowns with many input files. */
7678
7679static void
7680output_file_names (void)
7681{
7682 struct file_name_acquire_data fnad;
7683 int numfiles;
7684 struct file_info *files;
7685 struct dir_info *dirs;
7686 int *saved;
7687 int *savehere;
7688 int *backmap;
7689 int ndirs;
7690 int idx_offset;
7691 int i;
7692 int idx;
7693
7694 if (!last_emitted_file)
7695 {
7696 dw2_asm_output_data (1, 0, "End directory table");
7697 dw2_asm_output_data (1, 0, "End file name table");
7698 return;
7699 }
7700
7701 numfiles = last_emitted_file->emitted_number;
7702
7703 /* Allocate the various arrays we need. */
7704 files = alloca (numfiles * sizeof (struct file_info));
7705 dirs = alloca (numfiles * sizeof (struct dir_info));
7706
7707 fnad.files = files;
7708 fnad.used_files = 0;
7709 fnad.max_files = numfiles;
7710 htab_traverse (file_table, file_name_acquire, &fnad);
7711 gcc_assert (fnad.used_files == fnad.max_files);
7712
7713 qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
7714
7715 /* Find all the different directories used. */
7716 dirs[0].path = files[0].path;
7717 dirs[0].length = files[0].fname - files[0].path;
7718 dirs[0].prefix = -1;
7719 dirs[0].count = 1;
7720 dirs[0].dir_idx = 0;
7721 files[0].dir_idx = 0;
7722 ndirs = 1;
7723
7724 for (i = 1; i < numfiles; i++)
7725 if (files[i].fname - files[i].path == dirs[ndirs - 1].length
7726 && memcmp (dirs[ndirs - 1].path, files[i].path,
7727 dirs[ndirs - 1].length) == 0)
7728 {
7729 /* Same directory as last entry. */
7730 files[i].dir_idx = ndirs - 1;
7731 ++dirs[ndirs - 1].count;
7732 }
7733 else
7734 {
7735 int j;
7736
7737 /* This is a new directory. */
7738 dirs[ndirs].path = files[i].path;
7739 dirs[ndirs].length = files[i].fname - files[i].path;
7740 dirs[ndirs].count = 1;
7741 dirs[ndirs].dir_idx = ndirs;
7742 files[i].dir_idx = ndirs;
7743
7744 /* Search for a prefix. */
7745 dirs[ndirs].prefix = -1;
7746 for (j = 0; j < ndirs; j++)
7747 if (dirs[j].length < dirs[ndirs].length
7748 && dirs[j].length > 1
7749 && (dirs[ndirs].prefix == -1
7750 || dirs[j].length > dirs[dirs[ndirs].prefix].length)
7751 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
7752 dirs[ndirs].prefix = j;
7753
7754 ++ndirs;
7755 }
7756
7757 /* Now to the actual work. We have to find a subset of the directories which
7758 allow expressing the file name using references to the directory table
7759 with the least amount of characters. We do not do an exhaustive search
7760 where we would have to check out every combination of every single
7761 possible prefix. Instead we use a heuristic which provides nearly optimal
7762 results in most cases and never is much off. */
7763 saved = alloca (ndirs * sizeof (int));
7764 savehere = alloca (ndirs * sizeof (int));
7765
7766 memset (saved, '\0', ndirs * sizeof (saved[0]));
7767 for (i = 0; i < ndirs; i++)
7768 {
7769 int j;
7770 int total;
7771
7772 /* We can always save some space for the current directory. But this
7773 does not mean it will be enough to justify adding the directory. */
7774 savehere[i] = dirs[i].length;
7775 total = (savehere[i] - saved[i]) * dirs[i].count;
7776
7777 for (j = i + 1; j < ndirs; j++)
7778 {
7779 savehere[j] = 0;
7780 if (saved[j] < dirs[i].length)
7781 {
7782 /* Determine whether the dirs[i] path is a prefix of the
7783 dirs[j] path. */
7784 int k;
7785
7786 k = dirs[j].prefix;
7787 while (k != -1 && k != (int) i)
7788 k = dirs[k].prefix;
7789
7790 if (k == (int) i)
7791 {
7792 /* Yes it is. We can possibly save some memory by
7793 writing the filenames in dirs[j] relative to
7794 dirs[i]. */
7795 savehere[j] = dirs[i].length;
7796 total += (savehere[j] - saved[j]) * dirs[j].count;
7797 }
7798 }
7799 }
7800
7801 /* Check whether we can save enough to justify adding the dirs[i]
7802 directory. */
7803 if (total > dirs[i].length + 1)
7804 {
7805 /* It's worthwhile adding. */
7806 for (j = i; j < ndirs; j++)
7807 if (savehere[j] > 0)
7808 {
7809 /* Remember how much we saved for this directory so far. */
7810 saved[j] = savehere[j];
7811
7812 /* Remember the prefix directory. */
7813 dirs[j].dir_idx = i;
7814 }
7815 }
7816 }
7817
7818 /* Emit the directory name table. */
7819 idx = 1;
7820 idx_offset = dirs[0].length > 0 ? 1 : 0;
7821 for (i = 1 - idx_offset; i < ndirs; i++)
7822 dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1,
7823 "Directory Entry: 0x%x", i + idx_offset);
7824
7825 dw2_asm_output_data (1, 0, "End directory table");
7826
7827 /* We have to emit them in the order of emitted_number since that's
7828 used in the debug info generation. To do this efficiently we
7829 generate a back-mapping of the indices first. */
7830 backmap = alloca (numfiles * sizeof (int));
7831 for (i = 0; i < numfiles; i++)
7832 backmap[files[i].file_idx->emitted_number - 1] = i;
7833
7834 /* Now write all the file names. */
7835 for (i = 0; i < numfiles; i++)
7836 {
7837 int file_idx = backmap[i];
7838 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
7839
7840 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
7841 "File Entry: 0x%x", (unsigned) i + 1);
7842
7843 /* Include directory index. */
7844 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
7845
7846 /* Modification time. */
7847 dw2_asm_output_data_uleb128 (0, NULL);
7848
7849 /* File length in bytes. */
7850 dw2_asm_output_data_uleb128 (0, NULL);
7851 }
7852
7853 dw2_asm_output_data (1, 0, "End file name table");
7854}
7855
7856
7857/* Output the source line number correspondence information. This
7858 information goes into the .debug_line section. */
7859
7860static void
7861output_line_info (void)
7862{
7863 char l1[20], l2[20], p1[20], p2[20];
7864 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7865 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7866 unsigned opc;
7867 unsigned n_op_args;
7868 unsigned long lt_index;
7869 unsigned long current_line;
7870 long line_offset;
7871 long line_delta;
7872 unsigned long current_file;
7873 unsigned long function;
7874
7875 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
7876 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
7877 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
7878 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
7879
7880 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7881 dw2_asm_output_data (4, 0xffffffff,
7882 "Initial length escape value indicating 64-bit DWARF extension");
7883 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
7884 "Length of Source Line Info");
7885 ASM_OUTPUT_LABEL (asm_out_file, l1);
7886
7887 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7888 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
7889 ASM_OUTPUT_LABEL (asm_out_file, p1);
7890
7891 /* Define the architecture-dependent minimum instruction length (in
7892 bytes). In this implementation of DWARF, this field is used for
7893 information purposes only. Since GCC generates assembly language,
7894 we have no a priori knowledge of how many instruction bytes are
7895 generated for each source line, and therefore can use only the
7896 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
7897 commands. Accordingly, we fix this as `1', which is "correct
7898 enough" for all architectures, and don't let the target override. */
7899 dw2_asm_output_data (1, 1,
7900 "Minimum Instruction Length");
7901
7902 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
7903 "Default is_stmt_start flag");
7904 dw2_asm_output_data (1, DWARF_LINE_BASE,
7905 "Line Base Value (Special Opcodes)");
7906 dw2_asm_output_data (1, DWARF_LINE_RANGE,
7907 "Line Range Value (Special Opcodes)");
7908 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
7909 "Special Opcode Base");
7910
7911 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
7912 {
7913 switch (opc)
7914 {
7915 case DW_LNS_advance_pc:
7916 case DW_LNS_advance_line:
7917 case DW_LNS_set_file:
7918 case DW_LNS_set_column:
7919 case DW_LNS_fixed_advance_pc:
7920 n_op_args = 1;
7921 break;
7922 default:
7923 n_op_args = 0;
7924 break;
7925 }
7926
7927 dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
7928 opc, n_op_args);
7929 }
7930
7931 /* Write out the information about the files we use. */
7932 output_file_names ();
7933 ASM_OUTPUT_LABEL (asm_out_file, p2);
7934
7935 /* We used to set the address register to the first location in the text
7936 section here, but that didn't accomplish anything since we already
7937 have a line note for the opening brace of the first function. */
7938
7939 /* Generate the line number to PC correspondence table, encoded as
7940 a series of state machine operations. */
7941 current_file = 1;
7942 current_line = 1;
7943
7944 if (cfun && in_cold_section_p)
7945 strcpy (prev_line_label, cfun->cold_section_label);
7946 else
7947 strcpy (prev_line_label, text_section_label);
7948 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
7949 {
7950 dw_line_info_ref line_info = &line_info_table[lt_index];
7951
7952#if 0
7953 /* Disable this optimization for now; GDB wants to see two line notes
7954 at the beginning of a function so it can find the end of the
7955 prologue. */
7956
7957 /* Don't emit anything for redundant notes. Just updating the
7958 address doesn't accomplish anything, because we already assume
7959 that anything after the last address is this line. */
7960 if (line_info->dw_line_num == current_line
7961 && line_info->dw_file_num == current_file)
7962 continue;
7963#endif
7964
7965 /* Emit debug info for the address of the current line.
7966
7967 Unfortunately, we have little choice here currently, and must always
7968 use the most general form. GCC does not know the address delta
7969 itself, so we can't use DW_LNS_advance_pc. Many ports do have length
7970 attributes which will give an upper bound on the address range. We
7971 could perhaps use length attributes to determine when it is safe to
7972 use DW_LNS_fixed_advance_pc. */
7973
7974 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
7975 if (0)
7976 {
7977 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
7978 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7979 "DW_LNS_fixed_advance_pc");
7980 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
7981 }
7982 else
7983 {
7984 /* This can handle any delta. This takes
7985 4+DWARF2_ADDR_SIZE bytes. */
7986 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7987 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7988 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7989 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7990 }
7991
7992 strcpy (prev_line_label, line_label);
7993
7994 /* Emit debug info for the source file of the current line, if
7995 different from the previous line. */
7996 if (line_info->dw_file_num != current_file)
7997 {
7998 current_file = line_info->dw_file_num;
7999 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
8000 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
8001 }
8002
8003 /* Emit debug info for the current line number, choosing the encoding
8004 that uses the least amount of space. */
8005 if (line_info->dw_line_num != current_line)
8006 {
8007 line_offset = line_info->dw_line_num - current_line;
8008 line_delta = line_offset - DWARF_LINE_BASE;
8009 current_line = line_info->dw_line_num;
8010 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
8011 /* This can handle deltas from -10 to 234, using the current
8012 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
8013 takes 1 byte. */
8014 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
8015 "line %lu", current_line);
8016 else
8017 {
8018 /* This can handle any delta. This takes at least 4 bytes,
8019 depending on the value being encoded. */
8020 dw2_asm_output_data (1, DW_LNS_advance_line,
8021 "advance to line %lu", current_line);
8022 dw2_asm_output_data_sleb128 (line_offset, NULL);
8023 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8024 }
8025 }
8026 else
8027 /* We still need to start a new row, so output a copy insn. */
8028 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8029 }
8030
8031 /* Emit debug info for the address of the end of the function. */
8032 if (0)
8033 {
8034 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8035 "DW_LNS_fixed_advance_pc");
8036 dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
8037 }
8038 else
8039 {
8040 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8041 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8042 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8043 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
8044 }
8045
8046 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
8047 dw2_asm_output_data_uleb128 (1, NULL);
8048 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
8049
8050 function = 0;
8051 current_file = 1;
8052 current_line = 1;
8053 for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
8054 {
8055 dw_separate_line_info_ref line_info
8056 = &separate_line_info_table[lt_index];
8057
8058#if 0
8059 /* Don't emit anything for redundant notes. */
8060 if (line_info->dw_line_num == current_line
8061 && line_info->dw_file_num == current_file
8062 && line_info->function == function)
8063 goto cont;
8064#endif
8065
8066 /* Emit debug info for the address of the current line. If this is
8067 a new function, or the first line of a function, then we need
8068 to handle it differently. */
8069 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
8070 lt_index);
8071 if (function != line_info->function)
8072 {
8073 function = line_info->function;
8074
8075 /* Set the address register to the first line in the function. */
8076 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8077 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8078 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8079 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8080 }
8081 else
8082 {
8083 /* ??? See the DW_LNS_advance_pc comment above. */
8084 if (0)
8085 {
8086 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8087 "DW_LNS_fixed_advance_pc");
8088 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
8089 }
8090 else
8091 {
8092 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8093 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8094 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8095 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8096 }
8097 }
8098
8099 strcpy (prev_line_label, line_label);
8100
8101 /* Emit debug info for the source file of the current line, if
8102 different from the previous line. */
8103 if (line_info->dw_file_num != current_file)
8104 {
8105 current_file = line_info->dw_file_num;
8106 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
8107 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
8108 }
8109
8110 /* Emit debug info for the current line number, choosing the encoding
8111 that uses the least amount of space. */
8112 if (line_info->dw_line_num != current_line)
8113 {
8114 line_offset = line_info->dw_line_num - current_line;
8115 line_delta = line_offset - DWARF_LINE_BASE;
8116 current_line = line_info->dw_line_num;
8117 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
8118 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
8119 "line %lu", current_line);
8120 else
8121 {
8122 dw2_asm_output_data (1, DW_LNS_advance_line,
8123 "advance to line %lu", current_line);
8124 dw2_asm_output_data_sleb128 (line_offset, NULL);
8125 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8126 }
8127 }
8128 else
8129 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8130
8131#if 0
8132 cont:
8133#endif
8134
8135 lt_index++;
8136
8137 /* If we're done with a function, end its sequence. */
8138 if (lt_index == separate_line_info_table_in_use
8139 || separate_line_info_table[lt_index].function != function)
8140 {
8141 current_file = 1;
8142 current_line = 1;
8143
8144 /* Emit debug info for the address of the end of the function. */
8145 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
8146 if (0)
8147 {
8148 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8149 "DW_LNS_fixed_advance_pc");
8150 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
8151 }
8152 else
8153 {
8154 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8155 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8156 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8157 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8158 }
8159
8160 /* Output the marker for the end of this sequence. */
8161 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
8162 dw2_asm_output_data_uleb128 (1, NULL);
8163 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
8164 }
8165 }
8166
8167 /* Output the marker for the end of the line number info. */
8168 ASM_OUTPUT_LABEL (asm_out_file, l2);
8169}
8170
8171/* Given a pointer to a tree node for some base type, return a pointer to
8172 a DIE that describes the given type.
8173
8174 This routine must only be called for GCC type nodes that correspond to
8175 Dwarf base (fundamental) types. */
8176
8177static dw_die_ref
8178base_type_die (tree type)
8179{
8180 dw_die_ref base_type_result;
8181 enum dwarf_type encoding;
8182
8183 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
8184 return 0;
8185
8186 switch (TREE_CODE (type))
8187 {
8188 case INTEGER_TYPE:
8189 if (TYPE_STRING_FLAG (type))
8190 {
8191 if (TYPE_UNSIGNED (type))
8192 encoding = DW_ATE_unsigned_char;
8193 else
8194 encoding = DW_ATE_signed_char;
8195 }
8196 else if (TYPE_UNSIGNED (type))
8197 encoding = DW_ATE_unsigned;
8198 else
8199 encoding = DW_ATE_signed;
8200 break;
8201
8202 case REAL_TYPE:
8203 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
8204 encoding = DW_ATE_decimal_float;
8205 else
8206 encoding = DW_ATE_float;
8207 break;
8208
8209 /* Dwarf2 doesn't know anything about complex ints, so use
8210 a user defined type for it. */
8211 case COMPLEX_TYPE:
8212 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
8213 encoding = DW_ATE_complex_float;
8214 else
8215 encoding = DW_ATE_lo_user;
8216 break;
8217
8218 case BOOLEAN_TYPE:
8219 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
8220 encoding = DW_ATE_boolean;
8221 break;
8222
8223 default:
8224 /* No other TREE_CODEs are Dwarf fundamental types. */
8225 gcc_unreachable ();
8226 }
8227
8228 base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
8229
8230 /* This probably indicates a bug. */
8231 if (! TYPE_NAME (type))
8232 add_name_attribute (base_type_result, "__unknown__");
8233
8234 add_AT_unsigned (base_type_result, DW_AT_byte_size,
8235 int_size_in_bytes (type));
8236 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
8237
8238 return base_type_result;
8239}
8240
8241/* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
8242 the Dwarf "root" type for the given input type. The Dwarf "root" type of
8243 a given type is generally the same as the given type, except that if the
8244 given type is a pointer or reference type, then the root type of the given
8245 type is the root type of the "basis" type for the pointer or reference
8246 type. (This definition of the "root" type is recursive.) Also, the root
8247 type of a `const' qualified type or a `volatile' qualified type is the
8248 root type of the given type without the qualifiers. */
8249
8250static tree
8251root_type (tree type)
8252{
8253 if (TREE_CODE (type) == ERROR_MARK)
8254 return error_mark_node;
8255
8256 switch (TREE_CODE (type))
8257 {
8258 case ERROR_MARK:
8259 return error_mark_node;
8260
8261 case POINTER_TYPE:
8262 case REFERENCE_TYPE:
8263 return type_main_variant (root_type (TREE_TYPE (type)));
8264
8265 default:
8266 return type_main_variant (type);
8267 }
8268}
8269
8270/* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
8271 given input type is a Dwarf "fundamental" type. Otherwise return null. */
8272
8273static inline int
8274is_base_type (tree type)
8275{
8276 switch (TREE_CODE (type))
8277 {
8278 case ERROR_MARK:
8279 case VOID_TYPE:
8280 case INTEGER_TYPE:
8281 case REAL_TYPE:
8282 case COMPLEX_TYPE:
8283 case BOOLEAN_TYPE:
8284 return 1;
8285
8286 case ARRAY_TYPE:
8287 case RECORD_TYPE:
8288 case UNION_TYPE:
8289 case QUAL_UNION_TYPE:
8290 case ENUMERAL_TYPE:
8291 case FUNCTION_TYPE:
8292 case METHOD_TYPE:
8293 case POINTER_TYPE:
8294 case REFERENCE_TYPE:
8295 case OFFSET_TYPE:
8296 case LANG_TYPE:
8297 case VECTOR_TYPE:
8298 return 0;
8299
8300 default:
8301 gcc_unreachable ();
8302 }
8303
8304 return 0;
8305}
8306
8307/* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
8308 node, return the size in bits for the type if it is a constant, or else
8309 return the alignment for the type if the type's size is not constant, or
8310 else return BITS_PER_WORD if the type actually turns out to be an
8311 ERROR_MARK node. */
8312
8313static inline unsigned HOST_WIDE_INT
8314simple_type_size_in_bits (tree type)
8315{
8316 if (TREE_CODE (type) == ERROR_MARK)
8317 return BITS_PER_WORD;
8318 else if (TYPE_SIZE (type) == NULL_TREE)
8319 return 0;
8320 else if (host_integerp (TYPE_SIZE (type), 1))
8321 return tree_low_cst (TYPE_SIZE (type), 1);
8322 else
8323 return TYPE_ALIGN (type);
8324}
8325
8326/* Return true if the debug information for the given type should be
8327 emitted as a subrange type. */
8328
8329static inline bool
8330is_subrange_type (tree type)
8331{
8332 tree subtype = TREE_TYPE (type);
8333
8334 /* Subrange types are identified by the fact that they are integer
8335 types, and that they have a subtype which is either an integer type
8336 or an enumeral type. */
8337
8338 if (TREE_CODE (type) != INTEGER_TYPE
8339 || subtype == NULL_TREE)
8340 return false;
8341
8342 if (TREE_CODE (subtype) != INTEGER_TYPE
8343 && TREE_CODE (subtype) != ENUMERAL_TYPE)
8344 return false;
8345
8346 if (TREE_CODE (type) == TREE_CODE (subtype)
8347 && int_size_in_bytes (type) == int_size_in_bytes (subtype)
8348 && TYPE_MIN_VALUE (type) != NULL
8349 && TYPE_MIN_VALUE (subtype) != NULL
8350 && tree_int_cst_equal (TYPE_MIN_VALUE (type), TYPE_MIN_VALUE (subtype))
8351 && TYPE_MAX_VALUE (type) != NULL
8352 && TYPE_MAX_VALUE (subtype) != NULL
8353 && tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype)))
8354 {
8355 /* The type and its subtype have the same representation. If in
8356 addition the two types also have the same name, then the given
8357 type is not a subrange type, but rather a plain base type. */
8358 /* FIXME: brobecker/2004-03-22:
8359 Sizetype INTEGER_CSTs nodes are canonicalized. It should
8360 therefore be sufficient to check the TYPE_SIZE node pointers
8361 rather than checking the actual size. Unfortunately, we have
8362 found some cases, such as in the Ada "integer" type, where
8363 this is not the case. Until this problem is solved, we need to
8364 keep checking the actual size. */
8365 tree type_name = TYPE_NAME (type);
8366 tree subtype_name = TYPE_NAME (subtype);
8367
8368 if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL)
8369 type_name = DECL_NAME (type_name);
8370
8371 if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL)
8372 subtype_name = DECL_NAME (subtype_name);
8373
8374 if (type_name == subtype_name)
8375 return false;
8376 }
8377
8378 return true;
8379}
8380
8381/* Given a pointer to a tree node for a subrange type, return a pointer
8382 to a DIE that describes the given type. */
8383
8384static dw_die_ref
8385subrange_type_die (tree type, dw_die_ref context_die)
8386{
8387 dw_die_ref subrange_die;
8388 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
8389
8390 if (context_die == NULL)
8391 context_die = comp_unit_die;
8392
8393 subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
8394
8395 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
8396 {
8397 /* The size of the subrange type and its base type do not match,
8398 so we need to generate a size attribute for the subrange type. */
8399 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
8400 }
8401
8402 if (TYPE_MIN_VALUE (type) != NULL)
8403 add_bound_info (subrange_die, DW_AT_lower_bound,
8404 TYPE_MIN_VALUE (type));
8405 if (TYPE_MAX_VALUE (type) != NULL)
8406 add_bound_info (subrange_die, DW_AT_upper_bound,
8407 TYPE_MAX_VALUE (type));
8408
8409 return subrange_die;
8410}
8411
8412/* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
8413 entry that chains various modifiers in front of the given type. */
8414
8415static dw_die_ref
8416modified_type_die (tree type, int is_const_type, int is_volatile_type,
8417 dw_die_ref context_die)
8418{
8419 enum tree_code code = TREE_CODE (type);
8420 dw_die_ref mod_type_die;
8421 dw_die_ref sub_die = NULL;
8422 tree item_type = NULL;
8423 tree qualified_type;
8424 tree name;
8425
8426 if (code == ERROR_MARK)
8427 return NULL;
8428
8429 /* See if we already have the appropriately qualified variant of
8430 this type. */
8431 qualified_type
8432 = get_qualified_type (type,
8433 ((is_const_type ? TYPE_QUAL_CONST : 0)
8434 | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
8435
8436 /* If we do, then we can just use its DIE, if it exists. */
8437 if (qualified_type)
8438 {
8439 mod_type_die = lookup_type_die (qualified_type);
8440 if (mod_type_die)
8441 return mod_type_die;
8442 }
8443
8444 name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
8445
8446 /* Handle C typedef types. */
8447 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name))
8448 {
8449 tree dtype = TREE_TYPE (name);
8450
8451 if (qualified_type == dtype)
8452 {
8453 /* For a named type, use the typedef. */
8454 gen_type_die (qualified_type, context_die);
8455 return lookup_type_die (qualified_type);
8456 }
8457 else if (is_const_type < TYPE_READONLY (dtype)
8458 || is_volatile_type < TYPE_VOLATILE (dtype)
8459 || (is_const_type <= TYPE_READONLY (dtype)
8460 && is_volatile_type <= TYPE_VOLATILE (dtype)
8461 && DECL_ORIGINAL_TYPE (name) != type))
8462 /* cv-unqualified version of named type. Just use the unnamed
8463 type to which it refers. */
8464 return modified_type_die (DECL_ORIGINAL_TYPE (name),
8465 is_const_type, is_volatile_type,
8466 context_die);
8467 /* Else cv-qualified version of named type; fall through. */
8468 }
8469
8470 if (is_const_type)
8471 {
8472 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
8473 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
8474 }
8475 else if (is_volatile_type)
8476 {
8477 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
8478 sub_die = modified_type_die (type, 0, 0, context_die);
8479 }
8480 else if (code == POINTER_TYPE)
8481 {
8482 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
8483 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8484 simple_type_size_in_bits (type) / BITS_PER_UNIT);
8485 item_type = TREE_TYPE (type);
8486 }
8487 else if (code == REFERENCE_TYPE)
8488 {
8489 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
8490 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8491 simple_type_size_in_bits (type) / BITS_PER_UNIT);
8492 item_type = TREE_TYPE (type);
8493 }
8494 else if (is_subrange_type (type))
8495 {
8496 mod_type_die = subrange_type_die (type, context_die);
8497 item_type = TREE_TYPE (type);
8498 }
8499 else if (is_base_type (type))
8500 mod_type_die = base_type_die (type);
8501 else
8502 {
8503 gen_type_die (type, context_die);
8504
8505 /* We have to get the type_main_variant here (and pass that to the
8506 `lookup_type_die' routine) because the ..._TYPE node we have
8507 might simply be a *copy* of some original type node (where the
8508 copy was created to help us keep track of typedef names) and
8509 that copy might have a different TYPE_UID from the original
8510 ..._TYPE node. */
8511 if (TREE_CODE (type) != VECTOR_TYPE)
8512 return lookup_type_die (type_main_variant (type));
8513 else
8514 /* Vectors have the debugging information in the type,
8515 not the main variant. */
8516 return lookup_type_die (type);
8517 }
8518
8519 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
8520 don't output a DW_TAG_typedef, since there isn't one in the
8521 user's program; just attach a DW_AT_name to the type. */
8522 if (name
8523 && (TREE_CODE (name) != TYPE_DECL || TREE_TYPE (name) == qualified_type))
8524 {
8525 if (TREE_CODE (name) == TYPE_DECL)
8526 /* Could just call add_name_and_src_coords_attributes here,
8527 but since this is a builtin type it doesn't have any
8528 useful source coordinates anyway. */
8529 name = DECL_NAME (name);
8530 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
8531 }
8532
8533 if (qualified_type)
8534 equate_type_number_to_die (qualified_type, mod_type_die);
8535
8536 if (item_type)
8537 /* We must do this after the equate_type_number_to_die call, in case
8538 this is a recursive type. This ensures that the modified_type_die
8539 recursion will terminate even if the type is recursive. Recursive
8540 types are possible in Ada. */
8541 sub_die = modified_type_die (item_type,
8542 TYPE_READONLY (item_type),
8543 TYPE_VOLATILE (item_type),
8544 context_die);
8545
8546 if (sub_die != NULL)
8547 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
8548
8549 return mod_type_die;
8550}
8551
8552/* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
8553 an enumerated type. */
8554
8555static inline int
8556type_is_enum (tree type)
8557{
8558 return TREE_CODE (type) == ENUMERAL_TYPE;
8559}
8560
8561/* Return the DBX register number described by a given RTL node. */
8562
8563static unsigned int
8564dbx_reg_number (rtx rtl)
8565{
8566 unsigned regno = REGNO (rtl);
8567
8568 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
8569
8570#ifdef LEAF_REG_REMAP
8571 if (current_function_uses_only_leaf_regs)
8572 {
8573 int leaf_reg = LEAF_REG_REMAP (regno);
8574 if (leaf_reg != -1)
8575 regno = (unsigned) leaf_reg;
8576 }
8577#endif
8578
8579 return DBX_REGISTER_NUMBER (regno);
8580}
8581
8582/* Optionally add a DW_OP_piece term to a location description expression.
8583 DW_OP_piece is only added if the location description expression already
8584 doesn't end with DW_OP_piece. */
8585
8586static void
8587add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
8588{
8589 dw_loc_descr_ref loc;
8590
8591 if (*list_head != NULL)
8592 {
8593 /* Find the end of the chain. */
8594 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
8595 ;
8596
8597 if (loc->dw_loc_opc != DW_OP_piece)
8598 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
8599 }
8600}
8601
8602/* Return a location descriptor that designates a machine register or
8603 zero if there is none. */
8604
8605static dw_loc_descr_ref
8606reg_loc_descriptor (rtx rtl)
8607{
8608 rtx regs;
8609
8610 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
8611 return 0;
8612
8613 regs = targetm.dwarf_register_span (rtl);
8614
8615 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
8616 return multiple_reg_loc_descriptor (rtl, regs);
8617 else
8618 return one_reg_loc_descriptor (dbx_reg_number (rtl));
8619}
8620
8621/* Return a location descriptor that designates a machine register for
8622 a given hard register number. */
8623
8624static dw_loc_descr_ref
8625one_reg_loc_descriptor (unsigned int regno)
8626{
8627 if (regno <= 31)
8628 return new_loc_descr (DW_OP_reg0 + regno, 0, 0);
8629 else
8630 return new_loc_descr (DW_OP_regx, regno, 0);
8631}
8632
8633/* Given an RTL of a register, return a location descriptor that
8634 designates a value that spans more than one register. */
8635
8636static dw_loc_descr_ref
8637multiple_reg_loc_descriptor (rtx rtl, rtx regs)
8638{
8639 int nregs, size, i;
8640 unsigned reg;
8641 dw_loc_descr_ref loc_result = NULL;
8642
8643 reg = REGNO (rtl);
8644#ifdef LEAF_REG_REMAP
8645 if (current_function_uses_only_leaf_regs)
8646 {
8647 int leaf_reg = LEAF_REG_REMAP (reg);
8648 if (leaf_reg != -1)
8649 reg = (unsigned) leaf_reg;
8650 }
8651#endif
8652 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
8653 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
8654
8655 /* Simple, contiguous registers. */
8656 if (regs == NULL_RTX)
8657 {
8658 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
8659
8660 loc_result = NULL;
8661 while (nregs--)
8662 {
8663 dw_loc_descr_ref t;
8664
8665 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg));
8666 add_loc_descr (&loc_result, t);
8667 add_loc_descr_op_piece (&loc_result, size);
8668 ++reg;
8669 }
8670 return loc_result;
8671 }
8672
8673 /* Now onto stupid register sets in non contiguous locations. */
8674
8675 gcc_assert (GET_CODE (regs) == PARALLEL);
8676
8677 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8678 loc_result = NULL;
8679
8680 for (i = 0; i < XVECLEN (regs, 0); ++i)
8681 {
8682 dw_loc_descr_ref t;
8683
8684 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)));
8685 add_loc_descr (&loc_result, t);
8686 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8687 add_loc_descr_op_piece (&loc_result, size);
8688 }
8689 return loc_result;
8690}
8691
8692/* Return a location descriptor that designates a constant. */
8693
8694static dw_loc_descr_ref
8695int_loc_descriptor (HOST_WIDE_INT i)
8696{
8697 enum dwarf_location_atom op;
8698
8699 /* Pick the smallest representation of a constant, rather than just
8700 defaulting to the LEB encoding. */
8701 if (i >= 0)
8702 {
8703 if (i <= 31)
8704 op = DW_OP_lit0 + i;
8705 else if (i <= 0xff)
8706 op = DW_OP_const1u;
8707 else if (i <= 0xffff)
8708 op = DW_OP_const2u;
8709 else if (HOST_BITS_PER_WIDE_INT == 32
8710 || i <= 0xffffffff)
8711 op = DW_OP_const4u;
8712 else
8713 op = DW_OP_constu;
8714 }
8715 else
8716 {
8717 if (i >= -0x80)
8718 op = DW_OP_const1s;
8719 else if (i >= -0x8000)
8720 op = DW_OP_const2s;
8721 else if (HOST_BITS_PER_WIDE_INT == 32
8722 || i >= -0x80000000)
8723 op = DW_OP_const4s;
8724 else
8725 op = DW_OP_consts;
8726 }
8727
8728 return new_loc_descr (op, i, 0);
8729}
8730
8731/* Return a location descriptor that designates a base+offset location. */
8732
8733static dw_loc_descr_ref
8734based_loc_descr (rtx reg, HOST_WIDE_INT offset)
8735{
8736 unsigned int regno;
8737
8738 /* We only use "frame base" when we're sure we're talking about the
8739 post-prologue local stack frame. We do this by *not* running
8740 register elimination until this point, and recognizing the special
8741 argument pointer and soft frame pointer rtx's. */
8742 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
8743 {
8744 rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
8745
8746 if (elim != reg)
8747 {
8748 if (GET_CODE (elim) == PLUS)
8749 {
8750 offset += INTVAL (XEXP (elim, 1));
8751 elim = XEXP (elim, 0);
8752 }
8753 gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
8754 : stack_pointer_rtx));
8755 offset += frame_pointer_fb_offset;
8756
8757 return new_loc_descr (DW_OP_fbreg, offset, 0);
8758 }
8759 }
8760
8761 regno = dbx_reg_number (reg);
8762 if (regno <= 31)
8763 return new_loc_descr (DW_OP_breg0 + regno, offset, 0);
8764 else
8765 return new_loc_descr (DW_OP_bregx, regno, offset);
8766}
8767
8768/* Return true if this RTL expression describes a base+offset calculation. */
8769
8770static inline int
8771is_based_loc (rtx rtl)
8772{
8773 return (GET_CODE (rtl) == PLUS
8774 && ((REG_P (XEXP (rtl, 0))
8775 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
8776 && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
8777}
8778
8779/* The following routine converts the RTL for a variable or parameter
8780 (resident in memory) into an equivalent Dwarf representation of a
8781 mechanism for getting the address of that same variable onto the top of a
8782 hypothetical "address evaluation" stack.
8783
8784 When creating memory location descriptors, we are effectively transforming
8785 the RTL for a memory-resident object into its Dwarf postfix expression
8786 equivalent. This routine recursively descends an RTL tree, turning
8787 it into Dwarf postfix code as it goes.
8788
8789 MODE is the mode of the memory reference, needed to handle some
8790 autoincrement addressing modes.
8791
8792 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
8793 location list for RTL.
8794
8795 Return 0 if we can't represent the location. */
8796
8797static dw_loc_descr_ref
8798mem_loc_descriptor (rtx rtl, enum machine_mode mode)
8799{
8800 dw_loc_descr_ref mem_loc_result = NULL;
8801 enum dwarf_location_atom op;
8802
8803 /* Note that for a dynamically sized array, the location we will generate a
8804 description of here will be the lowest numbered location which is
8805 actually within the array. That's *not* necessarily the same as the
8806 zeroth element of the array. */
8807
8808 rtl = targetm.delegitimize_address (rtl);
8809
8810 switch (GET_CODE (rtl))
8811 {
8812 case POST_INC:
8813 case POST_DEC:
8814 case POST_MODIFY:
8815 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
8816 just fall into the SUBREG code. */
8817
8818 /* ... fall through ... */
8819
8820 case SUBREG:
8821 /* The case of a subreg may arise when we have a local (register)
8822 variable or a formal (register) parameter which doesn't quite fill
8823 up an entire register. For now, just assume that it is
8824 legitimate to make the Dwarf info refer to the whole register which
8825 contains the given subreg. */
8826 rtl = XEXP (rtl, 0);
8827
8828 /* ... fall through ... */
8829
8830 case REG:
8831 /* Whenever a register number forms a part of the description of the
8832 method for calculating the (dynamic) address of a memory resident
8833 object, DWARF rules require the register number be referred to as
8834 a "base register". This distinction is not based in any way upon
8835 what category of register the hardware believes the given register
8836 belongs to. This is strictly DWARF terminology we're dealing with
8837 here. Note that in cases where the location of a memory-resident
8838 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
8839 OP_CONST (0)) the actual DWARF location descriptor that we generate
8840 may just be OP_BASEREG (basereg). This may look deceptively like
8841 the object in question was allocated to a register (rather than in
8842 memory) so DWARF consumers need to be aware of the subtle
8843 distinction between OP_REG and OP_BASEREG. */
8844 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
8845 mem_loc_result = based_loc_descr (rtl, 0);
8846 break;
8847
8848 case MEM:
8849 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
8850 if (mem_loc_result != 0)
8851 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
8852 break;
8853
8854 case LO_SUM:
8855 rtl = XEXP (rtl, 1);
8856
8857 /* ... fall through ... */
8858
8859 case LABEL_REF:
8860 /* Some ports can transform a symbol ref into a label ref, because
8861 the symbol ref is too far away and has to be dumped into a constant
8862 pool. */
8863 case CONST:
8864 case SYMBOL_REF:
8865 /* Alternatively, the symbol in the constant pool might be referenced
8866 by a different symbol. */
8867 if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
8868 {
8869 bool marked;
8870 rtx tmp = get_pool_constant_mark (rtl, &marked);
8871
8872 if (GET_CODE (tmp) == SYMBOL_REF)
8873 {
8874 rtl = tmp;
8875 if (CONSTANT_POOL_ADDRESS_P (tmp))
8876 get_pool_constant_mark (tmp, &marked);
8877 else
8878 marked = true;
8879 }
8880
8881 /* If all references to this pool constant were optimized away,
8882 it was not output and thus we can't represent it.
8883 FIXME: might try to use DW_OP_const_value here, though
8884 DW_OP_piece complicates it. */
8885 if (!marked)
8886 return 0;
8887 }
8888
8889 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
8890 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
8891 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
8892 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
8893 break;
8894
8895 case PRE_MODIFY:
8896 /* Extract the PLUS expression nested inside and fall into
8897 PLUS code below. */
8898 rtl = XEXP (rtl, 1);
8899 goto plus;
8900
8901 case PRE_INC:
8902 case PRE_DEC:
8903 /* Turn these into a PLUS expression and fall into the PLUS code
8904 below. */
8905 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
8906 GEN_INT (GET_CODE (rtl) == PRE_INC
8907 ? GET_MODE_UNIT_SIZE (mode)
8908 : -GET_MODE_UNIT_SIZE (mode)));
8909
8910 /* ... fall through ... */
8911
8912 case PLUS:
8913 plus:
8914 if (is_based_loc (rtl))
8915 mem_loc_result = based_loc_descr (XEXP (rtl, 0),
8916 INTVAL (XEXP (rtl, 1)));
8917 else
8918 {
8919 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode);
8920 if (mem_loc_result == 0)
8921 break;
8922
8923 if (GET_CODE (XEXP (rtl, 1)) == CONST_INT
8924 && INTVAL (XEXP (rtl, 1)) >= 0)
8925 add_loc_descr (&mem_loc_result,
8926 new_loc_descr (DW_OP_plus_uconst,
8927 INTVAL (XEXP (rtl, 1)), 0));
8928 else
8929 {
8930 add_loc_descr (&mem_loc_result,
8931 mem_loc_descriptor (XEXP (rtl, 1), mode));
8932 add_loc_descr (&mem_loc_result,
8933 new_loc_descr (DW_OP_plus, 0, 0));
8934 }
8935 }
8936 break;
8937
8938 /* If a pseudo-reg is optimized away, it is possible for it to
8939 be replaced with a MEM containing a multiply or shift. */
8940 case MULT:
8941 op = DW_OP_mul;
8942 goto do_binop;
8943
8944 case ASHIFT:
8945 op = DW_OP_shl;
8946 goto do_binop;
8947
8948 case ASHIFTRT:
8949 op = DW_OP_shra;
8950 goto do_binop;
8951
8952 case LSHIFTRT:
8953 op = DW_OP_shr;
8954 goto do_binop;
8955
8956 do_binop:
8957 {
8958 dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode);
8959 dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode);
8960
8961 if (op0 == 0 || op1 == 0)
8962 break;
8963
8964 mem_loc_result = op0;
8965 add_loc_descr (&mem_loc_result, op1);
8966 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
8967 break;
8968 }
8969
8970 case CONST_INT:
8971 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
8972 break;
8973
8974 default:
8975 gcc_unreachable ();
8976 }
8977
8978 return mem_loc_result;
8979}
8980
8981/* Return a descriptor that describes the concatenation of two locations.
8982 This is typically a complex variable. */
8983
8984static dw_loc_descr_ref
8985concat_loc_descriptor (rtx x0, rtx x1)
8986{
8987 dw_loc_descr_ref cc_loc_result = NULL;
8988 dw_loc_descr_ref x0_ref = loc_descriptor (x0);
8989 dw_loc_descr_ref x1_ref = loc_descriptor (x1);
8990
8991 if (x0_ref == 0 || x1_ref == 0)
8992 return 0;
8993
8994 cc_loc_result = x0_ref;
8995 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
8996
8997 add_loc_descr (&cc_loc_result, x1_ref);
8998 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
8999
9000 return cc_loc_result;
9001}
9002
9003/* Output a proper Dwarf location descriptor for a variable or parameter
9004 which is either allocated in a register or in a memory location. For a
9005 register, we just generate an OP_REG and the register number. For a
9006 memory location we provide a Dwarf postfix expression describing how to
9007 generate the (dynamic) address of the object onto the address stack.
9008
9009 If we don't know how to describe it, return 0. */
9010
9011static dw_loc_descr_ref
9012loc_descriptor (rtx rtl)
9013{
9014 dw_loc_descr_ref loc_result = NULL;
9015
9016 switch (GET_CODE (rtl))
9017 {
9018 case SUBREG:
9019 /* The case of a subreg may arise when we have a local (register)
9020 variable or a formal (register) parameter which doesn't quite fill
9021 up an entire register. For now, just assume that it is
9022 legitimate to make the Dwarf info refer to the whole register which
9023 contains the given subreg. */
9024 rtl = SUBREG_REG (rtl);
9025
9026 /* ... fall through ... */
9027
9028 case REG:
9029 loc_result = reg_loc_descriptor (rtl);
9030 break;
9031
9032 case MEM:
9033 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
9034 break;
9035
9036 case CONCAT:
9037 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
9038 break;
9039
9040 case VAR_LOCATION:
9041 /* Single part. */
9042 if (GET_CODE (XEXP (rtl, 1)) != PARALLEL)
9043 {
9044 loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0));
9045 break;
9046 }
9047
9048 rtl = XEXP (rtl, 1);
9049 /* FALLTHRU */
9050
9051 case PARALLEL:
9052 {
9053 rtvec par_elems = XVEC (rtl, 0);
9054 int num_elem = GET_NUM_ELEM (par_elems);
9055 enum machine_mode mode;
9056 int i;
9057
9058 /* Create the first one, so we have something to add to. */
9059 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0));
9060 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
9061 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
9062 for (i = 1; i < num_elem; i++)
9063 {
9064 dw_loc_descr_ref temp;
9065
9066 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0));
9067 add_loc_descr (&loc_result, temp);
9068 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
9069 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
9070 }
9071 }
9072 break;
9073
9074 default:
9075 gcc_unreachable ();
9076 }
9077
9078 return loc_result;
9079}
9080
9081/* Similar, but generate the descriptor from trees instead of rtl. This comes
9082 up particularly with variable length arrays. WANT_ADDRESS is 2 if this is
9083 a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a
9084 top-level invocation, and we require the address of LOC; is 0 if we require
9085 the value of LOC. */
9086
9087static dw_loc_descr_ref
9088loc_descriptor_from_tree_1 (tree loc, int want_address)
9089{
9090 dw_loc_descr_ref ret, ret1;
9091 int have_address = 0;
9092 enum dwarf_location_atom op;
9093
9094 /* ??? Most of the time we do not take proper care for sign/zero
9095 extending the values properly. Hopefully this won't be a real
9096 problem... */
9097
9098 switch (TREE_CODE (loc))
9099 {
9100 case ERROR_MARK:
9101 return 0;
9102
9103 case PLACEHOLDER_EXPR:
9104 /* This case involves extracting fields from an object to determine the
9105 position of other fields. We don't try to encode this here. The
9106 only user of this is Ada, which encodes the needed information using
9107 the names of types. */
9108 return 0;
9109
9110 case CALL_EXPR:
9111 return 0;
9112
9113 case PREINCREMENT_EXPR:
9114 case PREDECREMENT_EXPR:
9115 case POSTINCREMENT_EXPR:
9116 case POSTDECREMENT_EXPR:
9117 /* There are no opcodes for these operations. */
9118 return 0;
9119
9120 case ADDR_EXPR:
9121 /* If we already want an address, there's nothing we can do. */
9122 if (want_address)
9123 return 0;
9124
9125 /* Otherwise, process the argument and look for the address. */
9126 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1);
9127
9128 case VAR_DECL:
9129 if (DECL_THREAD_LOCAL_P (loc))
9130 {
9131 rtx rtl;
9132
9133 /* If this is not defined, we have no way to emit the data. */
9134 if (!targetm.asm_out.output_dwarf_dtprel)
9135 return 0;
9136
9137 /* The way DW_OP_GNU_push_tls_address is specified, we can only
9138 look up addresses of objects in the current module. */
9139 if (DECL_EXTERNAL (loc))
9140 return 0;
9141
9142 rtl = rtl_for_decl_location (loc);
9143 if (rtl == NULL_RTX)
9144 return 0;
9145
9146 if (!MEM_P (rtl))
9147 return 0;
9148 rtl = XEXP (rtl, 0);
9149 if (! CONSTANT_P (rtl))
9150 return 0;
9151
9152 ret = new_loc_descr (INTERNAL_DW_OP_tls_addr, 0, 0);
9153 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9154 ret->dw_loc_oprnd1.v.val_addr = rtl;
9155
9156 ret1 = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
9157 add_loc_descr (&ret, ret1);
9158
9159 have_address = 1;
9160 break;
9161 }
9162 /* FALLTHRU */
9163
9164 case PARM_DECL:
9165 if (DECL_HAS_VALUE_EXPR_P (loc))
9166 return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc),
9167 want_address);
9168 /* FALLTHRU */
9169
9170 case RESULT_DECL:
9171 case FUNCTION_DECL:
9172 {
9173 rtx rtl = rtl_for_decl_location (loc);
9174
9175 if (rtl == NULL_RTX)
9176 return 0;
9177 else if (GET_CODE (rtl) == CONST_INT)
9178 {
9179 HOST_WIDE_INT val = INTVAL (rtl);
9180 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
9181 val &= GET_MODE_MASK (DECL_MODE (loc));
9182 ret = int_loc_descriptor (val);
9183 }
9184 else if (GET_CODE (rtl) == CONST_STRING)
9185 return 0;
9186 else if (CONSTANT_P (rtl))
9187 {
9188 ret = new_loc_descr (DW_OP_addr, 0, 0);
9189 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9190 ret->dw_loc_oprnd1.v.val_addr = rtl;
9191 }
9192 else
9193 {
9194 enum machine_mode mode;
9195
9196 /* Certain constructs can only be represented at top-level. */
9197 if (want_address == 2)
9198 return loc_descriptor (rtl);
9199
9200 mode = GET_MODE (rtl);
9201 if (MEM_P (rtl))
9202 {
9203 rtl = XEXP (rtl, 0);
9204 have_address = 1;
9205 }
9206 ret = mem_loc_descriptor (rtl, mode);
9207 }
9208 }
9209 break;
9210
9211 case INDIRECT_REF:
9212 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9213 have_address = 1;
9214 break;
9215
9216 case COMPOUND_EXPR:
9217 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address);
9218
9219 case NOP_EXPR:
9220 case CONVERT_EXPR:
9221 case NON_LVALUE_EXPR:
9222 case VIEW_CONVERT_EXPR:
9223 case SAVE_EXPR:
9224 case MODIFY_EXPR:
9225 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), want_address);
9226
9227 case COMPONENT_REF:
9228 case BIT_FIELD_REF:
9229 case ARRAY_REF:
9230 case ARRAY_RANGE_REF:
9231 {
9232 tree obj, offset;
9233 HOST_WIDE_INT bitsize, bitpos, bytepos;
9234 enum machine_mode mode;
9235 int volatilep;
9236 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
9237
9238 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
9239 &unsignedp, &volatilep, false);
9240
9241 if (obj == loc)
9242 return 0;
9243
9244 ret = loc_descriptor_from_tree_1 (obj, 1);
9245 if (ret == 0
9246 || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
9247 return 0;
9248
9249 if (offset != NULL_TREE)
9250 {
9251 /* Variable offset. */
9252 add_loc_descr (&ret, loc_descriptor_from_tree_1 (offset, 0));
9253 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9254 }
9255
9256 bytepos = bitpos / BITS_PER_UNIT;
9257 if (bytepos > 0)
9258 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
9259 else if (bytepos < 0)
9260 {
9261 add_loc_descr (&ret, int_loc_descriptor (bytepos));
9262 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9263 }
9264
9265 have_address = 1;
9266 break;
9267 }
9268
9269 case INTEGER_CST:
9270 if (host_integerp (loc, 0))
9271 ret = int_loc_descriptor (tree_low_cst (loc, 0));
9272 else
9273 return 0;
9274 break;
9275
9276 case CONSTRUCTOR:
9277 {
9278 /* Get an RTL for this, if something has been emitted. */
9279 rtx rtl = lookup_constant_def (loc);
9280 enum machine_mode mode;
9281
9282 if (!rtl || !MEM_P (rtl))
9283 return 0;
9284 mode = GET_MODE (rtl);
9285 rtl = XEXP (rtl, 0);
9286 ret = mem_loc_descriptor (rtl, mode);
9287 have_address = 1;
9288 break;
9289 }
9290
9291 case TRUTH_AND_EXPR:
9292 case TRUTH_ANDIF_EXPR:
9293 case BIT_AND_EXPR:
9294 op = DW_OP_and;
9295 goto do_binop;
9296
9297 case TRUTH_XOR_EXPR:
9298 case BIT_XOR_EXPR:
9299 op = DW_OP_xor;
9300 goto do_binop;
9301
9302 case TRUTH_OR_EXPR:
9303 case TRUTH_ORIF_EXPR:
9304 case BIT_IOR_EXPR:
9305 op = DW_OP_or;
9306 goto do_binop;
9307
9308 case FLOOR_DIV_EXPR:
9309 case CEIL_DIV_EXPR:
9310 case ROUND_DIV_EXPR:
9311 case TRUNC_DIV_EXPR:
9312 op = DW_OP_div;
9313 goto do_binop;
9314
9315 case MINUS_EXPR:
9316 op = DW_OP_minus;
9317 goto do_binop;
9318
9319 case FLOOR_MOD_EXPR:
9320 case CEIL_MOD_EXPR:
9321 case ROUND_MOD_EXPR:
9322 case TRUNC_MOD_EXPR:
9323 op = DW_OP_mod;
9324 goto do_binop;
9325
9326 case MULT_EXPR:
9327 op = DW_OP_mul;
9328 goto do_binop;
9329
9330 case LSHIFT_EXPR:
9331 op = DW_OP_shl;
9332 goto do_binop;
9333
9334 case RSHIFT_EXPR:
9335 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
9336 goto do_binop;
9337
9338 case PLUS_EXPR:
9339 if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
9340 && host_integerp (TREE_OPERAND (loc, 1), 0))
9341 {
9342 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9343 if (ret == 0)
9344 return 0;
9345
9346 add_loc_descr (&ret,
9347 new_loc_descr (DW_OP_plus_uconst,
9348 tree_low_cst (TREE_OPERAND (loc, 1),
9349 0),
9350 0));
9351 break;
9352 }
9353
9354 op = DW_OP_plus;
9355 goto do_binop;
9356
9357 case LE_EXPR:
9358 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9359 return 0;
9360
9361 op = DW_OP_le;
9362 goto do_binop;
9363
9364 case GE_EXPR:
9365 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9366 return 0;
9367
9368 op = DW_OP_ge;
9369 goto do_binop;
9370
9371 case LT_EXPR:
9372 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9373 return 0;
9374
9375 op = DW_OP_lt;
9376 goto do_binop;
9377
9378 case GT_EXPR:
9379 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9380 return 0;
9381
9382 op = DW_OP_gt;
9383 goto do_binop;
9384
9385 case EQ_EXPR:
9386 op = DW_OP_eq;
9387 goto do_binop;
9388
9389 case NE_EXPR:
9390 op = DW_OP_ne;
9391 goto do_binop;
9392
9393 do_binop:
9394 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9395 ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9396 if (ret == 0 || ret1 == 0)
9397 return 0;
9398
9399 add_loc_descr (&ret, ret1);
9400 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9401 break;
9402
9403 case TRUTH_NOT_EXPR:
9404 case BIT_NOT_EXPR:
9405 op = DW_OP_not;
9406 goto do_unop;
9407
9408 case ABS_EXPR:
9409 op = DW_OP_abs;
9410 goto do_unop;
9411
9412 case NEGATE_EXPR:
9413 op = DW_OP_neg;
9414 goto do_unop;
9415
9416 do_unop:
9417 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9418 if (ret == 0)
9419 return 0;
9420
9421 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9422 break;
9423
9424 case MIN_EXPR:
9425 case MAX_EXPR:
9426 {
9427 const enum tree_code code =
9428 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
9429
9430 loc = build3 (COND_EXPR, TREE_TYPE (loc),
9431 build2 (code, integer_type_node,
9432 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
9433 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
9434 }
9435
9436 /* ... fall through ... */
9437
9438 case COND_EXPR:
9439 {
9440 dw_loc_descr_ref lhs
9441 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9442 dw_loc_descr_ref rhs
9443 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0);
9444 dw_loc_descr_ref bra_node, jump_node, tmp;
9445
9446 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9447 if (ret == 0 || lhs == 0 || rhs == 0)
9448 return 0;
9449
9450 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
9451 add_loc_descr (&ret, bra_node);
9452
9453 add_loc_descr (&ret, rhs);
9454 jump_node = new_loc_descr (DW_OP_skip, 0, 0);
9455 add_loc_descr (&ret, jump_node);
9456
9457 add_loc_descr (&ret, lhs);
9458 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9459 bra_node->dw_loc_oprnd1.v.val_loc = lhs;
9460
9461 /* ??? Need a node to point the skip at. Use a nop. */
9462 tmp = new_loc_descr (DW_OP_nop, 0, 0);
9463 add_loc_descr (&ret, tmp);
9464 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9465 jump_node->dw_loc_oprnd1.v.val_loc = tmp;
9466 }
9467 break;
9468
9469 case FIX_TRUNC_EXPR:
9470 case FIX_CEIL_EXPR:
9471 case FIX_FLOOR_EXPR:
9472 case FIX_ROUND_EXPR:
9473 return 0;
9474
9475 default:
9476 /* Leave front-end specific codes as simply unknown. This comes
9477 up, for instance, with the C STMT_EXPR. */
9478 if ((unsigned int) TREE_CODE (loc)
9479 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
9480 return 0;
9481
9482#ifdef ENABLE_CHECKING
9483 /* Otherwise this is a generic code; we should just lists all of
9484 these explicitly. We forgot one. */
9485 gcc_unreachable ();
9486#else
9487 /* In a release build, we want to degrade gracefully: better to
9488 generate incomplete debugging information than to crash. */
9489 return NULL;
9490#endif
9491 }
9492
9493 /* Show if we can't fill the request for an address. */
9494 if (want_address && !have_address)
9495 return 0;
9496
9497 /* If we've got an address and don't want one, dereference. */
9498 if (!want_address && have_address && ret)
9499 {
9500 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
9501
9502 if (size > DWARF2_ADDR_SIZE || size == -1)
9503 return 0;
9504 else if (size == DWARF2_ADDR_SIZE)
9505 op = DW_OP_deref;
9506 else
9507 op = DW_OP_deref_size;
9508
9509 add_loc_descr (&ret, new_loc_descr (op, size, 0));
9510 }
9511
9512 return ret;
9513}
9514
9515static inline dw_loc_descr_ref
9516loc_descriptor_from_tree (tree loc)
9517{
9518 return loc_descriptor_from_tree_1 (loc, 2);
9519}
9520
9521/* Given a value, round it up to the lowest multiple of `boundary'
9522 which is not less than the value itself. */
9523
9524static inline HOST_WIDE_INT
9525ceiling (HOST_WIDE_INT value, unsigned int boundary)
9526{
9527 return (((value + boundary - 1) / boundary) * boundary);
9528}
9529
9530/* Given a pointer to what is assumed to be a FIELD_DECL node, return a
9531 pointer to the declared type for the relevant field variable, or return
9532 `integer_type_node' if the given node turns out to be an
9533 ERROR_MARK node. */
9534
9535static inline tree
9536field_type (tree decl)
9537{
9538 tree type;
9539
9540 if (TREE_CODE (decl) == ERROR_MARK)
9541 return integer_type_node;
9542
9543 type = DECL_BIT_FIELD_TYPE (decl);
9544 if (type == NULL_TREE)
9545 type = TREE_TYPE (decl);
9546
9547 return type;
9548}
9549
9550/* Given a pointer to a tree node, return the alignment in bits for
9551 it, or else return BITS_PER_WORD if the node actually turns out to
9552 be an ERROR_MARK node. */
9553
9554static inline unsigned
9555simple_type_align_in_bits (tree type)
9556{
9557 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
9558}
9559
9560static inline unsigned
9561simple_decl_align_in_bits (tree decl)
9562{
9563 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
9564}
9565
9566/* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
9567 lowest addressed byte of the "containing object" for the given FIELD_DECL,
9568 or return 0 if we are unable to determine what that offset is, either
9569 because the argument turns out to be a pointer to an ERROR_MARK node, or
9570 because the offset is actually variable. (We can't handle the latter case
9571 just yet). */
9572
9573static HOST_WIDE_INT
9574field_byte_offset (tree decl)
9575{
9576 unsigned int type_align_in_bits;
9577 unsigned int decl_align_in_bits;
9578 unsigned HOST_WIDE_INT type_size_in_bits;
9579 HOST_WIDE_INT object_offset_in_bits;
9580 tree type;
9581 tree field_size_tree;
9582 HOST_WIDE_INT bitpos_int;
9583 HOST_WIDE_INT deepest_bitpos;
9584 unsigned HOST_WIDE_INT field_size_in_bits;
9585
9586 if (TREE_CODE (decl) == ERROR_MARK)
9587 return 0;
9588
9589 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
9590
9591 type = field_type (decl);
9592 field_size_tree = DECL_SIZE (decl);
9593
9594 /* The size could be unspecified if there was an error, or for
9595 a flexible array member. */
9596 if (! field_size_tree)
9597 field_size_tree = bitsize_zero_node;
9598
9599 /* We cannot yet cope with fields whose positions are variable, so
9600 for now, when we see such things, we simply return 0. Someday, we may
9601 be able to handle such cases, but it will be damn difficult. */
9602 if (! host_integerp (bit_position (decl), 0))
9603 return 0;
9604
9605 bitpos_int = int_bit_position (decl);
9606
9607 /* If we don't know the size of the field, pretend it's a full word. */
9608 if (host_integerp (field_size_tree, 1))
9609 field_size_in_bits = tree_low_cst (field_size_tree, 1);
9610 else
9611 field_size_in_bits = BITS_PER_WORD;
9612
9613 type_size_in_bits = simple_type_size_in_bits (type);
9614 type_align_in_bits = simple_type_align_in_bits (type);
9615 decl_align_in_bits = simple_decl_align_in_bits (decl);
9616
9617 /* The GCC front-end doesn't make any attempt to keep track of the starting
9618 bit offset (relative to the start of the containing structure type) of the
9619 hypothetical "containing object" for a bit-field. Thus, when computing
9620 the byte offset value for the start of the "containing object" of a
9621 bit-field, we must deduce this information on our own. This can be rather
9622 tricky to do in some cases. For example, handling the following structure
9623 type definition when compiling for an i386/i486 target (which only aligns
9624 long long's to 32-bit boundaries) can be very tricky:
9625
9626 struct S { int field1; long long field2:31; };
9627
9628 Fortunately, there is a simple rule-of-thumb which can be used in such
9629 cases. When compiling for an i386/i486, GCC will allocate 8 bytes for the
9630 structure shown above. It decides to do this based upon one simple rule
9631 for bit-field allocation. GCC allocates each "containing object" for each
9632 bit-field at the first (i.e. lowest addressed) legitimate alignment
9633 boundary (based upon the required minimum alignment for the declared type
9634 of the field) which it can possibly use, subject to the condition that
9635 there is still enough available space remaining in the containing object
9636 (when allocated at the selected point) to fully accommodate all of the
9637 bits of the bit-field itself.
9638
9639 This simple rule makes it obvious why GCC allocates 8 bytes for each
9640 object of the structure type shown above. When looking for a place to
9641 allocate the "containing object" for `field2', the compiler simply tries
9642 to allocate a 64-bit "containing object" at each successive 32-bit
9643 boundary (starting at zero) until it finds a place to allocate that 64-
9644 bit field such that at least 31 contiguous (and previously unallocated)
9645 bits remain within that selected 64 bit field. (As it turns out, for the
9646 example above, the compiler finds it is OK to allocate the "containing
9647 object" 64-bit field at bit-offset zero within the structure type.)
9648
9649 Here we attempt to work backwards from the limited set of facts we're
9650 given, and we try to deduce from those facts, where GCC must have believed
9651 that the containing object started (within the structure type). The value
9652 we deduce is then used (by the callers of this routine) to generate
9653 DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields
9654 and, in the case of DW_AT_location, regular fields as well). */
9655
9656 /* Figure out the bit-distance from the start of the structure to the
9657 "deepest" bit of the bit-field. */
9658 deepest_bitpos = bitpos_int + field_size_in_bits;
9659
9660 /* This is the tricky part. Use some fancy footwork to deduce where the
9661 lowest addressed bit of the containing object must be. */
9662 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9663
9664 /* Round up to type_align by default. This works best for bitfields. */
9665 object_offset_in_bits += type_align_in_bits - 1;
9666 object_offset_in_bits /= type_align_in_bits;
9667 object_offset_in_bits *= type_align_in_bits;
9668
9669 if (object_offset_in_bits > bitpos_int)
9670 {
9671 /* Sigh, the decl must be packed. */
9672 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9673
9674 /* Round up to decl_align instead. */
9675 object_offset_in_bits += decl_align_in_bits - 1;
9676 object_offset_in_bits /= decl_align_in_bits;
9677 object_offset_in_bits *= decl_align_in_bits;
9678 }
9679
9680 return object_offset_in_bits / BITS_PER_UNIT;
9681}
9682
9683/* The following routines define various Dwarf attributes and any data
9684 associated with them. */
9685
9686/* Add a location description attribute value to a DIE.
9687
9688 This emits location attributes suitable for whole variables and
9689 whole parameters. Note that the location attributes for struct fields are
9690 generated by the routine `data_member_location_attribute' below. */
9691
9692static inline void
9693add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
9694 dw_loc_descr_ref descr)
9695{
9696 if (descr != 0)
9697 add_AT_loc (die, attr_kind, descr);
9698}
9699
9700/* Attach the specialized form of location attribute used for data members of
9701 struct and union types. In the special case of a FIELD_DECL node which
9702 represents a bit-field, the "offset" part of this special location
9703 descriptor must indicate the distance in bytes from the lowest-addressed
9704 byte of the containing struct or union type to the lowest-addressed byte of
9705 the "containing object" for the bit-field. (See the `field_byte_offset'
9706 function above).
9707
9708 For any given bit-field, the "containing object" is a hypothetical object
9709 (of some integral or enum type) within which the given bit-field lives. The
9710 type of this hypothetical "containing object" is always the same as the
9711 declared type of the individual bit-field itself (for GCC anyway... the
9712 DWARF spec doesn't actually mandate this). Note that it is the size (in
9713 bytes) of the hypothetical "containing object" which will be given in the
9714 DW_AT_byte_size attribute for this bit-field. (See the
9715 `byte_size_attribute' function below.) It is also used when calculating the
9716 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
9717 function below.) */
9718
9719static void
9720add_data_member_location_attribute (dw_die_ref die, tree decl)
9721{
9722 HOST_WIDE_INT offset;
9723 dw_loc_descr_ref loc_descr = 0;
9724
9725 if (TREE_CODE (decl) == TREE_BINFO)
9726 {
9727 /* We're working on the TAG_inheritance for a base class. */
9728 if (BINFO_VIRTUAL_P (decl) && is_cxx ())
9729 {
9730 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
9731 aren't at a fixed offset from all (sub)objects of the same
9732 type. We need to extract the appropriate offset from our
9733 vtable. The following dwarf expression means
9734
9735 BaseAddr = ObAddr + *((*ObAddr) - Offset)
9736
9737 This is specific to the V3 ABI, of course. */
9738
9739 dw_loc_descr_ref tmp;
9740
9741 /* Make a copy of the object address. */
9742 tmp = new_loc_descr (DW_OP_dup, 0, 0);
9743 add_loc_descr (&loc_descr, tmp);
9744
9745 /* Extract the vtable address. */
9746 tmp = new_loc_descr (DW_OP_deref, 0, 0);
9747 add_loc_descr (&loc_descr, tmp);
9748
9749 /* Calculate the address of the offset. */
9750 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
9751 gcc_assert (offset < 0);
9752
9753 tmp = int_loc_descriptor (-offset);
9754 add_loc_descr (&loc_descr, tmp);
9755 tmp = new_loc_descr (DW_OP_minus, 0, 0);
9756 add_loc_descr (&loc_descr, tmp);
9757
9758 /* Extract the offset. */
9759 tmp = new_loc_descr (DW_OP_deref, 0, 0);
9760 add_loc_descr (&loc_descr, tmp);
9761
9762 /* Add it to the object address. */
9763 tmp = new_loc_descr (DW_OP_plus, 0, 0);
9764 add_loc_descr (&loc_descr, tmp);
9765 }
9766 else
9767 offset = tree_low_cst (BINFO_OFFSET (decl), 0);
9768 }
9769 else
9770 offset = field_byte_offset (decl);
9771
9772 if (! loc_descr)
9773 {
9774 enum dwarf_location_atom op;
9775
9776 /* The DWARF2 standard says that we should assume that the structure
9777 address is already on the stack, so we can specify a structure field
9778 address by using DW_OP_plus_uconst. */
9779
9780#ifdef MIPS_DEBUGGING_INFO
9781 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
9782 operator correctly. It works only if we leave the offset on the
9783 stack. */
9784 op = DW_OP_constu;
9785#else
9786 op = DW_OP_plus_uconst;
9787#endif
9788
9789 loc_descr = new_loc_descr (op, offset, 0);
9790 }
9791
9792 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
9793}
9794
9795/* Writes integer values to dw_vec_const array. */
9796
9797static void
9798insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
9799{
9800 while (size != 0)
9801 {
9802 *dest++ = val & 0xff;
9803 val >>= 8;
9804 --size;
9805 }
9806}
9807
9808/* Reads integers from dw_vec_const array. Inverse of insert_int. */
9809
9810static HOST_WIDE_INT
9811extract_int (const unsigned char *src, unsigned int size)
9812{
9813 HOST_WIDE_INT val = 0;
9814
9815 src += size;
9816 while (size != 0)
9817 {
9818 val <<= 8;
9819 val |= *--src & 0xff;
9820 --size;
9821 }
9822 return val;
9823}
9824
9825/* Writes floating point values to dw_vec_const array. */
9826
9827static void
9828insert_float (rtx rtl, unsigned char *array)
9829{
9830 REAL_VALUE_TYPE rv;
9831 long val[4];
9832 int i;
9833
9834 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
9835 real_to_target (val, &rv, GET_MODE (rtl));
9836
9837 /* real_to_target puts 32-bit pieces in each long. Pack them. */
9838 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
9839 {
9840 insert_int (val[i], 4, array);
9841 array += 4;
9842 }
9843}
9844
9845/* Attach a DW_AT_const_value attribute for a variable or a parameter which
9846 does not have a "location" either in memory or in a register. These
9847 things can arise in GNU C when a constant is passed as an actual parameter
9848 to an inlined function. They can also arise in C++ where declared
9849 constants do not necessarily get memory "homes". */
9850
9851static void
9852add_const_value_attribute (dw_die_ref die, rtx rtl)
9853{
9854 switch (GET_CODE (rtl))
9855 {
9856 case CONST_INT:
9857 {
9858 HOST_WIDE_INT val = INTVAL (rtl);
9859
9860 if (val < 0)
9861 add_AT_int (die, DW_AT_const_value, val);
9862 else
9863 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
9864 }
9865 break;
9866
9867 case CONST_DOUBLE:
9868 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
9869 floating-point constant. A CONST_DOUBLE is used whenever the
9870 constant requires more than one word in order to be adequately
9871 represented. We output CONST_DOUBLEs as blocks. */
9872 {
9873 enum machine_mode mode = GET_MODE (rtl);
9874
9875 if (SCALAR_FLOAT_MODE_P (mode))
9876 {
9877 unsigned int length = GET_MODE_SIZE (mode);
9878 unsigned char *array = ggc_alloc (length);
9879
9880 insert_float (rtl, array);
9881 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
9882 }
9883 else
9884 {
9885 /* ??? We really should be using HOST_WIDE_INT throughout. */
9886 gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT);
9887
9888 add_AT_long_long (die, DW_AT_const_value,
9889 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
9890 }
9891 }
9892 break;
9893
9894 case CONST_VECTOR:
9895 {
9896 enum machine_mode mode = GET_MODE (rtl);
9897 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
9898 unsigned int length = CONST_VECTOR_NUNITS (rtl);
9899 unsigned char *array = ggc_alloc (length * elt_size);
9900 unsigned int i;
9901 unsigned char *p;
9902
9903 switch (GET_MODE_CLASS (mode))
9904 {
9905 case MODE_VECTOR_INT:
9906 for (i = 0, p = array; i < length; i++, p += elt_size)
9907 {
9908 rtx elt = CONST_VECTOR_ELT (rtl, i);
9909 HOST_WIDE_INT lo, hi;
9910
9911 switch (GET_CODE (elt))
9912 {
9913 case CONST_INT:
9914 lo = INTVAL (elt);
9915 hi = -(lo < 0);
9916 break;
9917
9918 case CONST_DOUBLE:
9919 lo = CONST_DOUBLE_LOW (elt);
9920 hi = CONST_DOUBLE_HIGH (elt);
9921 break;
9922
9923 default:
9924 gcc_unreachable ();
9925 }
9926
9927 if (elt_size <= sizeof (HOST_WIDE_INT))
9928 insert_int (lo, elt_size, p);
9929 else
9930 {
9931 unsigned char *p0 = p;
9932 unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
9933
9934 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
9935 if (WORDS_BIG_ENDIAN)
9936 {
9937 p0 = p1;
9938 p1 = p;
9939 }
9940 insert_int (lo, sizeof (HOST_WIDE_INT), p0);
9941 insert_int (hi, sizeof (HOST_WIDE_INT), p1);
9942 }
9943 }
9944 break;
9945
9946 case MODE_VECTOR_FLOAT:
9947 for (i = 0, p = array; i < length; i++, p += elt_size)
9948 {
9949 rtx elt = CONST_VECTOR_ELT (rtl, i);
9950 insert_float (elt, p);
9951 }
9952 break;
9953
9954 default:
9955 gcc_unreachable ();
9956 }
9957
9958 add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
9959 }
9960 break;
9961
9962 case CONST_STRING:
9963 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
9964 break;
9965
9966 case SYMBOL_REF:
9967 case LABEL_REF:
9968 case CONST:
9969 add_AT_addr (die, DW_AT_const_value, rtl);
9970 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
9971 break;
9972
9973 case PLUS:
9974 /* In cases where an inlined instance of an inline function is passed
9975 the address of an `auto' variable (which is local to the caller) we
9976 can get a situation where the DECL_RTL of the artificial local
9977 variable (for the inlining) which acts as a stand-in for the
9978 corresponding formal parameter (of the inline function) will look
9979 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
9980 exactly a compile-time constant expression, but it isn't the address
9981 of the (artificial) local variable either. Rather, it represents the
9982 *value* which the artificial local variable always has during its
9983 lifetime. We currently have no way to represent such quasi-constant
9984 values in Dwarf, so for now we just punt and generate nothing. */
9985 break;
9986
9987 default:
9988 /* No other kinds of rtx should be possible here. */
9989 gcc_unreachable ();
9990 }
9991
9992}
9993
9994/* Determine whether the evaluation of EXPR references any variables
9995 or functions which aren't otherwise used (and therefore may not be
9996 output). */
9997static tree
9998reference_to_unused (tree * tp, int * walk_subtrees,
9999 void * data ATTRIBUTE_UNUSED)
10000{
10001 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
10002 *walk_subtrees = 0;
10003
10004 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
10005 && ! TREE_ASM_WRITTEN (*tp))
10006 return *tp;
10007 else if (!flag_unit_at_a_time)
10008 return NULL_TREE;
10009 else if (!cgraph_global_info_ready
10010 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL))
10011 return *tp;
10012 else if (DECL_P (*tp) && TREE_CODE (*tp) == VAR_DECL)
10013 {
10014 struct cgraph_varpool_node *node = cgraph_varpool_node (*tp);
10015 if (!node->needed)
10016 return *tp;
10017 }
10018 else if (DECL_P (*tp) && TREE_CODE (*tp) == FUNCTION_DECL
10019 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp)))
10020 {
10021 struct cgraph_node *node = cgraph_node (*tp);
10022 if (!node->output)
10023 return *tp;
10024 }
10025
10026 return NULL_TREE;
10027}
10028
10029/* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
10030 for use in a later add_const_value_attribute call. */
10031
10032static rtx
10033rtl_for_decl_init (tree init, tree type)
10034{
10035 rtx rtl = NULL_RTX;
10036
10037 /* If a variable is initialized with a string constant without embedded
10038 zeros, build CONST_STRING. */
10039 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
10040 {
10041 tree enttype = TREE_TYPE (type);
10042 tree domain = TYPE_DOMAIN (type);
10043 enum machine_mode mode = TYPE_MODE (enttype);
10044
10045 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
10046 && domain
10047 && integer_zerop (TYPE_MIN_VALUE (domain))
10048 && compare_tree_int (TYPE_MAX_VALUE (domain),
10049 TREE_STRING_LENGTH (init) - 1) == 0
10050 && ((size_t) TREE_STRING_LENGTH (init)
10051 == strlen (TREE_STRING_POINTER (init)) + 1))
10052 rtl = gen_rtx_CONST_STRING (VOIDmode,
10053 ggc_strdup (TREE_STRING_POINTER (init)));
10054 }
10055 /* Other aggregates, and complex values, could be represented using
10056 CONCAT: FIXME! */
10057 else if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE)
10058 ;
10059 /* Vectors only work if their mode is supported by the target.
10060 FIXME: generic vectors ought to work too. */
10061 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_MODE (type) == BLKmode)
10062 ;
10063 /* If the initializer is something that we know will expand into an
10064 immediate RTL constant, expand it now. We must be careful not to
10065 reference variables which won't be output. */
10066 else if (initializer_constant_valid_p (init, type)
10067 && ! walk_tree (&init, reference_to_unused, NULL, NULL))
10068 {
10069 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
10070 possible. */
10071 if (TREE_CODE (type) == VECTOR_TYPE)
10072 switch (TREE_CODE (init))
10073 {
10074 case VECTOR_CST:
10075 break;
10076 case CONSTRUCTOR:
10077 if (TREE_CONSTANT (init))
10078 {
10079 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (init);
10080 bool constant_p = true;
10081 tree value;
10082 unsigned HOST_WIDE_INT ix;
10083
10084 /* Even when ctor is constant, it might contain non-*_CST
10085 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
10086 belong into VECTOR_CST nodes. */
10087 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
10088 if (!CONSTANT_CLASS_P (value))
10089 {
10090 constant_p = false;
10091 break;
10092 }
10093
10094 if (constant_p)
10095 {
10096 init = build_vector_from_ctor (type, elts);
10097 break;
10098 }
10099 }
10100 /* FALLTHRU */
10101
10102 default:
10103 return NULL;
10104 }
10105
10106 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
10107
10108 /* If expand_expr returns a MEM, it wasn't immediate. */
10109 gcc_assert (!rtl || !MEM_P (rtl));
10110 }
10111
10112 return rtl;
10113}
10114
10115/* Generate RTL for the variable DECL to represent its location. */
10116
10117static rtx
10118rtl_for_decl_location (tree decl)
10119{
10120 rtx rtl;
10121
10122 /* Here we have to decide where we are going to say the parameter "lives"
10123 (as far as the debugger is concerned). We only have a couple of
10124 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
10125
10126 DECL_RTL normally indicates where the parameter lives during most of the
10127 activation of the function. If optimization is enabled however, this
10128 could be either NULL or else a pseudo-reg. Both of those cases indicate
10129 that the parameter doesn't really live anywhere (as far as the code
10130 generation parts of GCC are concerned) during most of the function's
10131 activation. That will happen (for example) if the parameter is never
10132 referenced within the function.
10133
10134 We could just generate a location descriptor here for all non-NULL
10135 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
10136 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
10137 where DECL_RTL is NULL or is a pseudo-reg.
10138
10139 Note however that we can only get away with using DECL_INCOMING_RTL as
10140 a backup substitute for DECL_RTL in certain limited cases. In cases
10141 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
10142 we can be sure that the parameter was passed using the same type as it is
10143 declared to have within the function, and that its DECL_INCOMING_RTL
10144 points us to a place where a value of that type is passed.
10145
10146 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
10147 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
10148 because in these cases DECL_INCOMING_RTL points us to a value of some
10149 type which is *different* from the type of the parameter itself. Thus,
10150 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
10151 such cases, the debugger would end up (for example) trying to fetch a
10152 `float' from a place which actually contains the first part of a
10153 `double'. That would lead to really incorrect and confusing
10154 output at debug-time.
10155
10156 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
10157 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
10158 are a couple of exceptions however. On little-endian machines we can
10159 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
10160 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
10161 an integral type that is smaller than TREE_TYPE (decl). These cases arise
10162 when (on a little-endian machine) a non-prototyped function has a
10163 parameter declared to be of type `short' or `char'. In such cases,
10164 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
10165 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
10166 passed `int' value. If the debugger then uses that address to fetch
10167 a `short' or a `char' (on a little-endian machine) the result will be
10168 the correct data, so we allow for such exceptional cases below.
10169
10170 Note that our goal here is to describe the place where the given formal
10171 parameter lives during most of the function's activation (i.e. between the
10172 end of the prologue and the start of the epilogue). We'll do that as best
10173 as we can. Note however that if the given formal parameter is modified
10174 sometime during the execution of the function, then a stack backtrace (at
10175 debug-time) will show the function as having been called with the *new*
10176 value rather than the value which was originally passed in. This happens
10177 rarely enough that it is not a major problem, but it *is* a problem, and
10178 I'd like to fix it.
10179
10180 A future version of dwarf2out.c may generate two additional attributes for
10181 any given DW_TAG_formal_parameter DIE which will describe the "passed
10182 type" and the "passed location" for the given formal parameter in addition
10183 to the attributes we now generate to indicate the "declared type" and the
10184 "active location" for each parameter. This additional set of attributes
10185 could be used by debuggers for stack backtraces. Separately, note that
10186 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
10187 This happens (for example) for inlined-instances of inline function formal
10188 parameters which are never referenced. This really shouldn't be
10189 happening. All PARM_DECL nodes should get valid non-NULL
10190 DECL_INCOMING_RTL values. FIXME. */
10191
10192 /* Use DECL_RTL as the "location" unless we find something better. */
10193 rtl = DECL_RTL_IF_SET (decl);
10194
10195 /* When generating abstract instances, ignore everything except
10196 constants, symbols living in memory, and symbols living in
10197 fixed registers. */
10198 if (! reload_completed)
10199 {
10200 if (rtl
10201 && (CONSTANT_P (rtl)
10202 || (MEM_P (rtl)
10203 && CONSTANT_P (XEXP (rtl, 0)))
10204 || (REG_P (rtl)
10205 && TREE_CODE (decl) == VAR_DECL
10206 && TREE_STATIC (decl))))
10207 {
10208 rtl = targetm.delegitimize_address (rtl);
10209 return rtl;
10210 }
10211 rtl = NULL_RTX;
10212 }
10213 else if (TREE_CODE (decl) == PARM_DECL)
10214 {
10215 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
10216 {
10217 tree declared_type = TREE_TYPE (decl);
10218 tree passed_type = DECL_ARG_TYPE (decl);
10219 enum machine_mode dmode = TYPE_MODE (declared_type);
10220 enum machine_mode pmode = TYPE_MODE (passed_type);
10221
10222 /* This decl represents a formal parameter which was optimized out.
10223 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
10224 all cases where (rtl == NULL_RTX) just below. */
10225 if (dmode == pmode)
10226 rtl = DECL_INCOMING_RTL (decl);
10227 else if (SCALAR_INT_MODE_P (dmode)
10228 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
10229 && DECL_INCOMING_RTL (decl))
10230 {
10231 rtx inc = DECL_INCOMING_RTL (decl);
10232 if (REG_P (inc))
10233 rtl = inc;
10234 else if (MEM_P (inc))
10235 {
10236 if (BYTES_BIG_ENDIAN)
10237 rtl = adjust_address_nv (inc, dmode,
10238 GET_MODE_SIZE (pmode)
10239 - GET_MODE_SIZE (dmode));
10240 else
10241 rtl = inc;
10242 }
10243 }
10244 }
10245
10246 /* If the parm was passed in registers, but lives on the stack, then
10247 make a big endian correction if the mode of the type of the
10248 parameter is not the same as the mode of the rtl. */
10249 /* ??? This is the same series of checks that are made in dbxout.c before
10250 we reach the big endian correction code there. It isn't clear if all
10251 of these checks are necessary here, but keeping them all is the safe
10252 thing to do. */
10253 else if (MEM_P (rtl)
10254 && XEXP (rtl, 0) != const0_rtx
10255 && ! CONSTANT_P (XEXP (rtl, 0))
10256 /* Not passed in memory. */
10257 && !MEM_P (DECL_INCOMING_RTL (decl))
10258 /* Not passed by invisible reference. */
10259 && (!REG_P (XEXP (rtl, 0))
10260 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
10261 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
10262#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
10263 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
10264#endif
10265 )
10266 /* Big endian correction check. */
10267 && BYTES_BIG_ENDIAN
10268 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
10269 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
10270 < UNITS_PER_WORD))
10271 {
10272 int offset = (UNITS_PER_WORD
10273 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
10274
10275 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10276 plus_constant (XEXP (rtl, 0), offset));
10277 }
10278 }
10279 else if (TREE_CODE (decl) == VAR_DECL
10280 && rtl
10281 && MEM_P (rtl)
10282 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
10283 && BYTES_BIG_ENDIAN)
10284 {
10285 int rsize = GET_MODE_SIZE (GET_MODE (rtl));
10286 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
10287
10288 /* If a variable is declared "register" yet is smaller than
10289 a register, then if we store the variable to memory, it
10290 looks like we're storing a register-sized value, when in
10291 fact we are not. We need to adjust the offset of the
10292 storage location to reflect the actual value's bytes,
10293 else gdb will not be able to display it. */
10294 if (rsize > dsize)
10295 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10296 plus_constant (XEXP (rtl, 0), rsize-dsize));
10297 }
10298
10299 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
10300 and will have been substituted directly into all expressions that use it.
10301 C does not have such a concept, but C++ and other languages do. */
10302 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
10303 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
10304
10305 if (rtl)
10306 rtl = targetm.delegitimize_address (rtl);
10307
10308 /* If we don't look past the constant pool, we risk emitting a
10309 reference to a constant pool entry that isn't referenced from
10310 code, and thus is not emitted. */
10311 if (rtl)
10312 rtl = avoid_constant_pool_reference (rtl);
10313
10314 return rtl;
10315}
10316
10317/* We need to figure out what section we should use as the base for the
10318 address ranges where a given location is valid.
10319 1. If this particular DECL has a section associated with it, use that.
10320 2. If this function has a section associated with it, use that.
10321 3. Otherwise, use the text section.
10322 XXX: If you split a variable across multiple sections, we won't notice. */
10323
10324static const char *
10325secname_for_decl (tree decl)
10326{
10327 const char *secname;
10328
10329 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
10330 {
10331 tree sectree = DECL_SECTION_NAME (decl);
10332 secname = TREE_STRING_POINTER (sectree);
10333 }
10334 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
10335 {
10336 tree sectree = DECL_SECTION_NAME (current_function_decl);
10337 secname = TREE_STRING_POINTER (sectree);
10338 }
10339 else if (cfun && in_cold_section_p)
10340 secname = cfun->cold_section_label;
10341 else
10342 secname = text_section_label;
10343
10344 return secname;
10345}
10346
10347/* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
10348 data attribute for a variable or a parameter. We generate the
10349 DW_AT_const_value attribute only in those cases where the given variable
10350 or parameter does not have a true "location" either in memory or in a
10351 register. This can happen (for example) when a constant is passed as an
10352 actual argument in a call to an inline function. (It's possible that
10353 these things can crop up in other ways also.) Note that one type of
10354 constant value which can be passed into an inlined function is a constant
10355 pointer. This can happen for example if an actual argument in an inlined
10356 function call evaluates to a compile-time constant address. */
10357
10358static void
10359add_location_or_const_value_attribute (dw_die_ref die, tree decl,
10360 enum dwarf_attribute attr)
10361{
10362 rtx rtl;
10363 dw_loc_descr_ref descr;
10364 var_loc_list *loc_list;
10365 struct var_loc_node *node;
10366 if (TREE_CODE (decl) == ERROR_MARK)
10367 return;
10368
10369 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
10370 || TREE_CODE (decl) == RESULT_DECL);
10371
10372 /* See if we possibly have multiple locations for this variable. */
10373 loc_list = lookup_decl_loc (decl);
10374
10375 /* If it truly has multiple locations, the first and last node will
10376 differ. */
10377 if (loc_list && loc_list->first != loc_list->last)
10378 {
10379 const char *endname, *secname;
10380 dw_loc_list_ref list;
10381 rtx varloc;
10382
10383 /* Now that we know what section we are using for a base,
10384 actually construct the list of locations.
10385 The first location information is what is passed to the
10386 function that creates the location list, and the remaining
10387 locations just get added on to that list.
10388 Note that we only know the start address for a location
10389 (IE location changes), so to build the range, we use
10390 the range [current location start, next location start].
10391 This means we have to special case the last node, and generate
10392 a range of [last location start, end of function label]. */
10393
10394 node = loc_list->first;
10395 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10396 secname = secname_for_decl (decl);
10397
10398 list = new_loc_list (loc_descriptor (varloc),
10399 node->label, node->next->label, secname, 1);
10400 node = node->next;
10401
10402 for (; node->next; node = node->next)
10403 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10404 {
10405 /* The variable has a location between NODE->LABEL and
10406 NODE->NEXT->LABEL. */
10407 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10408 add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
10409 node->label, node->next->label, secname);
10410 }
10411
10412 /* If the variable has a location at the last label
10413 it keeps its location until the end of function. */
10414 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10415 {
10416 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
10417
10418 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10419 if (!current_function_decl)
10420 endname = text_end_label;
10421 else
10422 {
10423 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
10424 current_function_funcdef_no);
10425 endname = ggc_strdup (label_id);
10426 }
10427 add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
10428 node->label, endname, secname);
10429 }
10430
10431 /* Finally, add the location list to the DIE, and we are done. */
10432 add_AT_loc_list (die, attr, list);
10433 return;
10434 }
10435
10436 /* Try to get some constant RTL for this decl, and use that as the value of
10437 the location. */
10438
10439 rtl = rtl_for_decl_location (decl);
10440 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING))
10441 {
10442 add_const_value_attribute (die, rtl);
10443 return;
10444 }
10445
10446 /* If we have tried to generate the location otherwise, and it
10447 didn't work out (we wouldn't be here if we did), and we have a one entry
10448 location list, try generating a location from that. */
10449 if (loc_list && loc_list->first)
10450 {
10451 node = loc_list->first;
10452 descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note));
10453 if (descr)
10454 {
10455 add_AT_location_description (die, attr, descr);
10456 return;
10457 }
10458 }
10459
10460 /* We couldn't get any rtl, so try directly generating the location
10461 description from the tree. */
10462 descr = loc_descriptor_from_tree (decl);
10463 if (descr)
10464 {
10465 add_AT_location_description (die, attr, descr);
10466 return;
10467 }
10468 /* None of that worked, so it must not really have a location;
10469 try adding a constant value attribute from the DECL_INITIAL. */
10470 tree_add_const_value_attribute (die, decl);
10471}
10472
10473/* If we don't have a copy of this variable in memory for some reason (such
10474 as a C++ member constant that doesn't have an out-of-line definition),
10475 we should tell the debugger about the constant value. */
10476
10477static void
10478tree_add_const_value_attribute (dw_die_ref var_die, tree decl)
10479{
10480 tree init = DECL_INITIAL (decl);
10481 tree type = TREE_TYPE (decl);
10482 rtx rtl;
10483
10484 if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init)
10485 /* OK */;
10486 else
10487 return;
10488
10489 rtl = rtl_for_decl_init (init, type);
10490 if (rtl)
10491 add_const_value_attribute (var_die, rtl);
10492}
10493
10494/* Convert the CFI instructions for the current function into a
10495 location list. This is used for DW_AT_frame_base when we targeting
10496 a dwarf2 consumer that does not support the dwarf3
10497 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
10498 expressions. */
10499
10500static dw_loc_list_ref
10501convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
10502{
10503 dw_fde_ref fde;
10504 dw_loc_list_ref list, *list_tail;
10505 dw_cfi_ref cfi;
10506 dw_cfa_location last_cfa, next_cfa;
10507 const char *start_label, *last_label, *section;
10508
10509 fde = &fde_table[fde_table_in_use - 1];
10510
10511 section = secname_for_decl (current_function_decl);
10512 list_tail = &list;
10513 list = NULL;
10514
10515 next_cfa.reg = INVALID_REGNUM;
10516 next_cfa.offset = 0;
10517 next_cfa.indirect = 0;
10518 next_cfa.base_offset = 0;
10519
10520 start_label = fde->dw_fde_begin;
10521
10522 /* ??? Bald assumption that the CIE opcode list does not contain
10523 advance opcodes. */
10524 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
10525 lookup_cfa_1 (cfi, &next_cfa);
10526
10527 last_cfa = next_cfa;
10528 last_label = start_label;
10529
10530 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
10531 switch (cfi->dw_cfi_opc)
10532 {
10533 case DW_CFA_set_loc:
10534 case DW_CFA_advance_loc1:
10535 case DW_CFA_advance_loc2:
10536 case DW_CFA_advance_loc4:
10537 if (!cfa_equal_p (&last_cfa, &next_cfa))
10538 {
10539 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
10540 start_label, last_label, section,
10541 list == NULL);
10542
10543 list_tail = &(*list_tail)->dw_loc_next;
10544 last_cfa = next_cfa;
10545 start_label = last_label;
10546 }
10547 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
10548 break;
10549
10550 case DW_CFA_advance_loc:
10551 /* The encoding is complex enough that we should never emit this. */
10552 case DW_CFA_remember_state:
10553 case DW_CFA_restore_state:
10554 /* We don't handle these two in this function. It would be possible
10555 if it were to be required. */
10556 gcc_unreachable ();
10557
10558 default:
10559 lookup_cfa_1 (cfi, &next_cfa);
10560 break;
10561 }
10562
10563 if (!cfa_equal_p (&last_cfa, &next_cfa))
10564 {
10565 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
10566 start_label, last_label, section,
10567 list == NULL);
10568 list_tail = &(*list_tail)->dw_loc_next;
10569 start_label = last_label;
10570 }
10571 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
10572 start_label, fde->dw_fde_end, section,
10573 list == NULL);
10574
10575 return list;
10576}
10577
10578/* Compute a displacement from the "steady-state frame pointer" to the
10579 frame base (often the same as the CFA), and store it in
10580 frame_pointer_fb_offset. OFFSET is added to the displacement
10581 before the latter is negated. */
10582
10583static void
10584compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
10585{
10586 rtx reg, elim;
10587
10588#ifdef FRAME_POINTER_CFA_OFFSET
10589 reg = frame_pointer_rtx;
10590 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
10591#else
10592 reg = arg_pointer_rtx;
10593 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
10594#endif
10595
10596 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10597 if (GET_CODE (elim) == PLUS)
10598 {
10599 offset += INTVAL (XEXP (elim, 1));
10600 elim = XEXP (elim, 0);
10601 }
10602 gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
10603 : stack_pointer_rtx));
10604
10605 frame_pointer_fb_offset = -offset;
10606}
10607
10608/* Generate a DW_AT_name attribute given some string value to be included as
10609 the value of the attribute. */
10610
10611static void
10612add_name_attribute (dw_die_ref die, const char *name_string)
10613{
10614 if (name_string != NULL && *name_string != 0)
10615 {
10616 if (demangle_name_func)
10617 name_string = (*demangle_name_func) (name_string);
10618
10619 add_AT_string (die, DW_AT_name, name_string);
10620 }
10621}
10622
10623/* Generate a DW_AT_comp_dir attribute for DIE. */
10624
10625static void
10626add_comp_dir_attribute (dw_die_ref die)
10627{
10628 const char *wd = get_src_pwd ();
10629 if (wd != NULL)
10630 add_AT_string (die, DW_AT_comp_dir, wd);
10631}
10632
10633/* Given a tree node describing an array bound (either lower or upper) output
10634 a representation for that bound. */
10635
10636static void
10637add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
10638{
10639 switch (TREE_CODE (bound))
10640 {
10641 case ERROR_MARK:
10642 return;
10643
10644 /* All fixed-bounds are represented by INTEGER_CST nodes. */
10645 case INTEGER_CST:
10646 if (! host_integerp (bound, 0)
10647 || (bound_attr == DW_AT_lower_bound
10648 && (((is_c_family () || is_java ()) && integer_zerop (bound))
10649 || (is_fortran () && integer_onep (bound)))))
10650 /* Use the default. */
10651 ;
10652 else
10653 add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
10654 break;
10655
10656 case CONVERT_EXPR:
10657 case NOP_EXPR:
10658 case NON_LVALUE_EXPR:
10659 case VIEW_CONVERT_EXPR:
10660 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
10661 break;
10662
10663 case SAVE_EXPR:
10664 break;
10665
10666 case VAR_DECL:
10667 case PARM_DECL:
10668 case RESULT_DECL:
10669 {
10670 dw_die_ref decl_die = lookup_decl_die (bound);
10671
10672 /* ??? Can this happen, or should the variable have been bound
10673 first? Probably it can, since I imagine that we try to create
10674 the types of parameters in the order in which they exist in
10675 the list, and won't have created a forward reference to a
10676 later parameter. */
10677 if (decl_die != NULL)
10678 add_AT_die_ref (subrange_die, bound_attr, decl_die);
10679 break;
10680 }
10681
10682 default:
10683 {
10684 /* Otherwise try to create a stack operation procedure to
10685 evaluate the value of the array bound. */
10686
10687 dw_die_ref ctx, decl_die;
10688 dw_loc_descr_ref loc;
10689
10690 loc = loc_descriptor_from_tree (bound);
10691 if (loc == NULL)
10692 break;
10693
10694 if (current_function_decl == 0)
10695 ctx = comp_unit_die;
10696 else
10697 ctx = lookup_decl_die (current_function_decl);
10698
10699 decl_die = new_die (DW_TAG_variable, ctx, bound);
10700 add_AT_flag (decl_die, DW_AT_artificial, 1);
10701 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
10702 add_AT_loc (decl_die, DW_AT_location, loc);
10703
10704 add_AT_die_ref (subrange_die, bound_attr, decl_die);
10705 break;
10706 }
10707 }
10708}
10709
10710/* Note that the block of subscript information for an array type also
10711 includes information about the element type of type given array type. */
10712
10713static void
10714add_subscript_info (dw_die_ref type_die, tree type)
10715{
10716#ifndef MIPS_DEBUGGING_INFO
10717 unsigned dimension_number;
10718#endif
10719 tree lower, upper;
10720 dw_die_ref subrange_die;
10721
10722 /* The GNU compilers represent multidimensional array types as sequences of
10723 one dimensional array types whose element types are themselves array
10724 types. Here we squish that down, so that each multidimensional array
10725 type gets only one array_type DIE in the Dwarf debugging info. The draft
10726 Dwarf specification say that we are allowed to do this kind of
10727 compression in C (because there is no difference between an array or
10728 arrays and a multidimensional array in C) but for other source languages
10729 (e.g. Ada) we probably shouldn't do this. */
10730
10731 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
10732 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
10733 We work around this by disabling this feature. See also
10734 gen_array_type_die. */
10735#ifndef MIPS_DEBUGGING_INFO
10736 for (dimension_number = 0;
10737 TREE_CODE (type) == ARRAY_TYPE;
10738 type = TREE_TYPE (type), dimension_number++)
10739#endif
10740 {
10741 tree domain = TYPE_DOMAIN (type);
10742
10743 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
10744 and (in GNU C only) variable bounds. Handle all three forms
10745 here. */
10746 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
10747 if (domain)
10748 {
10749 /* We have an array type with specified bounds. */
10750 lower = TYPE_MIN_VALUE (domain);
10751 upper = TYPE_MAX_VALUE (domain);
10752
10753 /* Define the index type. */
10754 if (TREE_TYPE (domain))
10755 {
10756 /* ??? This is probably an Ada unnamed subrange type. Ignore the
10757 TREE_TYPE field. We can't emit debug info for this
10758 because it is an unnamed integral type. */
10759 if (TREE_CODE (domain) == INTEGER_TYPE
10760 && TYPE_NAME (domain) == NULL_TREE
10761 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
10762 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
10763 ;
10764 else
10765 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
10766 type_die);
10767 }
10768
10769 /* ??? If upper is NULL, the array has unspecified length,
10770 but it does have a lower bound. This happens with Fortran
10771 dimension arr(N:*)
10772 Since the debugger is definitely going to need to know N
10773 to produce useful results, go ahead and output the lower
10774 bound solo, and hope the debugger can cope. */
10775
10776 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
10777 if (upper)
10778 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
10779 }
10780
10781 /* Otherwise we have an array type with an unspecified length. The
10782 DWARF-2 spec does not say how to handle this; let's just leave out the
10783 bounds. */
10784 }
10785}
10786
10787static void
10788add_byte_size_attribute (dw_die_ref die, tree tree_node)
10789{
10790 unsigned size;
10791
10792 switch (TREE_CODE (tree_node))
10793 {
10794 case ERROR_MARK:
10795 size = 0;
10796 break;
10797 case ENUMERAL_TYPE:
10798 case RECORD_TYPE:
10799 case UNION_TYPE:
10800 case QUAL_UNION_TYPE:
10801 size = int_size_in_bytes (tree_node);
10802 break;
10803 case FIELD_DECL:
10804 /* For a data member of a struct or union, the DW_AT_byte_size is
10805 generally given as the number of bytes normally allocated for an
10806 object of the *declared* type of the member itself. This is true
10807 even for bit-fields. */
10808 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
10809 break;
10810 default:
10811 gcc_unreachable ();
10812 }
10813
10814 /* Note that `size' might be -1 when we get to this point. If it is, that
10815 indicates that the byte size of the entity in question is variable. We
10816 have no good way of expressing this fact in Dwarf at the present time.
10817 GCC/35998: Avoid passing negative sizes to Dtrace and gdb. */
10818 add_AT_unsigned (die, DW_AT_byte_size, (size != (unsigned)-1 ? size : 0));
10819}
10820
10821/* For a FIELD_DECL node which represents a bit-field, output an attribute
10822 which specifies the distance in bits from the highest order bit of the
10823 "containing object" for the bit-field to the highest order bit of the
10824 bit-field itself.
10825
10826 For any given bit-field, the "containing object" is a hypothetical object
10827 (of some integral or enum type) within which the given bit-field lives. The
10828 type of this hypothetical "containing object" is always the same as the
10829 declared type of the individual bit-field itself. The determination of the
10830 exact location of the "containing object" for a bit-field is rather
10831 complicated. It's handled by the `field_byte_offset' function (above).
10832
10833 Note that it is the size (in bytes) of the hypothetical "containing object"
10834 which will be given in the DW_AT_byte_size attribute for this bit-field.
10835 (See `byte_size_attribute' above). */
10836
10837static inline void
10838add_bit_offset_attribute (dw_die_ref die, tree decl)
10839{
10840 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
10841 tree type = DECL_BIT_FIELD_TYPE (decl);
10842 HOST_WIDE_INT bitpos_int;
10843 HOST_WIDE_INT highest_order_object_bit_offset;
10844 HOST_WIDE_INT highest_order_field_bit_offset;
10845 HOST_WIDE_INT unsigned bit_offset;
10846
10847 /* Must be a field and a bit field. */
10848 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
10849
10850 /* We can't yet handle bit-fields whose offsets are variable, so if we
10851 encounter such things, just return without generating any attribute
10852 whatsoever. Likewise for variable or too large size. */
10853 if (! host_integerp (bit_position (decl), 0)
10854 || ! host_integerp (DECL_SIZE (decl), 1))
10855 return;
10856
10857 bitpos_int = int_bit_position (decl);
10858
10859 /* Note that the bit offset is always the distance (in bits) from the
10860 highest-order bit of the "containing object" to the highest-order bit of
10861 the bit-field itself. Since the "high-order end" of any object or field
10862 is different on big-endian and little-endian machines, the computation
10863 below must take account of these differences. */
10864 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
10865 highest_order_field_bit_offset = bitpos_int;
10866
10867 if (! BYTES_BIG_ENDIAN)
10868 {
10869 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
10870 highest_order_object_bit_offset += simple_type_size_in_bits (type);
10871 }
10872
10873 bit_offset
10874 = (! BYTES_BIG_ENDIAN
10875 ? highest_order_object_bit_offset - highest_order_field_bit_offset
10876 : highest_order_field_bit_offset - highest_order_object_bit_offset);
10877
10878 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
10879}
10880
10881/* For a FIELD_DECL node which represents a bit field, output an attribute
10882 which specifies the length in bits of the given field. */
10883
10884static inline void
10885add_bit_size_attribute (dw_die_ref die, tree decl)
10886{
10887 /* Must be a field and a bit field. */
10888 gcc_assert (TREE_CODE (decl) == FIELD_DECL
10889 && DECL_BIT_FIELD_TYPE (decl));
10890
10891 if (host_integerp (DECL_SIZE (decl), 1))
10892 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
10893}
10894
10895/* If the compiled language is ANSI C, then add a 'prototyped'
10896 attribute, if arg types are given for the parameters of a function. */
10897
10898static inline void
10899add_prototyped_attribute (dw_die_ref die, tree func_type)
10900{
10901 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
10902 && TYPE_ARG_TYPES (func_type) != NULL)
10903 add_AT_flag (die, DW_AT_prototyped, 1);
10904}
10905
10906/* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
10907 by looking in either the type declaration or object declaration
10908 equate table. */
10909
10910static inline void
10911add_abstract_origin_attribute (dw_die_ref die, tree origin)
10912{
10913 dw_die_ref origin_die = NULL;
10914
10915 if (TREE_CODE (origin) != FUNCTION_DECL)
10916 {
10917 /* We may have gotten separated from the block for the inlined
10918 function, if we're in an exception handler or some such; make
10919 sure that the abstract function has been written out.
10920
10921 Doing this for nested functions is wrong, however; functions are
10922 distinct units, and our context might not even be inline. */
10923 tree fn = origin;
10924
10925 if (TYPE_P (fn))
10926 fn = TYPE_STUB_DECL (fn);
10927
10928 fn = decl_function_context (fn);
10929 if (fn)
10930 dwarf2out_abstract_function (fn);
10931 }
10932
10933 if (DECL_P (origin))
10934 origin_die = lookup_decl_die (origin);
10935 else if (TYPE_P (origin))
10936 origin_die = lookup_type_die (origin);
10937
10938 /* XXX: Functions that are never lowered don't always have correct block
10939 trees (in the case of java, they simply have no block tree, in some other
10940 languages). For these functions, there is nothing we can really do to
10941 output correct debug info for inlined functions in all cases. Rather
10942 than die, we'll just produce deficient debug info now, in that we will
10943 have variables without a proper abstract origin. In the future, when all
10944 functions are lowered, we should re-add a gcc_assert (origin_die)
10945 here. */
10946
10947 if (origin_die)
10948 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
10949}
10950
10951/* We do not currently support the pure_virtual attribute. */
10952
10953static inline void
10954add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
10955{
10956 if (DECL_VINDEX (func_decl))
10957 {
10958 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
10959
10960 if (host_integerp (DECL_VINDEX (func_decl), 0))
10961 add_AT_loc (die, DW_AT_vtable_elem_location,
10962 new_loc_descr (DW_OP_constu,
10963 tree_low_cst (DECL_VINDEX (func_decl), 0),
10964 0));
10965
10966 /* GNU extension: Record what type this method came from originally. */
10967 if (debug_info_level > DINFO_LEVEL_TERSE)
10968 add_AT_die_ref (die, DW_AT_containing_type,
10969 lookup_type_die (DECL_CONTEXT (func_decl)));
10970 }
10971}
10972
10973/* Add source coordinate attributes for the given decl. */
10974
10975static void
10976add_src_coords_attributes (dw_die_ref die, tree decl)
10977{
10978 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
10979
10980 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
10981 add_AT_unsigned (die, DW_AT_decl_line, s.line);
10982}
10983
10984/* Add a DW_AT_name attribute and source coordinate attribute for the
10985 given decl, but only if it actually has a name. */
10986
10987static void
10988add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
10989{
10990 tree decl_name;
10991
10992 decl_name = DECL_NAME (decl);
10993 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
10994 {
10995 add_name_attribute (die, dwarf2_name (decl, 0));
10996 if (! DECL_ARTIFICIAL (decl))
10997 add_src_coords_attributes (die, decl);
10998
10999 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
11000 && TREE_PUBLIC (decl)
11001 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
11002 && !DECL_ABSTRACT (decl)
11003 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl)))
11004 add_AT_string (die, DW_AT_MIPS_linkage_name,
11005 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
11006 }
11007
11008#ifdef VMS_DEBUGGING_INFO
11009 /* Get the function's name, as described by its RTL. This may be different
11010 from the DECL_NAME name used in the source file. */
11011 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
11012 {
11013 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
11014 XEXP (DECL_RTL (decl), 0));
11015 VEC_safe_push (tree, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
11016 }
11017#endif
11018}
11019
11020/* Push a new declaration scope. */
11021
11022static void
11023push_decl_scope (tree scope)
11024{
11025 VEC_safe_push (tree, gc, decl_scope_table, scope);
11026}
11027
11028/* Pop a declaration scope. */
11029
11030static inline void
11031pop_decl_scope (void)
11032{
11033 VEC_pop (tree, decl_scope_table);
11034}
11035
11036/* Return the DIE for the scope that immediately contains this type.
11037 Non-named types get global scope. Named types nested in other
11038 types get their containing scope if it's open, or global scope
11039 otherwise. All other types (i.e. function-local named types) get
11040 the current active scope. */
11041
11042static dw_die_ref
11043scope_die_for (tree t, dw_die_ref context_die)
11044{
11045 dw_die_ref scope_die = NULL;
11046 tree containing_scope;
11047 int i;
11048
11049 /* Non-types always go in the current scope. */
11050 gcc_assert (TYPE_P (t));
11051
11052 containing_scope = TYPE_CONTEXT (t);
11053
11054 /* Use the containing namespace if it was passed in (for a declaration). */
11055 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
11056 {
11057 if (context_die == lookup_decl_die (containing_scope))
11058 /* OK */;
11059 else
11060 containing_scope = NULL_TREE;
11061 }
11062
11063 /* Ignore function type "scopes" from the C frontend. They mean that
11064 a tagged type is local to a parmlist of a function declarator, but
11065 that isn't useful to DWARF. */
11066 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
11067 containing_scope = NULL_TREE;
11068
11069 if (containing_scope == NULL_TREE)
11070 scope_die = comp_unit_die;
11071 else if (TYPE_P (containing_scope))
11072 {
11073 /* For types, we can just look up the appropriate DIE. But
11074 first we check to see if we're in the middle of emitting it
11075 so we know where the new DIE should go. */
11076 for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
11077 if (VEC_index (tree, decl_scope_table, i) == containing_scope)
11078 break;
11079
11080 if (i < 0)
11081 {
11082 gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
11083 || TREE_ASM_WRITTEN (containing_scope));
11084
11085 /* If none of the current dies are suitable, we get file scope. */
11086 scope_die = comp_unit_die;
11087 }
11088 else
11089 scope_die = lookup_type_die (containing_scope);
11090 }
11091 else
11092 scope_die = context_die;
11093
11094 return scope_die;
11095}
11096
11097/* Returns nonzero if CONTEXT_DIE is internal to a function. */
11098
11099static inline int
11100local_scope_p (dw_die_ref context_die)
11101{
11102 for (; context_die; context_die = context_die->die_parent)
11103 if (context_die->die_tag == DW_TAG_inlined_subroutine
11104 || context_die->die_tag == DW_TAG_subprogram)
11105 return 1;
11106
11107 return 0;
11108}
11109
11110/* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
11111 whether or not to treat a DIE in this context as a declaration. */
11112
11113static inline int
11114class_or_namespace_scope_p (dw_die_ref context_die)
11115{
11116 return (context_die
11117 && (context_die->die_tag == DW_TAG_structure_type
11118 || context_die->die_tag == DW_TAG_union_type
11119 || context_die->die_tag == DW_TAG_namespace));
11120}
11121
11122/* Many forms of DIEs require a "type description" attribute. This
11123 routine locates the proper "type descriptor" die for the type given
11124 by 'type', and adds a DW_AT_type attribute below the given die. */
11125
11126static void
11127add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
11128 int decl_volatile, dw_die_ref context_die)
11129{
11130 enum tree_code code = TREE_CODE (type);
11131 dw_die_ref type_die = NULL;
11132
11133 /* ??? If this type is an unnamed subrange type of an integral or
11134 floating-point type, use the inner type. This is because we have no
11135 support for unnamed types in base_type_die. This can happen if this is
11136 an Ada subrange type. Correct solution is emit a subrange type die. */
11137 if ((code == INTEGER_TYPE || code == REAL_TYPE)
11138 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
11139 type = TREE_TYPE (type), code = TREE_CODE (type);
11140
11141 if (code == ERROR_MARK
11142 /* Handle a special case. For functions whose return type is void, we
11143 generate *no* type attribute. (Note that no object may have type
11144 `void', so this only applies to function return types). */
11145 || code == VOID_TYPE)
11146 return;
11147
11148 type_die = modified_type_die (type,
11149 decl_const || TYPE_READONLY (type),
11150 decl_volatile || TYPE_VOLATILE (type),
11151 context_die);
11152
11153 if (type_die != NULL)
11154 add_AT_die_ref (object_die, DW_AT_type, type_die);
11155}
11156
11157/* Given an object die, add the calling convention attribute for the
11158 function call type. */
11159static void
11160add_calling_convention_attribute (dw_die_ref subr_die, tree type)
11161{
11162 enum dwarf_calling_convention value = DW_CC_normal;
11163
11164 value = targetm.dwarf_calling_convention (type);
11165
11166 /* Only add the attribute if the backend requests it, and
11167 is not DW_CC_normal. */
11168 if (value && (value != DW_CC_normal))
11169 add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
11170}
11171
11172/* Given a tree pointer to a struct, class, union, or enum type node, return
11173 a pointer to the (string) tag name for the given type, or zero if the type
11174 was declared without a tag. */
11175
11176static const char *
11177type_tag (tree type)
11178{
11179 const char *name = 0;
11180
11181 if (TYPE_NAME (type) != 0)
11182 {
11183 tree t = 0;
11184
11185 /* Find the IDENTIFIER_NODE for the type name. */
11186 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
11187 t = TYPE_NAME (type);
11188
11189 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
11190 a TYPE_DECL node, regardless of whether or not a `typedef' was
11191 involved. */
11192 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11193 && ! DECL_IGNORED_P (TYPE_NAME (type)))
11194 t = DECL_NAME (TYPE_NAME (type));
11195
11196 /* Now get the name as a string, or invent one. */
11197 if (t != 0)
11198 name = IDENTIFIER_POINTER (t);
11199 }
11200
11201 return (name == 0 || *name == '\0') ? 0 : name;
11202}
11203
11204/* Return the type associated with a data member, make a special check
11205 for bit field types. */
11206
11207static inline tree
11208member_declared_type (tree member)
11209{
11210 return (DECL_BIT_FIELD_TYPE (member)
11211 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
11212}
11213
11214/* Get the decl's label, as described by its RTL. This may be different
11215 from the DECL_NAME name used in the source file. */
11216
11217#if 0
11218static const char *
11219decl_start_label (tree decl)
11220{
11221 rtx x;
11222 const char *fnname;
11223
11224 x = DECL_RTL (decl);
11225 gcc_assert (MEM_P (x));
11226
11227 x = XEXP (x, 0);
11228 gcc_assert (GET_CODE (x) == SYMBOL_REF);
11229
11230 fnname = XSTR (x, 0);
11231 return fnname;
11232}
11233#endif
11234
11235/* These routines generate the internal representation of the DIE's for
11236 the compilation unit. Debugging information is collected by walking
11237 the declaration trees passed in from dwarf2out_decl(). */
11238
11239static void
11240gen_array_type_die (tree type, dw_die_ref context_die)
11241{
11242 dw_die_ref scope_die = scope_die_for (type, context_die);
11243 dw_die_ref array_die;
11244 tree element_type;
11245
11246 /* ??? The SGI dwarf reader fails for array of array of enum types unless
11247 the inner array type comes before the outer array type. Thus we must
11248 call gen_type_die before we call new_die. See below also. */
11249#ifdef MIPS_DEBUGGING_INFO
11250 gen_type_die (TREE_TYPE (type), context_die);
11251#endif
11252
11253 array_die = new_die (DW_TAG_array_type, scope_die, type);
11254 add_name_attribute (array_die, type_tag (type));
11255 equate_type_number_to_die (type, array_die);
11256
11257 if (TREE_CODE (type) == VECTOR_TYPE)
11258 {
11259 /* The frontend feeds us a representation for the vector as a struct
11260 containing an array. Pull out the array type. */
11261 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
11262 add_AT_flag (array_die, DW_AT_GNU_vector, 1);
11263 }
11264
11265#if 0
11266 /* We default the array ordering. SDB will probably do
11267 the right things even if DW_AT_ordering is not present. It's not even
11268 an issue until we start to get into multidimensional arrays anyway. If
11269 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
11270 then we'll have to put the DW_AT_ordering attribute back in. (But if
11271 and when we find out that we need to put these in, we will only do so
11272 for multidimensional arrays. */
11273 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
11274#endif
11275
11276#ifdef MIPS_DEBUGGING_INFO
11277 /* The SGI compilers handle arrays of unknown bound by setting
11278 AT_declaration and not emitting any subrange DIEs. */
11279 if (! TYPE_DOMAIN (type))
11280 add_AT_flag (array_die, DW_AT_declaration, 1);
11281 else
11282#endif
11283 add_subscript_info (array_die, type);
11284
11285 /* Add representation of the type of the elements of this array type. */
11286 element_type = TREE_TYPE (type);
11287
11288 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
11289 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
11290 We work around this by disabling this feature. See also
11291 add_subscript_info. */
11292#ifndef MIPS_DEBUGGING_INFO
11293 while (TREE_CODE (element_type) == ARRAY_TYPE)
11294 element_type = TREE_TYPE (element_type);
11295
11296 gen_type_die (element_type, context_die);
11297#endif
11298
11299 add_type_attribute (array_die, element_type, 0, 0, context_die);
11300}
11301
11302#if 0
11303static void
11304gen_entry_point_die (tree decl, dw_die_ref context_die)
11305{
11306 tree origin = decl_ultimate_origin (decl);
11307 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
11308
11309 if (origin != NULL)
11310 add_abstract_origin_attribute (decl_die, origin);
11311 else
11312 {
11313 add_name_and_src_coords_attributes (decl_die, decl);
11314 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
11315 0, 0, context_die);
11316 }
11317
11318 if (DECL_ABSTRACT (decl))
11319 equate_decl_number_to_die (decl, decl_die);
11320 else
11321 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
11322}
11323#endif
11324
11325/* Walk through the list of incomplete types again, trying once more to
11326 emit full debugging info for them. */
11327
11328static void
11329retry_incomplete_types (void)
11330{
11331 int i;
11332
11333 for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
11334 gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die);
11335}
11336
11337/* Generate a DIE to represent an inlined instance of an enumeration type. */
11338
11339static void
11340gen_inlined_enumeration_type_die (tree type, dw_die_ref context_die)
11341{
11342 dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type);
11343
11344 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11345 be incomplete and such types are not marked. */
11346 add_abstract_origin_attribute (type_die, type);
11347}
11348
11349/* Generate a DIE to represent an inlined instance of a structure type. */
11350
11351static void
11352gen_inlined_structure_type_die (tree type, dw_die_ref context_die)
11353{
11354 dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die, type);
11355
11356 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11357 be incomplete and such types are not marked. */
11358 add_abstract_origin_attribute (type_die, type);
11359}
11360
11361/* Generate a DIE to represent an inlined instance of a union type. */
11362
11363static void
11364gen_inlined_union_type_die (tree type, dw_die_ref context_die)
11365{
11366 dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type);
11367
11368 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11369 be incomplete and such types are not marked. */
11370 add_abstract_origin_attribute (type_die, type);
11371}
11372
11373/* Generate a DIE to represent an enumeration type. Note that these DIEs
11374 include all of the information about the enumeration values also. Each
11375 enumerated type name/value is listed as a child of the enumerated type
11376 DIE. */
11377
11378static dw_die_ref
11379gen_enumeration_type_die (tree type, dw_die_ref context_die)
11380{
11381 dw_die_ref type_die = lookup_type_die (type);
11382
11383 if (type_die == NULL)
11384 {
11385 type_die = new_die (DW_TAG_enumeration_type,
11386 scope_die_for (type, context_die), type);
11387 equate_type_number_to_die (type, type_die);
11388 add_name_attribute (type_die, type_tag (type));
11389 }
11390 else if (! TYPE_SIZE (type))
11391 return type_die;
11392 else
11393 remove_AT (type_die, DW_AT_declaration);
11394
11395 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
11396 given enum type is incomplete, do not generate the DW_AT_byte_size
11397 attribute or the DW_AT_element_list attribute. */
11398 if (TYPE_SIZE (type))
11399 {
11400 tree link;
11401
11402 TREE_ASM_WRITTEN (type) = 1;
11403 add_byte_size_attribute (type_die, type);
11404 if (TYPE_STUB_DECL (type) != NULL_TREE)
11405 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
11406
11407 /* If the first reference to this type was as the return type of an
11408 inline function, then it may not have a parent. Fix this now. */
11409 if (type_die->die_parent == NULL)
11410 add_child_die (scope_die_for (type, context_die), type_die);
11411
11412 for (link = TYPE_VALUES (type);
11413 link != NULL; link = TREE_CHAIN (link))
11414 {
11415 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
11416 tree value = TREE_VALUE (link);
11417
11418 add_name_attribute (enum_die,
11419 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
11420
11421 if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
11422 /* DWARF2 does not provide a way of indicating whether or
11423 not enumeration constants are signed or unsigned. GDB
11424 always assumes the values are signed, so we output all
11425 values as if they were signed. That means that
11426 enumeration constants with very large unsigned values
11427 will appear to have negative values in the debugger. */
11428 add_AT_int (enum_die, DW_AT_const_value,
11429 tree_low_cst (value, tree_int_cst_sgn (value) > 0));
11430 }
11431 }
11432 else
11433 add_AT_flag (type_die, DW_AT_declaration, 1);
11434
11435 return type_die;
11436}
11437
11438/* Generate a DIE to represent either a real live formal parameter decl or to
11439 represent just the type of some formal parameter position in some function
11440 type.
11441
11442 Note that this routine is a bit unusual because its argument may be a
11443 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
11444 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
11445 node. If it's the former then this function is being called to output a
11446 DIE to represent a formal parameter object (or some inlining thereof). If
11447 it's the latter, then this function is only being called to output a
11448 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
11449 argument type of some subprogram type. */
11450
11451static dw_die_ref
11452gen_formal_parameter_die (tree node, dw_die_ref context_die)
11453{
11454 dw_die_ref parm_die
11455 = new_die (DW_TAG_formal_parameter, context_die, node);
11456 tree origin;
11457
11458 switch (TREE_CODE_CLASS (TREE_CODE (node)))
11459 {
11460 case tcc_declaration:
11461 origin = decl_ultimate_origin (node);
11462 if (origin != NULL)
11463 add_abstract_origin_attribute (parm_die, origin);
11464 else
11465 {
11466 add_name_and_src_coords_attributes (parm_die, node);
11467 add_type_attribute (parm_die, TREE_TYPE (node),
11468 TREE_READONLY (node),
11469 TREE_THIS_VOLATILE (node),
11470 context_die);
11471 if (DECL_ARTIFICIAL (node))
11472 add_AT_flag (parm_die, DW_AT_artificial, 1);
11473 }
11474
11475 equate_decl_number_to_die (node, parm_die);
11476 if (! DECL_ABSTRACT (node))
11477 add_location_or_const_value_attribute (parm_die, node, DW_AT_location);
11478
11479 break;
11480
11481 case tcc_type:
11482 /* We were called with some kind of a ..._TYPE node. */
11483 add_type_attribute (parm_die, node, 0, 0, context_die);
11484 break;
11485
11486 default:
11487 gcc_unreachable ();
11488 }
11489
11490 return parm_die;
11491}
11492
11493/* Generate a special type of DIE used as a stand-in for a trailing ellipsis
11494 at the end of an (ANSI prototyped) formal parameters list. */
11495
11496static void
11497gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
11498{
11499 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
11500}
11501
11502/* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
11503 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
11504 parameters as specified in some function type specification (except for
11505 those which appear as part of a function *definition*). */
11506
11507static void
11508gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
11509{
11510 tree link;
11511 tree formal_type = NULL;
11512 tree first_parm_type;
11513 tree arg;
11514
11515 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
11516 {
11517 arg = DECL_ARGUMENTS (function_or_method_type);
11518 function_or_method_type = TREE_TYPE (function_or_method_type);
11519 }
11520 else
11521 arg = NULL_TREE;
11522
11523 first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
11524
11525 /* Make our first pass over the list of formal parameter types and output a
11526 DW_TAG_formal_parameter DIE for each one. */
11527 for (link = first_parm_type; link; )
11528 {
11529 dw_die_ref parm_die;
11530
11531 formal_type = TREE_VALUE (link);
11532 if (formal_type == void_type_node)
11533 break;
11534
11535 /* Output a (nameless) DIE to represent the formal parameter itself. */
11536 parm_die = gen_formal_parameter_die (formal_type, context_die);
11537 if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
11538 && link == first_parm_type)
11539 || (arg && DECL_ARTIFICIAL (arg)))
11540 add_AT_flag (parm_die, DW_AT_artificial, 1);
11541
11542 link = TREE_CHAIN (link);
11543 if (arg)
11544 arg = TREE_CHAIN (arg);
11545 }
11546
11547 /* If this function type has an ellipsis, add a
11548 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
11549 if (formal_type != void_type_node)
11550 gen_unspecified_parameters_die (function_or_method_type, context_die);
11551
11552 /* Make our second (and final) pass over the list of formal parameter types
11553 and output DIEs to represent those types (as necessary). */
11554 for (link = TYPE_ARG_TYPES (function_or_method_type);
11555 link && TREE_VALUE (link);
11556 link = TREE_CHAIN (link))
11557 gen_type_die (TREE_VALUE (link), context_die);
11558}
11559
11560/* We want to generate the DIE for TYPE so that we can generate the
11561 die for MEMBER, which has been defined; we will need to refer back
11562 to the member declaration nested within TYPE. If we're trying to
11563 generate minimal debug info for TYPE, processing TYPE won't do the
11564 trick; we need to attach the member declaration by hand. */
11565
11566static void
11567gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
11568{
11569 gen_type_die (type, context_die);
11570
11571 /* If we're trying to avoid duplicate debug info, we may not have
11572 emitted the member decl for this function. Emit it now. */
11573 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
11574 && ! lookup_decl_die (member))
11575 {
11576 dw_die_ref type_die;
11577 gcc_assert (!decl_ultimate_origin (member));
11578
11579 push_decl_scope (type);
11580 type_die = lookup_type_die (type);
11581 if (TREE_CODE (member) == FUNCTION_DECL)
11582 gen_subprogram_die (member, type_die);
11583 else if (TREE_CODE (member) == FIELD_DECL)
11584 {
11585 /* Ignore the nameless fields that are used to skip bits but handle
11586 C++ anonymous unions and structs. */
11587 if (DECL_NAME (member) != NULL_TREE
11588 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
11589 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
11590 {
11591 gen_type_die (member_declared_type (member), type_die);
11592 gen_field_die (member, type_die);
11593 }
11594 }
11595 else
11596 gen_variable_die (member, type_die);
11597
11598 pop_decl_scope ();
11599 }
11600}
11601
11602/* Generate the DWARF2 info for the "abstract" instance of a function which we
11603 may later generate inlined and/or out-of-line instances of. */
11604
11605static void
11606dwarf2out_abstract_function (tree decl)
11607{
11608 dw_die_ref old_die;
11609 tree save_fn;
11610 struct function *save_cfun;
11611 tree context;
11612 int was_abstract = DECL_ABSTRACT (decl);
11613
11614 /* Make sure we have the actual abstract inline, not a clone. */
11615 decl = DECL_ORIGIN (decl);
11616
11617 old_die = lookup_decl_die (decl);
11618 if (old_die && get_AT (old_die, DW_AT_inline))
11619 /* We've already generated the abstract instance. */
11620 return;
11621
11622 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
11623 we don't get confused by DECL_ABSTRACT. */
11624 if (debug_info_level > DINFO_LEVEL_TERSE)
11625 {
11626 context = decl_class_context (decl);
11627 if (context)
11628 gen_type_die_for_member
11629 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
11630 }
11631
11632 /* Pretend we've just finished compiling this function. */
11633 save_fn = current_function_decl;
11634 save_cfun = cfun;
11635 current_function_decl = decl;
11636 cfun = DECL_STRUCT_FUNCTION (decl);
11637
11638 set_decl_abstract_flags (decl, 1);
11639 dwarf2out_decl (decl);
11640 if (! was_abstract)
11641 set_decl_abstract_flags (decl, 0);
11642
11643 current_function_decl = save_fn;
11644 cfun = save_cfun;
11645}
11646
11647/* Helper function of premark_used_types() which gets called through
11648 htab_traverse_resize().
11649
11650 Marks the DIE of a given type in *SLOT as perennial, so it never gets
11651 marked as unused by prune_unused_types. */
11652static int
11653premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED)
11654{
11655 tree type;
11656 dw_die_ref die;
11657
11658 type = *slot;
11659 die = lookup_type_die (type);
11660 if (die != NULL)
11661 die->die_perennial_p = 1;
11662 return 1;
11663}
11664
11665/* Mark all members of used_types_hash as perennial. */
11666static void
11667premark_used_types (void)
11668{
11669 if (cfun && cfun->used_types_hash)
11670 htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL);
11671}
11672
11673/* Generate a DIE to represent a declared function (either file-scope or
11674 block-local). */
11675
11676static void
11677gen_subprogram_die (tree decl, dw_die_ref context_die)
11678{
11679 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
11680 tree origin = decl_ultimate_origin (decl);
11681 dw_die_ref subr_die;
11682 tree fn_arg_types;
11683 tree outer_scope;
11684 dw_die_ref old_die = lookup_decl_die (decl);
11685 int declaration = (current_function_decl != decl
11686 || class_or_namespace_scope_p (context_die));
11687
11688 premark_used_types ();
11689
11690 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
11691 started to generate the abstract instance of an inline, decided to output
11692 its containing class, and proceeded to emit the declaration of the inline
11693 from the member list for the class. If so, DECLARATION takes priority;
11694 we'll get back to the abstract instance when done with the class. */
11695
11696 /* The class-scope declaration DIE must be the primary DIE. */
11697 if (origin && declaration && class_or_namespace_scope_p (context_die))
11698 {
11699 origin = NULL;
11700 gcc_assert (!old_die);
11701 }
11702
11703 /* Now that the C++ front end lazily declares artificial member fns, we
11704 might need to retrofit the declaration into its class. */
11705 if (!declaration && !origin && !old_die
11706 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
11707 && !class_or_namespace_scope_p (context_die)
11708 && debug_info_level > DINFO_LEVEL_TERSE)
11709 old_die = force_decl_die (decl);
11710
11711 if (origin != NULL)
11712 {
11713 gcc_assert (!declaration || local_scope_p (context_die));
11714
11715 /* Fixup die_parent for the abstract instance of a nested
11716 inline function. */
11717 if (old_die && old_die->die_parent == NULL)
11718 add_child_die (context_die, old_die);
11719
11720 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11721 add_abstract_origin_attribute (subr_die, origin);
11722 }
11723 else if (old_die)
11724 {
11725 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
11726 struct dwarf_file_data * file_index = lookup_filename (s.file);
11727
11728 if (!get_AT_flag (old_die, DW_AT_declaration)
11729 /* We can have a normal definition following an inline one in the
11730 case of redefinition of GNU C extern inlines.
11731 It seems reasonable to use AT_specification in this case. */
11732 && !get_AT (old_die, DW_AT_inline))
11733 {
11734 /* Detect and ignore this case, where we are trying to output
11735 something we have already output. */
11736 return;
11737 }
11738
11739 /* If the definition comes from the same place as the declaration,
11740 maybe use the old DIE. We always want the DIE for this function
11741 that has the *_pc attributes to be under comp_unit_die so the
11742 debugger can find it. We also need to do this for abstract
11743 instances of inlines, since the spec requires the out-of-line copy
11744 to have the same parent. For local class methods, this doesn't
11745 apply; we just use the old DIE. */
11746 if ((old_die->die_parent == comp_unit_die || context_die == NULL)
11747 && (DECL_ARTIFICIAL (decl)
11748 || (get_AT_file (old_die, DW_AT_decl_file) == file_index
11749 && (get_AT_unsigned (old_die, DW_AT_decl_line)
11750 == (unsigned) s.line))))
11751 {
11752 subr_die = old_die;
11753
11754 /* Clear out the declaration attribute and the formal parameters.
11755 Do not remove all children, because it is possible that this
11756 declaration die was forced using force_decl_die(). In such
11757 cases die that forced declaration die (e.g. TAG_imported_module)
11758 is one of the children that we do not want to remove. */
11759 remove_AT (subr_die, DW_AT_declaration);
11760 remove_child_TAG (subr_die, DW_TAG_formal_parameter);
11761 }
11762 else
11763 {
11764 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11765 add_AT_specification (subr_die, old_die);
11766 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
11767 add_AT_file (subr_die, DW_AT_decl_file, file_index);
11768 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
11769 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
11770 }
11771 }
11772 else
11773 {
11774 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11775
11776 if (TREE_PUBLIC (decl))
11777 add_AT_flag (subr_die, DW_AT_external, 1);
11778
11779 add_name_and_src_coords_attributes (subr_die, decl);
11780 if (debug_info_level > DINFO_LEVEL_TERSE)
11781 {
11782 add_prototyped_attribute (subr_die, TREE_TYPE (decl));
11783 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
11784 0, 0, context_die);
11785 }
11786
11787 add_pure_or_virtual_attribute (subr_die, decl);
11788 if (DECL_ARTIFICIAL (decl))
11789 add_AT_flag (subr_die, DW_AT_artificial, 1);
11790
11791 if (TREE_PROTECTED (decl))
11792 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
11793 else if (TREE_PRIVATE (decl))
11794 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
11795 }
11796
11797 if (declaration)
11798 {
11799 if (!old_die || !get_AT (old_die, DW_AT_inline))
11800 {
11801 add_AT_flag (subr_die, DW_AT_declaration, 1);
11802
11803 /* The first time we see a member function, it is in the context of
11804 the class to which it belongs. We make sure of this by emitting
11805 the class first. The next time is the definition, which is
11806 handled above. The two may come from the same source text.
11807
11808 Note that force_decl_die() forces function declaration die. It is
11809 later reused to represent definition. */
11810 equate_decl_number_to_die (decl, subr_die);
11811 }
11812 }
11813 else if (DECL_ABSTRACT (decl))
11814 {
11815 if (DECL_DECLARED_INLINE_P (decl))
11816 {
11817 if (cgraph_function_possibly_inlined_p (decl))
11818 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
11819 else
11820 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
11821 }
11822 else
11823 {
11824 if (cgraph_function_possibly_inlined_p (decl))
11825 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
11826 else
11827 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
11828 }
11829
11830 equate_decl_number_to_die (decl, subr_die);
11831 }
11832 else if (!DECL_EXTERNAL (decl))
11833 {
11834 HOST_WIDE_INT cfa_fb_offset;
11835
11836 if (!old_die || !get_AT (old_die, DW_AT_inline))
11837 equate_decl_number_to_die (decl, subr_die);
11838
11839 if (!flag_reorder_blocks_and_partition)
11840 {
11841 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
11842 current_function_funcdef_no);
11843 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
11844 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
11845 current_function_funcdef_no);
11846 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
11847
11848 add_pubname (decl, subr_die);
11849 add_arange (decl, subr_die);
11850 }
11851 else
11852 { /* Do nothing for now; maybe need to duplicate die, one for
11853 hot section and ond for cold section, then use the hot/cold
11854 section begin/end labels to generate the aranges... */
11855 /*
11856 add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
11857 add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
11858 add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
11859 add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
11860
11861 add_pubname (decl, subr_die);
11862 add_arange (decl, subr_die);
11863 add_arange (decl, subr_die);
11864 */
11865 }
11866
11867#ifdef MIPS_DEBUGGING_INFO
11868 /* Add a reference to the FDE for this routine. */
11869 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
11870#endif
11871
11872 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
11873
11874 /* We define the "frame base" as the function's CFA. This is more
11875 convenient for several reasons: (1) It's stable across the prologue
11876 and epilogue, which makes it better than just a frame pointer,
11877 (2) With dwarf3, there exists a one-byte encoding that allows us
11878 to reference the .debug_frame data by proxy, but failing that,
11879 (3) We can at least reuse the code inspection and interpretation
11880 code that determines the CFA position at various points in the
11881 function. */
11882 /* ??? Use some command-line or configury switch to enable the use
11883 of dwarf3 DW_OP_call_frame_cfa. At present there are no dwarf
11884 consumers that understand it; fall back to "pure" dwarf2 and
11885 convert the CFA data into a location list. */
11886 {
11887 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
11888 if (list->dw_loc_next)
11889 add_AT_loc_list (subr_die, DW_AT_frame_base, list);
11890 else
11891 add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
11892 }
11893
11894 /* Compute a displacement from the "steady-state frame pointer" to
11895 the CFA. The former is what all stack slots and argument slots
11896 will reference in the rtl; the later is what we've told the
11897 debugger about. We'll need to adjust all frame_base references
11898 by this displacement. */
11899 compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
11900
11901 if (cfun->static_chain_decl)
11902 add_AT_location_description (subr_die, DW_AT_static_link,
11903 loc_descriptor_from_tree (cfun->static_chain_decl));
11904 }
11905
11906 /* Now output descriptions of the arguments for this function. This gets
11907 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
11908 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
11909 `...' at the end of the formal parameter list. In order to find out if
11910 there was a trailing ellipsis or not, we must instead look at the type
11911 associated with the FUNCTION_DECL. This will be a node of type
11912 FUNCTION_TYPE. If the chain of type nodes hanging off of this
11913 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
11914 an ellipsis at the end. */
11915
11916 /* In the case where we are describing a mere function declaration, all we
11917 need to do here (and all we *can* do here) is to describe the *types* of
11918 its formal parameters. */
11919 if (debug_info_level <= DINFO_LEVEL_TERSE)
11920 ;
11921 else if (declaration)
11922 gen_formal_types_die (decl, subr_die);
11923 else
11924 {
11925 /* Generate DIEs to represent all known formal parameters. */
11926 tree arg_decls = DECL_ARGUMENTS (decl);
11927 tree parm;
11928
11929 /* When generating DIEs, generate the unspecified_parameters DIE
11930 instead if we come across the arg "__builtin_va_alist" */
11931 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
11932 if (TREE_CODE (parm) == PARM_DECL)
11933 {
11934 if (DECL_NAME (parm)
11935 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
11936 "__builtin_va_alist"))
11937 gen_unspecified_parameters_die (parm, subr_die);
11938 else
11939 gen_decl_die (parm, subr_die);
11940 }
11941
11942 /* Decide whether we need an unspecified_parameters DIE at the end.
11943 There are 2 more cases to do this for: 1) the ansi ... declaration -
11944 this is detectable when the end of the arg list is not a
11945 void_type_node 2) an unprototyped function declaration (not a
11946 definition). This just means that we have no info about the
11947 parameters at all. */
11948 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
11949 if (fn_arg_types != NULL)
11950 {
11951 /* This is the prototyped case, check for.... */
11952 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
11953 gen_unspecified_parameters_die (decl, subr_die);
11954 }
11955 else if (DECL_INITIAL (decl) == NULL_TREE)
11956 gen_unspecified_parameters_die (decl, subr_die);
11957 }
11958
11959 /* Output Dwarf info for all of the stuff within the body of the function
11960 (if it has one - it may be just a declaration). */
11961 outer_scope = DECL_INITIAL (decl);
11962
11963 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
11964 a function. This BLOCK actually represents the outermost binding contour
11965 for the function, i.e. the contour in which the function's formal
11966 parameters and labels get declared. Curiously, it appears that the front
11967 end doesn't actually put the PARM_DECL nodes for the current function onto
11968 the BLOCK_VARS list for this outer scope, but are strung off of the
11969 DECL_ARGUMENTS list for the function instead.
11970
11971 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
11972 the LABEL_DECL nodes for the function however, and we output DWARF info
11973 for those in decls_for_scope. Just within the `outer_scope' there will be
11974 a BLOCK node representing the function's outermost pair of curly braces,
11975 and any blocks used for the base and member initializers of a C++
11976 constructor function. */
11977 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
11978 {
11979 /* Emit a DW_TAG_variable DIE for a named return value. */
11980 if (DECL_NAME (DECL_RESULT (decl)))
11981 gen_decl_die (DECL_RESULT (decl), subr_die);
11982
11983 current_function_has_inlines = 0;
11984 decls_for_scope (outer_scope, subr_die, 0);
11985
11986#if 0 && defined (MIPS_DEBUGGING_INFO)
11987 if (current_function_has_inlines)
11988 {
11989 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
11990 if (! comp_unit_has_inlines)
11991 {
11992 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
11993 comp_unit_has_inlines = 1;
11994 }
11995 }
11996#endif
11997 }
11998 /* Add the calling convention attribute if requested. */
11999 add_calling_convention_attribute (subr_die, TREE_TYPE (decl));
12000
12001}
12002
12003/* Generate a DIE to represent a declared data object. */
12004
12005static void
12006gen_variable_die (tree decl, dw_die_ref context_die)
12007{
12008 tree origin = decl_ultimate_origin (decl);
12009 dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl);
12010
12011 dw_die_ref old_die = lookup_decl_die (decl);
12012 int declaration = (DECL_EXTERNAL (decl)
12013 /* If DECL is COMDAT and has not actually been
12014 emitted, we cannot take its address; there
12015 might end up being no definition anywhere in
12016 the program. For example, consider the C++
12017 test case:
12018
12019 template <class T>
12020 struct S { static const int i = 7; };
12021
12022 template <class T>
12023 const int S<T>::i;
12024
12025 int f() { return S<int>::i; }
12026
12027 Here, S<int>::i is not DECL_EXTERNAL, but no
12028 definition is required, so the compiler will
12029 not emit a definition. */
12030 || (TREE_CODE (decl) == VAR_DECL
12031 && DECL_COMDAT (decl) && !TREE_ASM_WRITTEN (decl))
12032 || class_or_namespace_scope_p (context_die));
12033
12034 if (origin != NULL)
12035 add_abstract_origin_attribute (var_die, origin);
12036
12037 /* Loop unrolling can create multiple blocks that refer to the same
12038 static variable, so we must test for the DW_AT_declaration flag.
12039
12040 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
12041 copy decls and set the DECL_ABSTRACT flag on them instead of
12042 sharing them.
12043
12044 ??? Duplicated blocks have been rewritten to use .debug_ranges.
12045
12046 ??? The declare_in_namespace support causes us to get two DIEs for one
12047 variable, both of which are declarations. We want to avoid considering
12048 one to be a specification, so we must test that this DIE is not a
12049 declaration. */
12050 else if (old_die && TREE_STATIC (decl) && ! declaration
12051 && get_AT_flag (old_die, DW_AT_declaration) == 1)
12052 {
12053 /* This is a definition of a C++ class level static. */
12054 add_AT_specification (var_die, old_die);
12055 if (DECL_NAME (decl))
12056 {
12057 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
12058 struct dwarf_file_data * file_index = lookup_filename (s.file);
12059
12060 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
12061 add_AT_file (var_die, DW_AT_decl_file, file_index);
12062
12063 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
12064
12065 add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
12066 }
12067 }
12068 else
12069 {
12070 add_name_and_src_coords_attributes (var_die, decl);
12071 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
12072 TREE_THIS_VOLATILE (decl), context_die);
12073
12074 if (TREE_PUBLIC (decl))
12075 add_AT_flag (var_die, DW_AT_external, 1);
12076
12077 if (DECL_ARTIFICIAL (decl))
12078 add_AT_flag (var_die, DW_AT_artificial, 1);
12079
12080 if (TREE_PROTECTED (decl))
12081 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
12082 else if (TREE_PRIVATE (decl))
12083 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
12084 }
12085
12086 if (declaration)
12087 add_AT_flag (var_die, DW_AT_declaration, 1);
12088
12089 if (DECL_ABSTRACT (decl) || declaration)
12090 equate_decl_number_to_die (decl, var_die);
12091
12092 if (! declaration && ! DECL_ABSTRACT (decl))
12093 {
12094 add_location_or_const_value_attribute (var_die, decl, DW_AT_location);
12095 add_pubname (decl, var_die);
12096 }
12097 else
12098 tree_add_const_value_attribute (var_die, decl);
12099}
12100
12101/* Generate a DIE to represent a label identifier. */
12102
12103static void
12104gen_label_die (tree decl, dw_die_ref context_die)
12105{
12106 tree origin = decl_ultimate_origin (decl);
12107 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
12108 rtx insn;
12109 char label[MAX_ARTIFICIAL_LABEL_BYTES];
12110
12111 if (origin != NULL)
12112 add_abstract_origin_attribute (lbl_die, origin);
12113 else
12114 add_name_and_src_coords_attributes (lbl_die, decl);
12115
12116 if (DECL_ABSTRACT (decl))
12117 equate_decl_number_to_die (decl, lbl_die);
12118 else
12119 {
12120 insn = DECL_RTL_IF_SET (decl);
12121
12122 /* Deleted labels are programmer specified labels which have been
12123 eliminated because of various optimizations. We still emit them
12124 here so that it is possible to put breakpoints on them. */
12125 if (insn
12126 && (LABEL_P (insn)
12127 || ((NOTE_P (insn)
12128 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL))))
12129 {
12130 /* When optimization is enabled (via -O) some parts of the compiler
12131 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
12132 represent source-level labels which were explicitly declared by
12133 the user. This really shouldn't be happening though, so catch
12134 it if it ever does happen. */
12135 gcc_assert (!INSN_DELETED_P (insn));
12136
12137 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
12138 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
12139 }
12140 }
12141}
12142
12143/* A helper function for gen_inlined_subroutine_die. Add source coordinate
12144 attributes to the DIE for a block STMT, to describe where the inlined
12145 function was called from. This is similar to add_src_coords_attributes. */
12146
12147static inline void
12148add_call_src_coords_attributes (tree stmt, dw_die_ref die)
12149{
12150 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
12151
12152 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
12153 add_AT_unsigned (die, DW_AT_call_line, s.line);
12154}
12155
12156/* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
12157 Add low_pc and high_pc attributes to the DIE for a block STMT. */
12158
12159static inline void
12160add_high_low_attributes (tree stmt, dw_die_ref die)
12161{
12162 char label[MAX_ARTIFICIAL_LABEL_BYTES];
12163
12164 if (BLOCK_FRAGMENT_CHAIN (stmt))
12165 {
12166 tree chain;
12167
12168 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
12169
12170 chain = BLOCK_FRAGMENT_CHAIN (stmt);
12171 do
12172 {
12173 add_ranges (chain);
12174 chain = BLOCK_FRAGMENT_CHAIN (chain);
12175 }
12176 while (chain);
12177 add_ranges (NULL);
12178 }
12179 else
12180 {
12181 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
12182 BLOCK_NUMBER (stmt));
12183 add_AT_lbl_id (die, DW_AT_low_pc, label);
12184 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
12185 BLOCK_NUMBER (stmt));
12186 add_AT_lbl_id (die, DW_AT_high_pc, label);
12187 }
12188}
12189
12190/* Generate a DIE for a lexical block. */
12191
12192static void
12193gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
12194{
12195 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
12196
12197 if (! BLOCK_ABSTRACT (stmt))
12198 add_high_low_attributes (stmt, stmt_die);
12199
12200 decls_for_scope (stmt, stmt_die, depth);
12201}
12202
12203/* Generate a DIE for an inlined subprogram. */
12204
12205static void
12206gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
12207{
12208 tree decl = block_ultimate_origin (stmt);
12209
12210 /* Emit info for the abstract instance first, if we haven't yet. We
12211 must emit this even if the block is abstract, otherwise when we
12212 emit the block below (or elsewhere), we may end up trying to emit
12213 a die whose origin die hasn't been emitted, and crashing. */
12214 dwarf2out_abstract_function (decl);
12215
12216 if (! BLOCK_ABSTRACT (stmt))
12217 {
12218 dw_die_ref subr_die
12219 = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
12220
12221 add_abstract_origin_attribute (subr_die, decl);
12222 add_high_low_attributes (stmt, subr_die);
12223 add_call_src_coords_attributes (stmt, subr_die);
12224
12225 decls_for_scope (stmt, subr_die, depth);
12226 current_function_has_inlines = 1;
12227 }
12228 else
12229 /* We may get here if we're the outer block of function A that was
12230 inlined into function B that was inlined into function C. When
12231 generating debugging info for C, dwarf2out_abstract_function(B)
12232 would mark all inlined blocks as abstract, including this one.
12233 So, we wouldn't (and shouldn't) expect labels to be generated
12234 for this one. Instead, just emit debugging info for
12235 declarations within the block. This is particularly important
12236 in the case of initializers of arguments passed from B to us:
12237 if they're statement expressions containing declarations, we
12238 wouldn't generate dies for their abstract variables, and then,
12239 when generating dies for the real variables, we'd die (pun
12240 intended :-) */
12241 gen_lexical_block_die (stmt, context_die, depth);
12242}
12243
12244/* Generate a DIE for a field in a record, or structure. */
12245
12246static void
12247gen_field_die (tree decl, dw_die_ref context_die)
12248{
12249 dw_die_ref decl_die;
12250
12251 if (TREE_TYPE (decl) == error_mark_node)
12252 return;
12253
12254 decl_die = new_die (DW_TAG_member, context_die, decl);
12255 add_name_and_src_coords_attributes (decl_die, decl);
12256 add_type_attribute (decl_die, member_declared_type (decl),
12257 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
12258 context_die);
12259
12260 if (DECL_BIT_FIELD_TYPE (decl))
12261 {
12262 add_byte_size_attribute (decl_die, decl);
12263 add_bit_size_attribute (decl_die, decl);
12264 add_bit_offset_attribute (decl_die, decl);
12265 }
12266
12267 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
12268 add_data_member_location_attribute (decl_die, decl);
12269
12270 if (DECL_ARTIFICIAL (decl))
12271 add_AT_flag (decl_die, DW_AT_artificial, 1);
12272
12273 if (TREE_PROTECTED (decl))
12274 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
12275 else if (TREE_PRIVATE (decl))
12276 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
12277
12278 /* Equate decl number to die, so that we can look up this decl later on. */
12279 equate_decl_number_to_die (decl, decl_die);
12280}
12281
12282#if 0
12283/* Don't generate either pointer_type DIEs or reference_type DIEs here.
12284 Use modified_type_die instead.
12285 We keep this code here just in case these types of DIEs may be needed to
12286 represent certain things in other languages (e.g. Pascal) someday. */
12287
12288static void
12289gen_pointer_type_die (tree type, dw_die_ref context_die)
12290{
12291 dw_die_ref ptr_die
12292 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
12293
12294 equate_type_number_to_die (type, ptr_die);
12295 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12296 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12297}
12298
12299/* Don't generate either pointer_type DIEs or reference_type DIEs here.
12300 Use modified_type_die instead.
12301 We keep this code here just in case these types of DIEs may be needed to
12302 represent certain things in other languages (e.g. Pascal) someday. */
12303
12304static void
12305gen_reference_type_die (tree type, dw_die_ref context_die)
12306{
12307 dw_die_ref ref_die
12308 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
12309
12310 equate_type_number_to_die (type, ref_die);
12311 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
12312 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12313}
12314#endif
12315
12316/* Generate a DIE for a pointer to a member type. */
12317
12318static void
12319gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
12320{
12321 dw_die_ref ptr_die
12322 = new_die (DW_TAG_ptr_to_member_type,
12323 scope_die_for (type, context_die), type);
12324
12325 equate_type_number_to_die (type, ptr_die);
12326 add_AT_die_ref (ptr_die, DW_AT_containing_type,
12327 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
12328 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12329}
12330
12331/* Generate the DIE for the compilation unit. */
12332
12333static dw_die_ref
12334gen_compile_unit_die (const char *filename)
12335{
12336 dw_die_ref die;
12337 char producer[250];
12338 const char *language_string = lang_hooks.name;
12339 int language;
12340
12341 die = new_die (DW_TAG_compile_unit, NULL, NULL);
12342
12343 if (filename)
12344 {
12345 add_name_attribute (die, filename);
12346 /* Don't add cwd for <built-in>. */
12347 if (filename[0] != DIR_SEPARATOR && filename[0] != '<')
12348 add_comp_dir_attribute (die);
12349 }
12350
12351 sprintf (producer, "%s %s", language_string, version_string);
12352
12353#ifdef MIPS_DEBUGGING_INFO
12354 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
12355 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
12356 not appear in the producer string, the debugger reaches the conclusion
12357 that the object file is stripped and has no debugging information.
12358 To get the MIPS/SGI debugger to believe that there is debugging
12359 information in the object file, we add a -g to the producer string. */
12360 if (debug_info_level > DINFO_LEVEL_TERSE)
12361 strcat (producer, " -g");
12362#endif
12363
12364 add_AT_string (die, DW_AT_producer, producer);
12365
12366 if (strcmp (language_string, "GNU C++") == 0)
12367 language = DW_LANG_C_plus_plus;
12368 else if (strcmp (language_string, "GNU Ada") == 0)
12369 language = DW_LANG_Ada95;
12370 else if (strcmp (language_string, "GNU F77") == 0)
12371 language = DW_LANG_Fortran77;
12372 else if (strcmp (language_string, "GNU F95") == 0)
12373 language = DW_LANG_Fortran95;
12374 else if (strcmp (language_string, "GNU Pascal") == 0)
12375 language = DW_LANG_Pascal83;
12376 else if (strcmp (language_string, "GNU Java") == 0)
12377 language = DW_LANG_Java;
12378 else if (strcmp (language_string, "GNU Objective-C") == 0)
12379 language = DW_LANG_ObjC;
12380 else if (strcmp (language_string, "GNU Objective-C++") == 0)
12381 language = DW_LANG_ObjC_plus_plus;
12382 else
12383 language = DW_LANG_C89;
12384
12385 add_AT_unsigned (die, DW_AT_language, language);
12386 return die;
12387}
12388
12389/* Generate the DIE for a base class. */
12390
12391static void
12392gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
12393{
12394 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
12395
12396 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
12397 add_data_member_location_attribute (die, binfo);
12398
12399 if (BINFO_VIRTUAL_P (binfo))
12400 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
12401
12402 if (access == access_public_node)
12403 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
12404 else if (access == access_protected_node)
12405 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
12406}
12407
12408/* Generate a DIE for a class member. */
12409
12410static void
12411gen_member_die (tree type, dw_die_ref context_die)
12412{
12413 tree member;
12414 tree binfo = TYPE_BINFO (type);
12415 dw_die_ref child;
12416
12417 /* If this is not an incomplete type, output descriptions of each of its
12418 members. Note that as we output the DIEs necessary to represent the
12419 members of this record or union type, we will also be trying to output
12420 DIEs to represent the *types* of those members. However the `type'
12421 function (above) will specifically avoid generating type DIEs for member
12422 types *within* the list of member DIEs for this (containing) type except
12423 for those types (of members) which are explicitly marked as also being
12424 members of this (containing) type themselves. The g++ front- end can
12425 force any given type to be treated as a member of some other (containing)
12426 type by setting the TYPE_CONTEXT of the given (member) type to point to
12427 the TREE node representing the appropriate (containing) type. */
12428
12429 /* First output info about the base classes. */
12430 if (binfo)
12431 {
12432 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
12433 int i;
12434 tree base;
12435
12436 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
12437 gen_inheritance_die (base,
12438 (accesses ? VEC_index (tree, accesses, i)
12439 : access_public_node), context_die);
12440 }
12441
12442 /* Now output info about the data members and type members. */
12443 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
12444 {
12445 /* If we thought we were generating minimal debug info for TYPE
12446 and then changed our minds, some of the member declarations
12447 may have already been defined. Don't define them again, but
12448 do put them in the right order. */
12449
12450 child = lookup_decl_die (member);
12451 if (child)
12452 splice_child_die (context_die, child);
12453 else
12454 gen_decl_die (member, context_die);
12455 }
12456
12457 /* Now output info about the function members (if any). */
12458 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
12459 {
12460 /* Don't include clones in the member list. */
12461 if (DECL_ABSTRACT_ORIGIN (member))
12462 continue;
12463
12464 child = lookup_decl_die (member);
12465 if (child)
12466 splice_child_die (context_die, child);
12467 else
12468 gen_decl_die (member, context_die);
12469 }
12470}
12471
12472/* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
12473 is set, we pretend that the type was never defined, so we only get the
12474 member DIEs needed by later specification DIEs. */
12475
12476static void
12477gen_struct_or_union_type_die (tree type, dw_die_ref context_die,
12478 enum debug_info_usage usage)
12479{
12480 dw_die_ref type_die = lookup_type_die (type);
12481 dw_die_ref scope_die = 0;
12482 int nested = 0;
12483 int complete = (TYPE_SIZE (type)
12484 && (! TYPE_STUB_DECL (type)
12485 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
12486 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
12487 complete = complete && should_emit_struct_debug (type, usage);
12488
12489 if (type_die && ! complete)
12490 return;
12491
12492 if (TYPE_CONTEXT (type) != NULL_TREE
12493 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12494 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
12495 nested = 1;
12496
12497 scope_die = scope_die_for (type, context_die);
12498
12499 if (! type_die || (nested && scope_die == comp_unit_die))
12500 /* First occurrence of type or toplevel definition of nested class. */
12501 {
12502 dw_die_ref old_die = type_die;
12503
12504 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
12505 ? DW_TAG_structure_type : DW_TAG_union_type,
12506 scope_die, type);
12507 equate_type_number_to_die (type, type_die);
12508 if (old_die)
12509 add_AT_specification (type_die, old_die);
12510 else
12511 add_name_attribute (type_die, type_tag (type));
12512 }
12513 else
12514 remove_AT (type_die, DW_AT_declaration);
12515
12516 /* If this type has been completed, then give it a byte_size attribute and
12517 then give a list of members. */
12518 if (complete && !ns_decl)
12519 {
12520 /* Prevent infinite recursion in cases where the type of some member of
12521 this type is expressed in terms of this type itself. */
12522 TREE_ASM_WRITTEN (type) = 1;
12523 add_byte_size_attribute (type_die, type);
12524 if (TYPE_STUB_DECL (type) != NULL_TREE)
12525 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
12526
12527 /* If the first reference to this type was as the return type of an
12528 inline function, then it may not have a parent. Fix this now. */
12529 if (type_die->die_parent == NULL)
12530 add_child_die (scope_die, type_die);
12531
12532 push_decl_scope (type);
12533 gen_member_die (type, type_die);
12534 pop_decl_scope ();
12535
12536 /* GNU extension: Record what type our vtable lives in. */
12537 if (TYPE_VFIELD (type))
12538 {
12539 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
12540
12541 gen_type_die (vtype, context_die);
12542 add_AT_die_ref (type_die, DW_AT_containing_type,
12543 lookup_type_die (vtype));
12544 }
12545 }
12546 else
12547 {
12548 add_AT_flag (type_die, DW_AT_declaration, 1);
12549
12550 /* We don't need to do this for function-local types. */
12551 if (TYPE_STUB_DECL (type)
12552 && ! decl_function_context (TYPE_STUB_DECL (type)))
12553 VEC_safe_push (tree, gc, incomplete_types, type);
12554 }
12555}
12556
12557/* Generate a DIE for a subroutine _type_. */
12558
12559static void
12560gen_subroutine_type_die (tree type, dw_die_ref context_die)
12561{
12562 tree return_type = TREE_TYPE (type);
12563 dw_die_ref subr_die
12564 = new_die (DW_TAG_subroutine_type,
12565 scope_die_for (type, context_die), type);
12566
12567 equate_type_number_to_die (type, subr_die);
12568 add_prototyped_attribute (subr_die, type);
12569 add_type_attribute (subr_die, return_type, 0, 0, context_die);
12570 gen_formal_types_die (type, subr_die);
12571}
12572
12573/* Generate a DIE for a type definition. */
12574
12575static void
12576gen_typedef_die (tree decl, dw_die_ref context_die)
12577{
12578 dw_die_ref type_die;
12579 tree origin;
12580
12581 if (TREE_ASM_WRITTEN (decl))
12582 return;
12583
12584 TREE_ASM_WRITTEN (decl) = 1;
12585 type_die = new_die (DW_TAG_typedef, context_die, decl);
12586 origin = decl_ultimate_origin (decl);
12587 if (origin != NULL)
12588 add_abstract_origin_attribute (type_die, origin);
12589 else
12590 {
12591 tree type;
12592
12593 add_name_and_src_coords_attributes (type_die, decl);
12594 if (DECL_ORIGINAL_TYPE (decl))
12595 {
12596 type = DECL_ORIGINAL_TYPE (decl);
12597
12598 gcc_assert (type != TREE_TYPE (decl));
12599 equate_type_number_to_die (TREE_TYPE (decl), type_die);
12600 }
12601 else
12602 type = TREE_TYPE (decl);
12603
12604 add_type_attribute (type_die, type, TREE_READONLY (decl),
12605 TREE_THIS_VOLATILE (decl), context_die);
12606 }
12607
12608 if (DECL_ABSTRACT (decl))
12609 equate_decl_number_to_die (decl, type_die);
12610}
12611
12612/* Generate a type description DIE. */
12613
12614static void
12615gen_type_die_with_usage (tree type, dw_die_ref context_die,
12616 enum debug_info_usage usage)
12617{
12618 int need_pop;
12619
12620 if (type == NULL_TREE || type == error_mark_node)
12621 return;
12622
12623 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12624 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
12625 {
12626 if (TREE_ASM_WRITTEN (type))
12627 return;
12628
12629 /* Prevent broken recursion; we can't hand off to the same type. */
12630 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
12631
12632 TREE_ASM_WRITTEN (type) = 1;
12633 gen_decl_die (TYPE_NAME (type), context_die);
12634 return;
12635 }
12636
12637 /* We are going to output a DIE to represent the unqualified version
12638 of this type (i.e. without any const or volatile qualifiers) so
12639 get the main variant (i.e. the unqualified version) of this type
12640 now. (Vectors are special because the debugging info is in the
12641 cloned type itself). */
12642 if (TREE_CODE (type) != VECTOR_TYPE)
12643 type = type_main_variant (type);
12644
12645 if (TREE_ASM_WRITTEN (type))
12646 return;
12647
12648 switch (TREE_CODE (type))
12649 {
12650 case ERROR_MARK:
12651 break;
12652
12653 case POINTER_TYPE:
12654 case REFERENCE_TYPE:
12655 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
12656 ensures that the gen_type_die recursion will terminate even if the
12657 type is recursive. Recursive types are possible in Ada. */
12658 /* ??? We could perhaps do this for all types before the switch
12659 statement. */
12660 TREE_ASM_WRITTEN (type) = 1;
12661
12662 /* For these types, all that is required is that we output a DIE (or a
12663 set of DIEs) to represent the "basis" type. */
12664 gen_type_die_with_usage (TREE_TYPE (type), context_die,
12665 DINFO_USAGE_IND_USE);
12666 break;
12667
12668 case OFFSET_TYPE:
12669 /* This code is used for C++ pointer-to-data-member types.
12670 Output a description of the relevant class type. */
12671 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die,
12672 DINFO_USAGE_IND_USE);
12673
12674 /* Output a description of the type of the object pointed to. */
12675 gen_type_die_with_usage (TREE_TYPE (type), context_die,
12676 DINFO_USAGE_IND_USE);
12677
12678 /* Now output a DIE to represent this pointer-to-data-member type
12679 itself. */
12680 gen_ptr_to_mbr_type_die (type, context_die);
12681 break;
12682
12683 case FUNCTION_TYPE:
12684 /* Force out return type (in case it wasn't forced out already). */
12685 gen_type_die_with_usage (TREE_TYPE (type), context_die,
12686 DINFO_USAGE_DIR_USE);
12687 gen_subroutine_type_die (type, context_die);
12688 break;
12689
12690 case METHOD_TYPE:
12691 /* Force out return type (in case it wasn't forced out already). */
12692 gen_type_die_with_usage (TREE_TYPE (type), context_die,
12693 DINFO_USAGE_DIR_USE);
12694 gen_subroutine_type_die (type, context_die);
12695 break;
12696
12697 case ARRAY_TYPE:
12698 gen_array_type_die (type, context_die);
12699 break;
12700
12701 case VECTOR_TYPE:
12702 gen_array_type_die (type, context_die);
12703 break;
12704
12705 case ENUMERAL_TYPE:
12706 case RECORD_TYPE:
12707 case UNION_TYPE:
12708 case QUAL_UNION_TYPE:
12709 /* If this is a nested type whose containing class hasn't been written
12710 out yet, writing it out will cover this one, too. This does not apply
12711 to instantiations of member class templates; they need to be added to
12712 the containing class as they are generated. FIXME: This hurts the
12713 idea of combining type decls from multiple TUs, since we can't predict
12714 what set of template instantiations we'll get. */
12715 if (TYPE_CONTEXT (type)
12716 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12717 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
12718 {
12719 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage);
12720
12721 if (TREE_ASM_WRITTEN (type))
12722 return;
12723
12724 /* If that failed, attach ourselves to the stub. */
12725 push_decl_scope (TYPE_CONTEXT (type));
12726 context_die = lookup_type_die (TYPE_CONTEXT (type));
12727 need_pop = 1;
12728 }
12729 else
12730 {
12731 declare_in_namespace (type, context_die);
12732 need_pop = 0;
12733 }
12734
12735 if (TREE_CODE (type) == ENUMERAL_TYPE)
12736 {
12737 /* This might have been written out by the call to
12738 declare_in_namespace. */
12739 if (!TREE_ASM_WRITTEN (type))
12740 gen_enumeration_type_die (type, context_die);
12741 }
12742 else
12743 gen_struct_or_union_type_die (type, context_die, usage);
12744
12745 if (need_pop)
12746 pop_decl_scope ();
12747
12748 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
12749 it up if it is ever completed. gen_*_type_die will set it for us
12750 when appropriate. */
12751 return;
12752
12753 case VOID_TYPE:
12754 case INTEGER_TYPE:
12755 case REAL_TYPE:
12756 case COMPLEX_TYPE:
12757 case BOOLEAN_TYPE:
12758 /* No DIEs needed for fundamental types. */
12759 break;
12760
12761 case LANG_TYPE:
12762 /* No Dwarf representation currently defined. */
12763 break;
12764
12765 default:
12766 gcc_unreachable ();
12767 }
12768
12769 TREE_ASM_WRITTEN (type) = 1;
12770}
12771
12772static void
12773gen_type_die (tree type, dw_die_ref context_die)
12774{
12775 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE);
12776}
12777
12778/* Generate a DIE for a tagged type instantiation. */
12779
12780static void
12781gen_tagged_type_instantiation_die (tree type, dw_die_ref context_die)
12782{
12783 if (type == NULL_TREE || type == error_mark_node)
12784 return;
12785
12786 /* We are going to output a DIE to represent the unqualified version of
12787 this type (i.e. without any const or volatile qualifiers) so make sure
12788 that we have the main variant (i.e. the unqualified version) of this
12789 type now. */
12790 gcc_assert (type == type_main_variant (type));
12791
12792 /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
12793 an instance of an unresolved type. */
12794
12795 switch (TREE_CODE (type))
12796 {
12797 case ERROR_MARK:
12798 break;
12799
12800 case ENUMERAL_TYPE:
12801 gen_inlined_enumeration_type_die (type, context_die);
12802 break;
12803
12804 case RECORD_TYPE:
12805 gen_inlined_structure_type_die (type, context_die);
12806 break;
12807
12808 case UNION_TYPE:
12809 case QUAL_UNION_TYPE:
12810 gen_inlined_union_type_die (type, context_die);
12811 break;
12812
12813 default:
12814 gcc_unreachable ();
12815 }
12816}
12817
12818/* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
12819 things which are local to the given block. */
12820
12821static void
12822gen_block_die (tree stmt, dw_die_ref context_die, int depth)
12823{
12824 int must_output_die = 0;
12825 tree origin;
12826 tree decl;
12827 enum tree_code origin_code;
12828
12829 /* Ignore blocks that are NULL. */
12830 if (stmt == NULL_TREE)
12831 return;
12832
12833 /* If the block is one fragment of a non-contiguous block, do not
12834 process the variables, since they will have been done by the
12835 origin block. Do process subblocks. */
12836 if (BLOCK_FRAGMENT_ORIGIN (stmt))
12837 {
12838 tree sub;
12839
12840 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
12841 gen_block_die (sub, context_die, depth + 1);
12842
12843 return;
12844 }
12845
12846 /* Determine the "ultimate origin" of this block. This block may be an
12847 inlined instance of an inlined instance of inline function, so we have
12848 to trace all of the way back through the origin chain to find out what
12849 sort of node actually served as the original seed for the creation of
12850 the current block. */
12851 origin = block_ultimate_origin (stmt);
12852 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
12853
12854 /* Determine if we need to output any Dwarf DIEs at all to represent this
12855 block. */
12856 if (origin_code == FUNCTION_DECL)
12857 /* The outer scopes for inlinings *must* always be represented. We
12858 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
12859 must_output_die = 1;
12860 else
12861 {
12862 /* In the case where the current block represents an inlining of the
12863 "body block" of an inline function, we must *NOT* output any DIE for
12864 this block because we have already output a DIE to represent the whole
12865 inlined function scope and the "body block" of any function doesn't
12866 really represent a different scope according to ANSI C rules. So we
12867 check here to make sure that this block does not represent a "body
12868 block inlining" before trying to set the MUST_OUTPUT_DIE flag. */
12869 if (! is_body_block (origin ? origin : stmt))
12870 {
12871 /* Determine if this block directly contains any "significant"
12872 local declarations which we will need to output DIEs for. */
12873 if (debug_info_level > DINFO_LEVEL_TERSE)
12874 /* We are not in terse mode so *any* local declaration counts
12875 as being a "significant" one. */
12876 must_output_die = (BLOCK_VARS (stmt) != NULL
12877 && (TREE_USED (stmt)
12878 || TREE_ASM_WRITTEN (stmt)
12879 || BLOCK_ABSTRACT (stmt)));
12880 else
12881 /* We are in terse mode, so only local (nested) function
12882 definitions count as "significant" local declarations. */
12883 for (decl = BLOCK_VARS (stmt);
12884 decl != NULL; decl = TREE_CHAIN (decl))
12885 if (TREE_CODE (decl) == FUNCTION_DECL
12886 && DECL_INITIAL (decl))
12887 {
12888 must_output_die = 1;
12889 break;
12890 }
12891 }
12892 }
12893
12894 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
12895 DIE for any block which contains no significant local declarations at
12896 all. Rather, in such cases we just call `decls_for_scope' so that any
12897 needed Dwarf info for any sub-blocks will get properly generated. Note
12898 that in terse mode, our definition of what constitutes a "significant"
12899 local declaration gets restricted to include only inlined function
12900 instances and local (nested) function definitions. */
12901 if (must_output_die)
12902 {
12903 if (origin_code == FUNCTION_DECL)
12904 gen_inlined_subroutine_die (stmt, context_die, depth);
12905 else
12906 gen_lexical_block_die (stmt, context_die, depth);
12907 }
12908 else
12909 decls_for_scope (stmt, context_die, depth);
12910}
12911
12912/* Generate all of the decls declared within a given scope and (recursively)
12913 all of its sub-blocks. */
12914
12915static void
12916decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
12917{
12918 tree decl;
12919 tree subblocks;
12920
12921 /* Ignore NULL blocks. */
12922 if (stmt == NULL_TREE)
12923 return;
12924
12925 if (TREE_USED (stmt))
12926 {
12927 /* Output the DIEs to represent all of the data objects and typedefs
12928 declared directly within this block but not within any nested
12929 sub-blocks. Also, nested function and tag DIEs have been
12930 generated with a parent of NULL; fix that up now. */
12931 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
12932 {
12933 dw_die_ref die;
12934
12935 if (TREE_CODE (decl) == FUNCTION_DECL)
12936 die = lookup_decl_die (decl);
12937 else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
12938 die = lookup_type_die (TREE_TYPE (decl));
12939 else
12940 die = NULL;
12941
12942 if (die != NULL && die->die_parent == NULL)
12943 add_child_die (context_die, die);
12944 /* Do not produce debug information for static variables since
12945 these might be optimized out. We are called for these later
12946 in cgraph_varpool_analyze_pending_decls. */
12947 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
12948 ;
12949 else
12950 gen_decl_die (decl, context_die);
12951 }
12952 }
12953
12954 /* If we're at -g1, we're not interested in subblocks. */
12955 if (debug_info_level <= DINFO_LEVEL_TERSE)
12956 return;
12957
12958 /* Output the DIEs to represent all sub-blocks (and the items declared
12959 therein) of this block. */
12960 for (subblocks = BLOCK_SUBBLOCKS (stmt);
12961 subblocks != NULL;
12962 subblocks = BLOCK_CHAIN (subblocks))
12963 gen_block_die (subblocks, context_die, depth + 1);
12964}
12965
12966/* Is this a typedef we can avoid emitting? */
12967
12968static inline int
12969is_redundant_typedef (tree decl)
12970{
12971 if (TYPE_DECL_IS_STUB (decl))
12972 return 1;
12973
12974 if (DECL_ARTIFICIAL (decl)
12975 && DECL_CONTEXT (decl)
12976 && is_tagged_type (DECL_CONTEXT (decl))
12977 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
12978 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
12979 /* Also ignore the artificial member typedef for the class name. */
12980 return 1;
12981
12982 return 0;
12983}
12984
12985/* Returns the DIE for decl. A DIE will always be returned. */
12986
12987static dw_die_ref
12988force_decl_die (tree decl)
12989{
12990 dw_die_ref decl_die;
12991 unsigned saved_external_flag;
12992 tree save_fn = NULL_TREE;
12993 decl_die = lookup_decl_die (decl);
12994 if (!decl_die)
12995 {
12996 dw_die_ref context_die;
12997 tree decl_context = DECL_CONTEXT (decl);
12998 if (decl_context)
12999 {
13000 /* Find die that represents this context. */
13001 if (TYPE_P (decl_context))
13002 context_die = force_type_die (decl_context);
13003 else
13004 context_die = force_decl_die (decl_context);
13005 }
13006 else
13007 context_die = comp_unit_die;
13008
13009 decl_die = lookup_decl_die (decl);
13010 if (decl_die)
13011 return decl_die;
13012
13013 switch (TREE_CODE (decl))
13014 {
13015 case FUNCTION_DECL:
13016 /* Clear current_function_decl, so that gen_subprogram_die thinks
13017 that this is a declaration. At this point, we just want to force
13018 declaration die. */
13019 save_fn = current_function_decl;
13020 current_function_decl = NULL_TREE;
13021 gen_subprogram_die (decl, context_die);
13022 current_function_decl = save_fn;
13023 break;
13024
13025 case VAR_DECL:
13026 /* Set external flag to force declaration die. Restore it after
13027 gen_decl_die() call. */
13028 saved_external_flag = DECL_EXTERNAL (decl);
13029 DECL_EXTERNAL (decl) = 1;
13030 gen_decl_die (decl, context_die);
13031 DECL_EXTERNAL (decl) = saved_external_flag;
13032 break;
13033
13034 case NAMESPACE_DECL:
13035 dwarf2out_decl (decl);
13036 break;
13037
13038 default:
13039 gcc_unreachable ();
13040 }
13041
13042 /* We should be able to find the DIE now. */
13043 if (!decl_die)
13044 decl_die = lookup_decl_die (decl);
13045 gcc_assert (decl_die);
13046 }
13047
13048 return decl_die;
13049}
13050
13051/* Returns the DIE for TYPE, that must not be a base type. A DIE is
13052 always returned. */
13053
13054static dw_die_ref
13055force_type_die (tree type)
13056{
13057 dw_die_ref type_die;
13058
13059 type_die = lookup_type_die (type);
13060 if (!type_die)
13061 {
13062 dw_die_ref context_die;
13063 if (TYPE_CONTEXT (type))
13064 {
13065 if (TYPE_P (TYPE_CONTEXT (type)))
13066 context_die = force_type_die (TYPE_CONTEXT (type));
13067 else
13068 context_die = force_decl_die (TYPE_CONTEXT (type));
13069 }
13070 else
13071 context_die = comp_unit_die;
13072
13073 type_die = lookup_type_die (type);
13074 if (type_die)
13075 return type_die;
13076 gen_type_die (type, context_die);
13077 type_die = lookup_type_die (type);
13078 gcc_assert (type_die);
13079 }
13080 return type_die;
13081}
13082
13083/* Force out any required namespaces to be able to output DECL,
13084 and return the new context_die for it, if it's changed. */
13085
13086static dw_die_ref
13087setup_namespace_context (tree thing, dw_die_ref context_die)
13088{
13089 tree context = (DECL_P (thing)
13090 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
13091 if (context && TREE_CODE (context) == NAMESPACE_DECL)
13092 /* Force out the namespace. */
13093 context_die = force_decl_die (context);
13094
13095 return context_die;
13096}
13097
13098/* Emit a declaration DIE for THING (which is either a DECL or a tagged
13099 type) within its namespace, if appropriate.
13100
13101 For compatibility with older debuggers, namespace DIEs only contain
13102 declarations; all definitions are emitted at CU scope. */
13103
13104static void
13105declare_in_namespace (tree thing, dw_die_ref context_die)
13106{
13107 dw_die_ref ns_context;
13108
13109 if (debug_info_level <= DINFO_LEVEL_TERSE)
13110 return;
13111
13112 /* If this decl is from an inlined function, then don't try to emit it in its
13113 namespace, as we will get confused. It would have already been emitted
13114 when the abstract instance of the inline function was emitted anyways. */
13115 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
13116 return;
13117
13118 ns_context = setup_namespace_context (thing, context_die);
13119
13120 if (ns_context != context_die)
13121 {
13122 if (DECL_P (thing))
13123 gen_decl_die (thing, ns_context);
13124 else
13125 gen_type_die (thing, ns_context);
13126 }
13127}
13128
13129/* Generate a DIE for a namespace or namespace alias. */
13130
13131static void
13132gen_namespace_die (tree decl)
13133{
13134 dw_die_ref context_die = setup_namespace_context (decl, comp_unit_die);
13135
13136 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
13137 they are an alias of. */
13138 if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
13139 {
13140 /* Output a real namespace. */
13141 dw_die_ref namespace_die
13142 = new_die (DW_TAG_namespace, context_die, decl);
13143 add_name_and_src_coords_attributes (namespace_die, decl);
13144 equate_decl_number_to_die (decl, namespace_die);
13145 }
13146 else
13147 {
13148 /* Output a namespace alias. */
13149
13150 /* Force out the namespace we are an alias of, if necessary. */
13151 dw_die_ref origin_die
13152 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
13153
13154 /* Now create the namespace alias DIE. */
13155 dw_die_ref namespace_die
13156 = new_die (DW_TAG_imported_declaration, context_die, decl);
13157 add_name_and_src_coords_attributes (namespace_die, decl);
13158 add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
13159 equate_decl_number_to_die (decl, namespace_die);
13160 }
13161}
13162
13163/* Generate Dwarf debug information for a decl described by DECL. */
13164
13165static void
13166gen_decl_die (tree decl, dw_die_ref context_die)
13167{
13168 tree origin;
13169
13170 if (DECL_P (decl) && DECL_IGNORED_P (decl))
13171 return;
13172
13173 switch (TREE_CODE (decl))
13174 {
13175 case ERROR_MARK:
13176 break;
13177
13178 case CONST_DECL:
13179 /* The individual enumerators of an enum type get output when we output
13180 the Dwarf representation of the relevant enum type itself. */
13181 break;
13182
13183 case FUNCTION_DECL:
13184 /* Don't output any DIEs to represent mere function declarations,
13185 unless they are class members or explicit block externs. */
13186 if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
13187 && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl)))
13188 break;
13189
13190#if 0
13191 /* FIXME */
13192 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
13193 on local redeclarations of global functions. That seems broken. */
13194 if (current_function_decl != decl)
13195 /* This is only a declaration. */;
13196#endif
13197
13198 /* If we're emitting a clone, emit info for the abstract instance. */
13199 if (DECL_ORIGIN (decl) != decl)
13200 dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl));
13201
13202 /* If we're emitting an out-of-line copy of an inline function,
13203 emit info for the abstract instance and set up to refer to it. */
13204 else if (cgraph_function_possibly_inlined_p (decl)
13205 && ! DECL_ABSTRACT (decl)
13206 && ! class_or_namespace_scope_p (context_die)
13207 /* dwarf2out_abstract_function won't emit a die if this is just
13208 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
13209 that case, because that works only if we have a die. */
13210 && DECL_INITIAL (decl) != NULL_TREE)
13211 {
13212 dwarf2out_abstract_function (decl);
13213 set_decl_origin_self (decl);
13214 }
13215
13216 /* Otherwise we're emitting the primary DIE for this decl. */
13217 else if (debug_info_level > DINFO_LEVEL_TERSE)
13218 {
13219 /* Before we describe the FUNCTION_DECL itself, make sure that we
13220 have described its return type. */
13221 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
13222
13223 /* And its virtual context. */
13224 if (DECL_VINDEX (decl) != NULL_TREE)
13225 gen_type_die (DECL_CONTEXT (decl), context_die);
13226
13227 /* And its containing type. */
13228 origin = decl_class_context (decl);
13229 if (origin != NULL_TREE)
13230 gen_type_die_for_member (origin, decl, context_die);
13231
13232 /* And its containing namespace. */
13233 declare_in_namespace (decl, context_die);
13234 }
13235
13236 /* Now output a DIE to represent the function itself. */
13237 gen_subprogram_die (decl, context_die);
13238 break;
13239
13240 case TYPE_DECL:
13241 /* If we are in terse mode, don't generate any DIEs to represent any
13242 actual typedefs. */
13243 if (debug_info_level <= DINFO_LEVEL_TERSE)
13244 break;
13245
13246 /* In the special case of a TYPE_DECL node representing the declaration
13247 of some type tag, if the given TYPE_DECL is marked as having been
13248 instantiated from some other (original) TYPE_DECL node (e.g. one which
13249 was generated within the original definition of an inline function) we
13250 have to generate a special (abbreviated) DW_TAG_structure_type,
13251 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. */
13252 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE
13253 && is_tagged_type (TREE_TYPE (decl)))
13254 {
13255 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
13256 break;
13257 }
13258
13259 if (is_redundant_typedef (decl))
13260 gen_type_die (TREE_TYPE (decl), context_die);
13261 else
13262 /* Output a DIE to represent the typedef itself. */
13263 gen_typedef_die (decl, context_die);
13264 break;
13265
13266 case LABEL_DECL:
13267 if (debug_info_level >= DINFO_LEVEL_NORMAL)
13268 gen_label_die (decl, context_die);
13269 break;
13270
13271 case VAR_DECL:
13272 case RESULT_DECL:
13273 /* If we are in terse mode, don't generate any DIEs to represent any
13274 variable declarations or definitions. */
13275 if (debug_info_level <= DINFO_LEVEL_TERSE)
13276 break;
13277
13278 /* Output any DIEs that are needed to specify the type of this data
13279 object. */
13280 gen_type_die (TREE_TYPE (decl), context_die);
13281
13282 /* And its containing type. */
13283 origin = decl_class_context (decl);
13284 if (origin != NULL_TREE)
13285 gen_type_die_for_member (origin, decl, context_die);
13286
13287 /* And its containing namespace. */
13288 declare_in_namespace (decl, context_die);
13289
13290 /* Now output the DIE to represent the data object itself. This gets
13291 complicated because of the possibility that the VAR_DECL really
13292 represents an inlined instance of a formal parameter for an inline
13293 function. */
13294 origin = decl_ultimate_origin (decl);
13295 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
13296 gen_formal_parameter_die (decl, context_die);
13297 else
13298 gen_variable_die (decl, context_die);
13299 break;
13300
13301 case FIELD_DECL:
13302 /* Ignore the nameless fields that are used to skip bits but handle C++
13303 anonymous unions and structs. */
13304 if (DECL_NAME (decl) != NULL_TREE
13305 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
13306 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
13307 {
13308 gen_type_die (member_declared_type (decl), context_die);
13309 gen_field_die (decl, context_die);
13310 }
13311 break;
13312
13313 case PARM_DECL:
13314 gen_type_die (TREE_TYPE (decl), context_die);
13315 gen_formal_parameter_die (decl, context_die);
13316 break;
13317
13318 case NAMESPACE_DECL:
13319 gen_namespace_die (decl);
13320 break;
13321
13322 default:
13323 /* Probably some frontend-internal decl. Assume we don't care. */
13324 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
13325 break;
13326 }
13327}
13328
13329/* Output debug information for global decl DECL. Called from toplev.c after
13330 compilation proper has finished. */
13331
13332static void
13333dwarf2out_global_decl (tree decl)
13334{
13335 /* Output DWARF2 information for file-scope tentative data object
13336 declarations, file-scope (extern) function declarations (which had no
13337 corresponding body) and file-scope tagged type declarations and
13338 definitions which have not yet been forced out. */
13339 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
13340 dwarf2out_decl (decl);
13341}
13342
13343/* Output debug information for type decl DECL. Called from toplev.c
13344 and from language front ends (to record built-in types). */
13345static void
13346dwarf2out_type_decl (tree decl, int local)
13347{
13348 if (!local)
13349 dwarf2out_decl (decl);
13350}
13351
13352/* Output debug information for imported module or decl. */
13353
13354static void
13355dwarf2out_imported_module_or_decl (tree decl, tree context)
13356{
13357 dw_die_ref imported_die, at_import_die;
13358 dw_die_ref scope_die;
13359 expanded_location xloc;
13360
13361 if (debug_info_level <= DINFO_LEVEL_TERSE)
13362 return;
13363
13364 gcc_assert (decl);
13365
13366 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
13367 We need decl DIE for reference and scope die. First, get DIE for the decl
13368 itself. */
13369
13370 /* Get the scope die for decl context. Use comp_unit_die for global module
13371 or decl. If die is not found for non globals, force new die. */
13372 if (!context)
13373 scope_die = comp_unit_die;
13374 else if (TYPE_P (context))
13375 {
13376 if (!should_emit_struct_debug (context, DINFO_USAGE_DIR_USE))
13377 return;
13378 scope_die = force_type_die (context);
13379 }
13380 else
13381 scope_die = force_decl_die (context);
13382
13383 /* For TYPE_DECL or CONST_DECL, lookup TREE_TYPE. */
13384 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
13385 {
13386 if (is_base_type (TREE_TYPE (decl)))
13387 at_import_die = base_type_die (TREE_TYPE (decl));
13388 else
13389 at_import_die = force_type_die (TREE_TYPE (decl));
13390 }
13391 else
13392 {
13393 at_import_die = lookup_decl_die (decl);
13394 if (!at_import_die)
13395 {
13396 /* If we're trying to avoid duplicate debug info, we may not have
13397 emitted the member decl for this field. Emit it now. */
13398 if (TREE_CODE (decl) == FIELD_DECL)
13399 {
13400 tree type = DECL_CONTEXT (decl);
13401 dw_die_ref type_context_die;
13402
13403 if (TYPE_CONTEXT (type))
13404 if (TYPE_P (TYPE_CONTEXT (type)))
13405 {
13406 if (!should_emit_struct_debug (TYPE_CONTEXT (type),
13407 DINFO_USAGE_DIR_USE))
13408 return;
13409 type_context_die = force_type_die (TYPE_CONTEXT (type));
13410 }
13411 else
13412 type_context_die = force_decl_die (TYPE_CONTEXT (type));
13413 else
13414 type_context_die = comp_unit_die;
13415 gen_type_die_for_member (type, decl, type_context_die);
13416 }
13417 at_import_die = force_decl_die (decl);
13418 }
13419 }
13420
13421 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
13422 if (TREE_CODE (decl) == NAMESPACE_DECL)
13423 imported_die = new_die (DW_TAG_imported_module, scope_die, context);
13424 else
13425 imported_die = new_die (DW_TAG_imported_declaration, scope_die, context);
13426
13427 xloc = expand_location (input_location);
13428 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
13429 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
13430 add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
13431}
13432
13433/* Write the debugging output for DECL. */
13434
13435void
13436dwarf2out_decl (tree decl)
13437{
13438 dw_die_ref context_die = comp_unit_die;
13439
13440 switch (TREE_CODE (decl))
13441 {
13442 case ERROR_MARK:
13443 return;
13444
13445 case FUNCTION_DECL:
13446 /* What we would really like to do here is to filter out all mere
13447 file-scope declarations of file-scope functions which are never
13448 referenced later within this translation unit (and keep all of ones
13449 that *are* referenced later on) but we aren't clairvoyant, so we have
13450 no idea which functions will be referenced in the future (i.e. later
13451 on within the current translation unit). So here we just ignore all
13452 file-scope function declarations which are not also definitions. If
13453 and when the debugger needs to know something about these functions,
13454 it will have to hunt around and find the DWARF information associated
13455 with the definition of the function.
13456
13457 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
13458 nodes represent definitions and which ones represent mere
13459 declarations. We have to check DECL_INITIAL instead. That's because
13460 the C front-end supports some weird semantics for "extern inline"
13461 function definitions. These can get inlined within the current
13462 translation unit (and thus, we need to generate Dwarf info for their
13463 abstract instances so that the Dwarf info for the concrete inlined
13464 instances can have something to refer to) but the compiler never
13465 generates any out-of-lines instances of such things (despite the fact
13466 that they *are* definitions).
13467
13468 The important point is that the C front-end marks these "extern
13469 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
13470 them anyway. Note that the C++ front-end also plays some similar games
13471 for inline function definitions appearing within include files which
13472 also contain `#pragma interface' pragmas. */
13473 if (DECL_INITIAL (decl) == NULL_TREE)
13474 return;
13475
13476 /* If we're a nested function, initially use a parent of NULL; if we're
13477 a plain function, this will be fixed up in decls_for_scope. If
13478 we're a method, it will be ignored, since we already have a DIE. */
13479 if (decl_function_context (decl)
13480 /* But if we're in terse mode, we don't care about scope. */
13481 && debug_info_level > DINFO_LEVEL_TERSE)
13482 context_die = NULL;
13483 break;
13484
13485 case VAR_DECL:
13486 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
13487 declaration and if the declaration was never even referenced from
13488 within this entire compilation unit. We suppress these DIEs in
13489 order to save space in the .debug section (by eliminating entries
13490 which are probably useless). Note that we must not suppress
13491 block-local extern declarations (whether used or not) because that
13492 would screw-up the debugger's name lookup mechanism and cause it to
13493 miss things which really ought to be in scope at a given point. */
13494 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
13495 return;
13496
13497 /* For local statics lookup proper context die. */
13498 if (TREE_STATIC (decl) && decl_function_context (decl))
13499 context_die = lookup_decl_die (DECL_CONTEXT (decl));
13500
13501 /* If we are in terse mode, don't generate any DIEs to represent any
13502 variable declarations or definitions. */
13503 if (debug_info_level <= DINFO_LEVEL_TERSE)
13504 return;
13505 break;
13506
13507 case NAMESPACE_DECL:
13508 if (debug_info_level <= DINFO_LEVEL_TERSE)
13509 return;
13510 if (lookup_decl_die (decl) != NULL)
13511 return;
13512 break;
13513
13514 case TYPE_DECL:
13515 /* Don't emit stubs for types unless they are needed by other DIEs. */
13516 if (TYPE_DECL_SUPPRESS_DEBUG (decl))
13517 return;
13518
13519 /* Don't bother trying to generate any DIEs to represent any of the
13520 normal built-in types for the language we are compiling. */
13521 if (DECL_IS_BUILTIN (decl))
13522 {
13523 /* OK, we need to generate one for `bool' so GDB knows what type
13524 comparisons have. */
13525 if (is_cxx ()
13526 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
13527 && ! DECL_IGNORED_P (decl))
13528 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
13529
13530 return;
13531 }
13532
13533 /* If we are in terse mode, don't generate any DIEs for types. */
13534 if (debug_info_level <= DINFO_LEVEL_TERSE)
13535 return;
13536
13537 /* If we're a function-scope tag, initially use a parent of NULL;
13538 this will be fixed up in decls_for_scope. */
13539 if (decl_function_context (decl))
13540 context_die = NULL;
13541
13542 break;
13543
13544 default:
13545 return;
13546 }
13547
13548 gen_decl_die (decl, context_die);
13549}
13550
13551/* Output a marker (i.e. a label) for the beginning of the generated code for
13552 a lexical block. */
13553
13554static void
13555dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
13556 unsigned int blocknum)
13557{
13558 switch_to_section (current_function_section ());
13559 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
13560}
13561
13562/* Output a marker (i.e. a label) for the end of the generated code for a
13563 lexical block. */
13564
13565static void
13566dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
13567{
13568 switch_to_section (current_function_section ());
13569 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
13570}
13571
13572/* Returns nonzero if it is appropriate not to emit any debugging
13573 information for BLOCK, because it doesn't contain any instructions.
13574
13575 Don't allow this for blocks with nested functions or local classes
13576 as we would end up with orphans, and in the presence of scheduling
13577 we may end up calling them anyway. */
13578
13579static bool
13580dwarf2out_ignore_block (tree block)
13581{
13582 tree decl;
13583
13584 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
13585 if (TREE_CODE (decl) == FUNCTION_DECL
13586 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
13587 return 0;
13588
13589 return 1;
13590}
13591
13592/* Hash table routines for file_hash. */
13593
13594static int
13595file_table_eq (const void *p1_p, const void *p2_p)
13596{
13597 const struct dwarf_file_data * p1 = p1_p;
13598 const char * p2 = p2_p;
13599 return strcmp (p1->filename, p2) == 0;
13600}
13601
13602static hashval_t
13603file_table_hash (const void *p_p)
13604{
13605 const struct dwarf_file_data * p = p_p;
13606 return htab_hash_string (p->filename);
13607}
13608
13609/* Lookup FILE_NAME (in the list of filenames that we know about here in
13610 dwarf2out.c) and return its "index". The index of each (known) filename is
13611 just a unique number which is associated with only that one filename. We
13612 need such numbers for the sake of generating labels (in the .debug_sfnames
13613 section) and references to those files numbers (in the .debug_srcinfo
13614 and.debug_macinfo sections). If the filename given as an argument is not
13615 found in our current list, add it to the list and assign it the next
13616 available unique index number. In order to speed up searches, we remember
13617 the index of the filename was looked up last. This handles the majority of
13618 all searches. */
13619
13620static struct dwarf_file_data *
13621lookup_filename (const char *file_name)
13622{
13623 void ** slot;
13624 struct dwarf_file_data * created;
13625
13626 /* Check to see if the file name that was searched on the previous
13627 call matches this file name. If so, return the index. */
13628 if (file_table_last_lookup
13629 && (file_name == file_table_last_lookup->filename
13630 || strcmp (file_table_last_lookup->filename, file_name) == 0))
13631 return file_table_last_lookup;
13632
13633 /* Didn't match the previous lookup, search the table. */
13634 slot = htab_find_slot_with_hash (file_table, file_name,
13635 htab_hash_string (file_name), INSERT);
13636 if (*slot)
13637 return *slot;
13638
13639 created = ggc_alloc (sizeof (struct dwarf_file_data));
13640 created->filename = file_name;
13641 created->emitted_number = 0;
13642 *slot = created;
13643 return created;
13644}
13645
13646/* If the assembler will construct the file table, then translate the compiler
13647 internal file table number into the assembler file table number, and emit
13648 a .file directive if we haven't already emitted one yet. The file table
13649 numbers are different because we prune debug info for unused variables and
13650 types, which may include filenames. */
13651
13652static int
13653maybe_emit_file (struct dwarf_file_data * fd)
13654{
13655 if (! fd->emitted_number)
13656 {
13657 if (last_emitted_file)
13658 fd->emitted_number = last_emitted_file->emitted_number + 1;
13659 else
13660 fd->emitted_number = 1;
13661 last_emitted_file = fd;
13662
13663 if (DWARF2_ASM_LINE_DEBUG_INFO)
13664 {
13665 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
13666 output_quoted_string (asm_out_file, fd->filename);
13667 fputc ('\n', asm_out_file);
13668 }
13669 }
13670
13671 return fd->emitted_number;
13672}
13673
13674/* Called by the final INSN scan whenever we see a var location. We
13675 use it to drop labels in the right places, and throw the location in
13676 our lookup table. */
13677
13678static void
13679dwarf2out_var_location (rtx loc_note)
13680{
13681 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
13682 struct var_loc_node *newloc;
13683 rtx prev_insn;
13684 static rtx last_insn;
13685 static const char *last_label;
13686 tree decl;
13687
13688 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
13689 return;
13690 prev_insn = PREV_INSN (loc_note);
13691
13692 newloc = ggc_alloc_cleared (sizeof (struct var_loc_node));
13693 /* If the insn we processed last time is the previous insn
13694 and it is also a var location note, use the label we emitted
13695 last time. */
13696 if (last_insn != NULL_RTX
13697 && last_insn == prev_insn
13698 && NOTE_P (prev_insn)
13699 && NOTE_LINE_NUMBER (prev_insn) == NOTE_INSN_VAR_LOCATION)
13700 {
13701 newloc->label = last_label;
13702 }
13703 else
13704 {
13705 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
13706 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
13707 loclabel_num++;
13708 newloc->label = ggc_strdup (loclabel);
13709 }
13710 newloc->var_loc_note = loc_note;
13711 newloc->next = NULL;
13712
13713 if (cfun && in_cold_section_p)
13714 newloc->section_label = cfun->cold_section_label;
13715 else
13716 newloc->section_label = text_section_label;
13717
13718 last_insn = loc_note;
13719 last_label = newloc->label;
13720 decl = NOTE_VAR_LOCATION_DECL (loc_note);
13721 add_var_loc_to_decl (decl, newloc);
13722}
13723
13724/* We need to reset the locations at the beginning of each
13725 function. We can't do this in the end_function hook, because the
13726 declarations that use the locations won't have been output when
13727 that hook is called. Also compute have_multiple_function_sections here. */
13728
13729static void
13730dwarf2out_begin_function (tree fun)
13731{
13732 htab_empty (decl_loc_table);
13733
13734 if (function_section (fun) != text_section)
13735 have_multiple_function_sections = true;
13736}
13737
13738/* Output a label to mark the beginning of a source code line entry
13739 and record information relating to this source line, in
13740 'line_info_table' for later output of the .debug_line section. */
13741
13742static void
13743dwarf2out_source_line (unsigned int line, const char *filename)
13744{
13745 if (debug_info_level >= DINFO_LEVEL_NORMAL
13746 && line != 0)
13747 {
13748 int file_num = maybe_emit_file (lookup_filename (filename));
13749
13750 switch_to_section (current_function_section ());
13751
13752 /* If requested, emit something human-readable. */
13753 if (flag_debug_asm)
13754 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
13755 filename, line);
13756
13757 if (DWARF2_ASM_LINE_DEBUG_INFO)
13758 {
13759 /* Emit the .loc directive understood by GNU as. */
13760 fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line);
13761
13762 /* Indicate that line number info exists. */
13763 line_info_table_in_use++;
13764 }
13765 else if (function_section (current_function_decl) != text_section)
13766 {
13767 dw_separate_line_info_ref line_info;
13768 targetm.asm_out.internal_label (asm_out_file,
13769 SEPARATE_LINE_CODE_LABEL,
13770 separate_line_info_table_in_use);
13771
13772 /* Expand the line info table if necessary. */
13773 if (separate_line_info_table_in_use
13774 == separate_line_info_table_allocated)
13775 {
13776 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13777 separate_line_info_table
13778 = ggc_realloc (separate_line_info_table,
13779 separate_line_info_table_allocated
13780 * sizeof (dw_separate_line_info_entry));
13781 memset (separate_line_info_table
13782 + separate_line_info_table_in_use,
13783 0,
13784 (LINE_INFO_TABLE_INCREMENT
13785 * sizeof (dw_separate_line_info_entry)));
13786 }
13787
13788 /* Add the new entry at the end of the line_info_table. */
13789 line_info
13790 = &separate_line_info_table[separate_line_info_table_in_use++];
13791 line_info->dw_file_num = file_num;
13792 line_info->dw_line_num = line;
13793 line_info->function = current_function_funcdef_no;
13794 }
13795 else
13796 {
13797 dw_line_info_ref line_info;
13798
13799 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
13800 line_info_table_in_use);
13801
13802 /* Expand the line info table if necessary. */
13803 if (line_info_table_in_use == line_info_table_allocated)
13804 {
13805 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13806 line_info_table
13807 = ggc_realloc (line_info_table,
13808 (line_info_table_allocated
13809 * sizeof (dw_line_info_entry)));
13810 memset (line_info_table + line_info_table_in_use, 0,
13811 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
13812 }
13813
13814 /* Add the new entry at the end of the line_info_table. */
13815 line_info = &line_info_table[line_info_table_in_use++];
13816 line_info->dw_file_num = file_num;
13817 line_info->dw_line_num = line;
13818 }
13819 }
13820}
13821
13822/* Record the beginning of a new source file. */
13823
13824static void
13825dwarf2out_start_source_file (unsigned int lineno, const char *filename)
13826{
13827 if (flag_eliminate_dwarf2_dups)
13828 {
13829 /* Record the beginning of the file for break_out_includes. */
13830 dw_die_ref bincl_die;
13831
13832 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
13833 add_AT_string (bincl_die, DW_AT_name, filename);
13834 }
13835
13836 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13837 {
13838 int file_num = maybe_emit_file (lookup_filename (filename));
13839
13840 switch_to_section (debug_macinfo_section);
13841 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
13842 dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
13843 lineno);
13844
13845 dw2_asm_output_data_uleb128 (file_num, "file %s", filename);
13846 }
13847}
13848
13849/* Record the end of a source file. */
13850
13851static void
13852dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
13853{
13854 if (flag_eliminate_dwarf2_dups)
13855 /* Record the end of the file for break_out_includes. */
13856 new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
13857
13858 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13859 {
13860 switch_to_section (debug_macinfo_section);
13861 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
13862 }
13863}
13864
13865/* Called from debug_define in toplev.c. The `buffer' parameter contains
13866 the tail part of the directive line, i.e. the part which is past the
13867 initial whitespace, #, whitespace, directive-name, whitespace part. */
13868
13869static void
13870dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
13871 const char *buffer ATTRIBUTE_UNUSED)
13872{
13873 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13874 {
13875 switch_to_section (debug_macinfo_section);
13876 dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
13877 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13878 dw2_asm_output_nstring (buffer, -1, "The macro");
13879 }
13880}
13881
13882/* Called from debug_undef in toplev.c. The `buffer' parameter contains
13883 the tail part of the directive line, i.e. the part which is past the
13884 initial whitespace, #, whitespace, directive-name, whitespace part. */
13885
13886static void
13887dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
13888 const char *buffer ATTRIBUTE_UNUSED)
13889{
13890 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13891 {
13892 switch_to_section (debug_macinfo_section);
13893 dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
13894 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13895 dw2_asm_output_nstring (buffer, -1, "The macro");
13896 }
13897}
13898
13899/* Set up for Dwarf output at the start of compilation. */
13900
13901static void
13902dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
13903{
13904 /* Allocate the file_table. */
13905 file_table = htab_create_ggc (50, file_table_hash,
13906 file_table_eq, NULL);
13907
13908 /* Allocate the decl_die_table. */
13909 decl_die_table = htab_create_ggc (10, decl_die_table_hash,
13910 decl_die_table_eq, NULL);
13911
13912 /* Allocate the decl_loc_table. */
13913 decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
13914 decl_loc_table_eq, NULL);
13915
13916 /* Allocate the initial hunk of the decl_scope_table. */
13917 decl_scope_table = VEC_alloc (tree, gc, 256);
13918
13919 /* Allocate the initial hunk of the abbrev_die_table. */
13920 abbrev_die_table = ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT
13921 * sizeof (dw_die_ref));
13922 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
13923 /* Zero-th entry is allocated, but unused. */
13924 abbrev_die_table_in_use = 1;
13925
13926 /* Allocate the initial hunk of the line_info_table. */
13927 line_info_table = ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT
13928 * sizeof (dw_line_info_entry));
13929 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
13930
13931 /* Zero-th entry is allocated, but unused. */
13932 line_info_table_in_use = 1;
13933
13934 /* Generate the initial DIE for the .debug section. Note that the (string)
13935 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
13936 will (typically) be a relative pathname and that this pathname should be
13937 taken as being relative to the directory from which the compiler was
13938 invoked when the given (base) source file was compiled. We will fill
13939 in this value in dwarf2out_finish. */
13940 comp_unit_die = gen_compile_unit_die (NULL);
13941
13942 incomplete_types = VEC_alloc (tree, gc, 64);
13943
13944 used_rtx_array = VEC_alloc (rtx, gc, 32);
13945
13946 debug_info_section = get_section (DEBUG_INFO_SECTION,
13947 SECTION_DEBUG, NULL);
13948 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
13949 SECTION_DEBUG, NULL);
13950 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
13951 SECTION_DEBUG, NULL);
13952 debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
13953 SECTION_DEBUG, NULL);
13954 debug_line_section = get_section (DEBUG_LINE_SECTION,
13955 SECTION_DEBUG, NULL);
13956 debug_loc_section = get_section (DEBUG_LOC_SECTION,
13957 SECTION_DEBUG, NULL);
13958 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
13959 SECTION_DEBUG, NULL);
13960 debug_str_section = get_section (DEBUG_STR_SECTION,
13961 DEBUG_STR_SECTION_FLAGS, NULL);
13962 debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
13963 SECTION_DEBUG, NULL);
13964 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
13965 SECTION_DEBUG, NULL);
13966
13967 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
13968 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
13969 DEBUG_ABBREV_SECTION_LABEL, 0);
13970 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
13971 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
13972 COLD_TEXT_SECTION_LABEL, 0);
13973 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
13974
13975 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
13976 DEBUG_INFO_SECTION_LABEL, 0);
13977 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
13978 DEBUG_LINE_SECTION_LABEL, 0);
13979 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
13980 DEBUG_RANGES_SECTION_LABEL, 0);
13981 switch_to_section (debug_abbrev_section);
13982 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
13983 switch_to_section (debug_info_section);
13984 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
13985 switch_to_section (debug_line_section);
13986 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
13987
13988 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13989 {
13990 switch_to_section (debug_macinfo_section);
13991 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
13992 DEBUG_MACINFO_SECTION_LABEL, 0);
13993 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
13994 }
13995
13996 switch_to_section (text_section);
13997 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
13998 if (flag_reorder_blocks_and_partition)
13999 {
14000 switch_to_section (unlikely_text_section ());
14001 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
14002 }
14003}
14004
14005/* A helper function for dwarf2out_finish called through
14006 ht_forall. Emit one queued .debug_str string. */
14007
14008static int
14009output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
14010{
14011 struct indirect_string_node *node = (struct indirect_string_node *) *h;
14012
14013 if (node->form == DW_FORM_strp)
14014 {
14015 switch_to_section (debug_str_section);
14016 ASM_OUTPUT_LABEL (asm_out_file, node->label);
14017 assemble_string (node->str, strlen (node->str) + 1);
14018 }
14019
14020 return 1;
14021}
14022
14023#if ENABLE_ASSERT_CHECKING
14024/* Verify that all marks are clear. */
14025
14026static void
14027verify_marks_clear (dw_die_ref die)
14028{
14029 dw_die_ref c;
14030
14031 gcc_assert (! die->die_mark);
14032 FOR_EACH_CHILD (die, c, verify_marks_clear (c));
14033}
14034#endif /* ENABLE_ASSERT_CHECKING */
14035
14036/* Clear the marks for a die and its children.
14037 Be cool if the mark isn't set. */
14038
14039static void
14040prune_unmark_dies (dw_die_ref die)
14041{
14042 dw_die_ref c;
14043
14044 if (die->die_mark)
14045 die->die_mark = 0;
14046 FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
14047}
14048
14049/* Given DIE that we're marking as used, find any other dies
14050 it references as attributes and mark them as used. */
14051
14052static void
14053prune_unused_types_walk_attribs (dw_die_ref die)
14054{
14055 dw_attr_ref a;
14056 unsigned ix;
14057
14058 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
14059 {
14060 if (a->dw_attr_val.val_class == dw_val_class_die_ref)
14061 {
14062 /* A reference to another DIE.
14063 Make sure that it will get emitted. */
14064 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
14065 }
14066 /* Set the string's refcount to 0 so that prune_unused_types_mark
14067 accounts properly for it. */
14068 if (AT_class (a) == dw_val_class_str)
14069 a->dw_attr_val.v.val_str->refcount = 0;
14070 }
14071}
14072
14073
14074/* Mark DIE as being used. If DOKIDS is true, then walk down
14075 to DIE's children. */
14076
14077static void
14078prune_unused_types_mark (dw_die_ref die, int dokids)
14079{
14080 dw_die_ref c;
14081
14082 if (die->die_mark == 0)
14083 {
14084 /* We haven't done this node yet. Mark it as used. */
14085 die->die_mark = 1;
14086
14087 /* We also have to mark its parents as used.
14088 (But we don't want to mark our parents' kids due to this.) */
14089 if (die->die_parent)
14090 prune_unused_types_mark (die->die_parent, 0);
14091
14092 /* Mark any referenced nodes. */
14093 prune_unused_types_walk_attribs (die);
14094
14095 /* If this node is a specification,
14096 also mark the definition, if it exists. */
14097 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
14098 prune_unused_types_mark (die->die_definition, 1);
14099 }
14100
14101 if (dokids && die->die_mark != 2)
14102 {
14103 /* We need to walk the children, but haven't done so yet.
14104 Remember that we've walked the kids. */
14105 die->die_mark = 2;
14106
14107 /* If this is an array type, we need to make sure our
14108 kids get marked, even if they're types. */
14109 if (die->die_tag == DW_TAG_array_type)
14110 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
14111 else
14112 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
14113 }
14114}
14115
14116
14117/* Walk the tree DIE and mark types that we actually use. */
14118
14119static void
14120prune_unused_types_walk (dw_die_ref die)
14121{
14122 dw_die_ref c;
14123
14124 /* Don't do anything if this node is already marked. */
14125 if (die->die_mark)
14126 return;
14127
14128 switch (die->die_tag) {
14129 case DW_TAG_const_type:
14130 case DW_TAG_packed_type:
14131 case DW_TAG_pointer_type:
14132 case DW_TAG_reference_type:
14133 case DW_TAG_volatile_type:
14134 case DW_TAG_typedef:
14135 case DW_TAG_array_type:
14136 case DW_TAG_structure_type:
14137 case DW_TAG_union_type:
14138 case DW_TAG_class_type:
14139 case DW_TAG_friend:
14140 case DW_TAG_variant_part:
14141 case DW_TAG_enumeration_type:
14142 case DW_TAG_subroutine_type:
14143 case DW_TAG_string_type:
14144 case DW_TAG_set_type:
14145 case DW_TAG_subrange_type:
14146 case DW_TAG_ptr_to_member_type:
14147 case DW_TAG_file_type:
14148 if (die->die_perennial_p)
14149 break;
14150
14151 /* It's a type node --- don't mark it. */
14152 return;
14153
14154 default:
14155 /* Mark everything else. */
14156 break;
14157 }
14158
14159 die->die_mark = 1;
14160
14161 /* Now, mark any dies referenced from here. */
14162 prune_unused_types_walk_attribs (die);
14163
14164 /* Mark children. */
14165 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
14166}
14167
14168/* Increment the string counts on strings referred to from DIE's
14169 attributes. */
14170
14171static void
14172prune_unused_types_update_strings (dw_die_ref die)
14173{
14174 dw_attr_ref a;
14175 unsigned ix;
14176
14177 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
14178 if (AT_class (a) == dw_val_class_str)
14179 {
14180 struct indirect_string_node *s = a->dw_attr_val.v.val_str;
14181 s->refcount++;
14182 /* Avoid unnecessarily putting strings that are used less than
14183 twice in the hash table. */
14184 if (s->refcount
14185 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
14186 {
14187 void ** slot;
14188 slot = htab_find_slot_with_hash (debug_str_hash, s->str,
14189 htab_hash_string (s->str),
14190 INSERT);
14191 gcc_assert (*slot == NULL);
14192 *slot = s;
14193 }
14194 }
14195}
14196
14197/* Remove from the tree DIE any dies that aren't marked. */
14198
14199static void
14200prune_unused_types_prune (dw_die_ref die)
14201{
14202 dw_die_ref c;
14203
14204 gcc_assert (die->die_mark);
14205 prune_unused_types_update_strings (die);
14206
14207 if (! die->die_child)
14208 return;
14209
14210 c = die->die_child;
14211 do {
14212 dw_die_ref prev = c;
14213 for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
14214 if (c == die->die_child)
14215 {
14216 /* No marked children between 'prev' and the end of the list. */
14217 if (prev == c)
14218 /* No marked children at all. */
14219 die->die_child = NULL;
14220 else
14221 {
14222 prev->die_sib = c->die_sib;
14223 die->die_child = prev;
14224 }
14225 return;
14226 }
14227
14228 if (c != prev->die_sib)
14229 prev->die_sib = c;
14230 prune_unused_types_prune (c);
14231 } while (c != die->die_child);
14232}
14233
14234
14235/* Remove dies representing declarations that we never use. */
14236
14237static void
14238prune_unused_types (void)
14239{
14240 unsigned int i;
14241 limbo_die_node *node;
14242
14243#if ENABLE_ASSERT_CHECKING
14244 /* All the marks should already be clear. */
14245 verify_marks_clear (comp_unit_die);
14246 for (node = limbo_die_list; node; node = node->next)
14247 verify_marks_clear (node->die);
14248#endif /* ENABLE_ASSERT_CHECKING */
14249
14250 /* Set the mark on nodes that are actually used. */
14251 prune_unused_types_walk (comp_unit_die);
14252 for (node = limbo_die_list; node; node = node->next)
14253 prune_unused_types_walk (node->die);
14254
14255 /* Also set the mark on nodes referenced from the
14256 pubname_table or arange_table. */
14257 for (i = 0; i < pubname_table_in_use; i++)
14258 prune_unused_types_mark (pubname_table[i].die, 1);
14259 for (i = 0; i < arange_table_in_use; i++)
14260 prune_unused_types_mark (arange_table[i], 1);
14261
14262 /* Get rid of nodes that aren't marked; and update the string counts. */
14263 if (debug_str_hash)
14264 htab_empty (debug_str_hash);
14265 prune_unused_types_prune (comp_unit_die);
14266 for (node = limbo_die_list; node; node = node->next)
14267 prune_unused_types_prune (node->die);
14268
14269 /* Leave the marks clear. */
14270 prune_unmark_dies (comp_unit_die);
14271 for (node = limbo_die_list; node; node = node->next)
14272 prune_unmark_dies (node->die);
14273}
14274
14275/* Set the parameter to true if there are any relative pathnames in
14276 the file table. */
14277static int
14278file_table_relative_p (void ** slot, void *param)
14279{
14280 bool *p = param;
14281 struct dwarf_file_data *d = *slot;
14282 if (d->emitted_number && d->filename[0] != DIR_SEPARATOR)
14283 {
14284 *p = true;
14285 return 0;
14286 }
14287 return 1;
14288}
14289
14290/* Output stuff that dwarf requires at the end of every file,
14291 and generate the DWARF-2 debugging info. */
14292
14293static void
14294dwarf2out_finish (const char *filename)
14295{
14296 limbo_die_node *node, *next_node;
14297 dw_die_ref die = 0;
14298
14299 /* Add the name for the main input file now. We delayed this from
14300 dwarf2out_init to avoid complications with PCH. */
14301 add_name_attribute (comp_unit_die, filename);
14302 if (filename[0] != DIR_SEPARATOR)
14303 add_comp_dir_attribute (comp_unit_die);
14304 else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
14305 {
14306 bool p = false;
14307 htab_traverse (file_table, file_table_relative_p, &p);
14308 if (p)
14309 add_comp_dir_attribute (comp_unit_die);
14310 }
14311
14312 /* Traverse the limbo die list, and add parent/child links. The only
14313 dies without parents that should be here are concrete instances of
14314 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
14315 For concrete instances, we can get the parent die from the abstract
14316 instance. */
14317 for (node = limbo_die_list; node; node = next_node)
14318 {
14319 next_node = node->next;
14320 die = node->die;
14321
14322 if (die->die_parent == NULL)
14323 {
14324 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
14325
14326 if (origin)
14327 add_child_die (origin->die_parent, die);
14328 else if (die == comp_unit_die)
14329 ;
14330 else if (errorcount > 0 || sorrycount > 0)
14331 /* It's OK to be confused by errors in the input. */
14332 add_child_die (comp_unit_die, die);
14333 else
14334 {
14335 /* In certain situations, the lexical block containing a
14336 nested function can be optimized away, which results
14337 in the nested function die being orphaned. Likewise
14338 with the return type of that nested function. Force
14339 this to be a child of the containing function.
14340
14341 It may happen that even the containing function got fully
14342 inlined and optimized out. In that case we are lost and
14343 assign the empty child. This should not be big issue as
14344 the function is likely unreachable too. */
14345 tree context = NULL_TREE;
14346
14347 gcc_assert (node->created_for);
14348
14349 if (DECL_P (node->created_for))
14350 context = DECL_CONTEXT (node->created_for);
14351 else if (TYPE_P (node->created_for))
14352 context = TYPE_CONTEXT (node->created_for);
14353
14354 gcc_assert (context
14355 && (TREE_CODE (context) == FUNCTION_DECL
14356 || TREE_CODE (context) == NAMESPACE_DECL));
14357
14358 origin = lookup_decl_die (context);
14359 if (origin)
14360 add_child_die (origin, die);
14361 else
14362 add_child_die (comp_unit_die, die);
14363 }
14364 }
14365 }
14366
14367 limbo_die_list = NULL;
14368
14369 /* Walk through the list of incomplete types again, trying once more to
14370 emit full debugging info for them. */
14371 retry_incomplete_types ();
14372
14373 if (flag_eliminate_unused_debug_types)
14374 prune_unused_types ();
14375
14376 /* Generate separate CUs for each of the include files we've seen.
14377 They will go into limbo_die_list. */
14378 if (flag_eliminate_dwarf2_dups)
14379 break_out_includes (comp_unit_die);
14380
14381 /* Traverse the DIE's and add add sibling attributes to those DIE's
14382 that have children. */
14383 add_sibling_attributes (comp_unit_die);
14384 for (node = limbo_die_list; node; node = node->next)
14385 add_sibling_attributes (node->die);
14386
14387 /* Output a terminator label for the .text section. */
14388 switch_to_section (text_section);
14389 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
14390 if (flag_reorder_blocks_and_partition)
14391 {
14392 switch_to_section (unlikely_text_section ());
14393 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
14394 }
14395
14396 /* We can only use the low/high_pc attributes if all of the code was
14397 in .text. */
14398 if (!have_multiple_function_sections)
14399 {
14400 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
14401 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
14402 }
14403
14404 /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate
14405 "base address". Use zero so that these addresses become absolute. */
14406 else if (have_location_lists || ranges_table_in_use)
14407 add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
14408
14409 /* Output location list section if necessary. */
14410 if (have_location_lists)
14411 {
14412 /* Output the location lists info. */
14413 switch_to_section (debug_loc_section);
14414 ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
14415 DEBUG_LOC_SECTION_LABEL, 0);
14416 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
14417 output_location_lists (die);
14418 }
14419
14420 if (debug_info_level >= DINFO_LEVEL_NORMAL)
14421 add_AT_lineptr (comp_unit_die, DW_AT_stmt_list,
14422 debug_line_section_label);
14423
14424 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14425 add_AT_macptr (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
14426
14427 /* Output all of the compilation units. We put the main one last so that
14428 the offsets are available to output_pubnames. */
14429 for (node = limbo_die_list; node; node = node->next)
14430 output_comp_unit (node->die, 0);
14431
14432 output_comp_unit (comp_unit_die, 0);
14433
14434 /* Output the abbreviation table. */
14435 switch_to_section (debug_abbrev_section);
14436 output_abbrev_section ();
14437
14438 /* Output public names table if necessary. */
14439 if (pubname_table_in_use)
14440 {
14441 switch_to_section (debug_pubnames_section);
14442 output_pubnames ();
14443 }
14444
14445 /* Output the address range information. We only put functions in the arange
14446 table, so don't write it out if we don't have any. */
14447 if (fde_table_in_use)
14448 {
14449 switch_to_section (debug_aranges_section);
14450 output_aranges ();
14451 }
14452
14453 /* Output ranges section if necessary. */
14454 if (ranges_table_in_use)
14455 {
14456 switch_to_section (debug_ranges_section);
14457 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
14458 output_ranges ();
14459 }
14460
14461 /* Output the source line correspondence table. We must do this
14462 even if there is no line information. Otherwise, on an empty
14463 translation unit, we will generate a present, but empty,
14464 .debug_info section. IRIX 6.5 `nm' will then complain when
14465 examining the file. This is done late so that any filenames
14466 used by the debug_info section are marked as 'used'. */
14467 if (! DWARF2_ASM_LINE_DEBUG_INFO)
14468 {
14469 switch_to_section (debug_line_section);
14470 output_line_info ();
14471 }
14472
14473 /* Have to end the macro section. */
14474 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14475 {
14476 switch_to_section (debug_macinfo_section);
14477 dw2_asm_output_data (1, 0, "End compilation unit");
14478 }
14479
14480 /* If we emitted any DW_FORM_strp form attribute, output the string
14481 table too. */
14482 if (debug_str_hash)
14483 htab_traverse (debug_str_hash, output_indirect_string, NULL);
14484}
14485#else
14486
14487/* This should never be used, but its address is needed for comparisons. */
14488const struct gcc_debug_hooks dwarf2_debug_hooks;
14489
14490#endif /* DWARF2_DEBUGGING_INFO */
14491
14492#include "gt-dwarf2out.h"