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
8 This file is part of GCC.
9
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 2, or (at your option) any later
13 version.
14
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING. If not, write to the Free
22 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
23 02110-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
72 static 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
112 int
dwarf2out_do_frame(void)113 dwarf2out_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. */
136 static 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. */
142 static 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. */
149 static GTY(()) VEC(tree,gc) *decl_scope_table;
150
151 /* Pointers to various DWARF2 sections. */
152 static GTY(()) section *debug_info_section;
153 static GTY(()) section *debug_abbrev_section;
154 static GTY(()) section *debug_aranges_section;
155 static GTY(()) section *debug_macinfo_section;
156 static GTY(()) section *debug_line_section;
157 static GTY(()) section *debug_loc_section;
158 static GTY(()) section *debug_pubnames_section;
159 static GTY(()) section *debug_str_section;
160 static GTY(()) section *debug_ranges_section;
161 static 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
168 typedef struct dw_cfi_struct *dw_cfi_ref;
169 typedef struct dw_fde_struct *dw_fde_ref;
170 typedef 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
177 enum 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
185 typedef 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 }
192 dw_cfi_oprnd;
193
194 typedef 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 }
203 dw_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. */
210 typedef 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
224 typedef 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 }
241 dw_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. */
301 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
302
303 /* Number of elements currently allocated for fde_table. */
304 static GTY(()) unsigned fde_table_allocated;
305
306 /* Number of elements in fde_table currently in use. */
307 static 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. */
314 static 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. */
321 static unsigned current_funcdef_fde;
322 #endif
323
324 struct indirect_string_node GTY(())
325 {
326 const char *str;
327 unsigned int refcount;
328 unsigned int form;
329 char *label;
330 };
331
332 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
333
334 static GTY(()) int dw2_string_counter;
335 static 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
341 static char *stripattributes (const char *);
342 static const char *dwarf_cfi_name (unsigned);
343 static dw_cfi_ref new_cfi (void);
344 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
345 static void add_fde_cfi (const char *, dw_cfi_ref);
346 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *);
347 static void lookup_cfa (dw_cfa_location *);
348 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
349 static void initial_return_save (rtx);
350 static HOST_WIDE_INT stack_adjust_offset (rtx);
351 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
352 static void output_call_frame_info (int);
353 static void dwarf2out_stack_adjust (rtx, bool);
354 static void flush_queued_reg_saves (void);
355 static bool clobbers_queued_reg_save (rtx);
356 static void dwarf2out_frame_debug_expr (rtx, const char *);
357
358 /* Support for complex CFA locations. */
359 static void output_cfa_loc (dw_cfi_ref);
360 static void get_cfa_from_loc_descr (dw_cfa_location *,
361 struct dw_loc_descr_struct *);
362 static struct dw_loc_descr_struct *build_cfa_loc
363 (dw_cfa_location *, HOST_WIDE_INT);
364 static 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
420 rtx
expand_builtin_dwarf_sp_column(void)421 expand_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
430 static inline char *
stripattributes(const char * s)431 stripattributes (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
447 void
expand_builtin_init_dwarf_reg_sizes(tree address)448 expand_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
502 static const char *
dwarf_cfi_name(unsigned int cfi_opc)503 dwarf_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
575 static inline dw_cfi_ref
new_cfi(void)576 new_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
589 static inline void
add_cfi(dw_cfi_ref * list_head,dw_cfi_ref cfi)590 add_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
603 char *
dwarf2out_cfi_label(void)604 dwarf2out_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
616 static void
add_fde_cfi(const char * label,dw_cfi_ref cfi)617 add_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
655 static void
lookup_cfa_1(dw_cfi_ref cfi,dw_cfa_location * loc)656 lookup_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
689 static void
lookup_cfa(dw_cfa_location * loc)690 lookup_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. */
711 static dw_cfa_location cfa;
712
713 /* The register used for saving registers to the stack, and its offset
714 from the CFA. */
715 static dw_cfa_location cfa_store;
716
717 /* The running total of the size of arguments pushed onto the stack. */
718 static HOST_WIDE_INT args_size;
719
720 /* The last args_size we actually output. */
721 static 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
727 void
dwarf2out_def_cfa(const char * label,unsigned int reg,HOST_WIDE_INT offset)728 dwarf2out_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
740 static bool
cfa_equal_p(const dw_cfa_location * loc1,const dw_cfa_location * loc2)741 cfa_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
753 static void
def_cfa_1(const char * label,dw_cfa_location * loc_p)754 def_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
847 static void
reg_save(const char * label,unsigned int reg,unsigned int sreg,HOST_WIDE_INT offset)848 reg_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
898 void
dwarf2out_window_save(const char * label)899 dwarf2out_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
910 void
dwarf2out_args_size(const char * label,HOST_WIDE_INT size)911 dwarf2out_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
929 void
dwarf2out_reg_save(const char * label,unsigned int reg,HOST_WIDE_INT offset)930 dwarf2out_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
938 void
dwarf2out_return_save(const char * label,HOST_WIDE_INT offset)939 dwarf2out_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
947 void
dwarf2out_return_reg(const char * label,unsigned int sreg)948 dwarf2out_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
956 static void
initial_return_save(rtx rtl)957 initial_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
1014 static HOST_WIDE_INT
stack_adjust_offset(rtx pattern)1015 stack_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
1088 static void
dwarf2out_stack_adjust(rtx insn,bool after_p)1089 dwarf2out_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
1177 struct 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
1185 static GTY(()) struct queued_reg_save *queued_reg_saves;
1186
1187 /* The caller's ORIG_REG is saved in SAVED_IN_REG. */
1188 struct 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. */
1197 static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1198 static GTY(()) size_t num_regs_saved_in_regs;
1199
1200 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1201 static 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
1206 static void
queue_reg_save(const char * label,rtx reg,rtx sreg,HOST_WIDE_INT offset)1207 queue_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
1234 static void
flush_queued_reg_saves(void)1235 flush_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
1275 static bool
clobbers_queued_reg_save(rtx insn)1276 clobbers_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
1296 void
dwarf2out_reg_save_reg(const char * label,rtx reg,rtx sreg)1297 dwarf2out_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
1320 static rtx
reg_saved_in(rtx reg)1321 reg_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. */
1343 static 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
1509 static void
dwarf2out_frame_debug_expr(rtx expr,const char * label)1510 dwarf2out_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
1859 void
dwarf2out_frame_debug(rtx insn,bool after_p)1860 dwarf2out_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. */
1914 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
1915 (enum dwarf_call_frame_info cfi);
1916
1917 static enum dw_cfi_oprnd_type
dw_cfi_oprnd1_desc(enum dwarf_call_frame_info cfi)1918 dw_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. */
1960 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
1961 (enum dwarf_call_frame_info cfi);
1962
1963 static enum dw_cfi_oprnd_type
dw_cfi_oprnd2_desc(enum dwarf_call_frame_info cfi)1964 dw_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
1989 static void
switch_to_eh_frame_section(void)1990 switch_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
2043 static void
output_cfi(dw_cfi_ref cfi,dw_fde_ref fde,int for_eh)2044 output_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
2168 static void
output_call_frame_info(int for_eh)2169 output_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
2522 void
dwarf2out_begin_prologue(unsigned int line ATTRIBUTE_UNUSED,const char * file ATTRIBUTE_UNUSED)2523 dwarf2out_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
2602 void
dwarf2out_end_epilogue(unsigned int line ATTRIBUTE_UNUSED,const char * file ATTRIBUTE_UNUSED)2603 dwarf2out_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
2618 void
dwarf2out_frame_init(void)2619 dwarf2out_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
2638 void
dwarf2out_frame_finish(void)2639 dwarf2out_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. */
2657 struct 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
2668 typedef struct dw_val_struct *dw_val_ref;
2669 typedef struct die_struct *dw_die_ref;
2670 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
2671 typedef 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
2677 enum 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
2701 typedef struct dw_long_long_struct GTY(())
2702 {
2703 unsigned long hi;
2704 unsigned long low;
2705 }
2706 dw_long_long_const;
2707
2708 /* Describe a floating point constant value, or a vector constant value. */
2709
2710 typedef struct dw_vec_struct GTY(())
2711 {
2712 unsigned char * GTY((length ("%h.length"))) array;
2713 unsigned length;
2714 unsigned elt_size;
2715 }
2716 dw_vec_const;
2717
2718 /* The dw_val_node describes an attribute's value, as it is
2719 represented internally. */
2720
2721 typedef 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 }
2747 dw_val_node;
2748
2749 /* Locations in memory are described using a sequence of stack machine
2750 operations. */
2751
2752 typedef 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 }
2760 dw_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. */
2765 typedef 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
2778 static const char *dwarf_stack_op_name (unsigned);
2779 static dw_loc_descr_ref new_loc_descr (enum dwarf_location_atom,
2780 unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
2781 static void add_loc_descr (dw_loc_descr_ref *, dw_loc_descr_ref);
2782 static unsigned long size_of_loc_descr (dw_loc_descr_ref);
2783 static unsigned long size_of_locs (dw_loc_descr_ref);
2784 static void output_loc_operands (dw_loc_descr_ref);
2785 static void output_loc_sequence (dw_loc_descr_ref);
2786
2787 /* Convert a DWARF stack opcode into its string name. */
2788
2789 static const char *
dwarf_stack_op_name(unsigned int op)2790 dwarf_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
3104 static inline dw_loc_descr_ref
new_loc_descr(enum dwarf_location_atom op,unsigned HOST_WIDE_INT oprnd1,unsigned HOST_WIDE_INT oprnd2)3105 new_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
3121 static inline void
add_loc_descr(dw_loc_descr_ref * list_head,dw_loc_descr_ref descr)3122 add_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
3135 static unsigned long
size_of_loc_descr(dw_loc_descr_ref loc)3136 size_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
3247 static unsigned long
size_of_locs(dw_loc_descr_ref loc)3248 size_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
3275 static void
output_loc_operands(dw_loc_descr_ref loc)3276 output_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
3415 static void
output_loc_sequence(dw_loc_descr_ref loc)3416 output_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
3432 static void
output_cfa_loc(dw_cfi_ref cfi)3433 output_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
3451 static struct dw_loc_descr_struct *
build_cfa_loc(dw_cfa_location * cfa,HOST_WIDE_INT offset)3452 build_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
3500 static void
get_cfa_from_loc_descr(dw_cfa_location * cfa,struct dw_loc_descr_struct * loc)3501 get_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. */
3609 static int output_indirect_string (void **, void *);
3610
3611 static void dwarf2out_init (const char *);
3612 static void dwarf2out_finish (const char *);
3613 static void dwarf2out_define (unsigned int, const char *);
3614 static void dwarf2out_undef (unsigned int, const char *);
3615 static void dwarf2out_start_source_file (unsigned, const char *);
3616 static void dwarf2out_end_source_file (unsigned);
3617 static void dwarf2out_begin_block (unsigned, unsigned);
3618 static void dwarf2out_end_block (unsigned, unsigned);
3619 static bool dwarf2out_ignore_block (tree);
3620 static void dwarf2out_global_decl (tree);
3621 static void dwarf2out_type_decl (tree, int);
3622 static void dwarf2out_imported_module_or_decl (tree, tree);
3623 static void dwarf2out_abstract_function (tree);
3624 static void dwarf2out_var_location (rtx);
3625 static void dwarf2out_begin_function (tree);
3626 static void dwarf2out_switch_text_section (void);
3627
3628 /* The debug hooks structure. */
3629
3630 const 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
3676 typedef long int dw_offset;
3677
3678 /* Define typedefs here to avoid circular dependencies. */
3679
3680 typedef struct dw_attr_struct *dw_attr_ref;
3681 typedef struct dw_line_info_struct *dw_line_info_ref;
3682 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
3683 typedef struct pubname_struct *pubname_ref;
3684 typedef 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
3691 typedef struct dw_line_info_struct GTY(())
3692 {
3693 unsigned long dw_file_num;
3694 unsigned long dw_line_num;
3695 }
3696 dw_line_info_entry;
3697
3698 /* Line information for functions in separate sections; each one gets its
3699 own sequence. */
3700 typedef 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 }
3706 dw_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
3712 typedef struct dw_attr_struct GTY(())
3713 {
3714 enum dwarf_attribute dw_attr;
3715 dw_val_node dw_attr_val;
3716 }
3717 dw_attr_node;
3718
3719 DEF_VEC_O(dw_attr_node);
3720 DEF_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
3726 typedef 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 }
3742 die_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
3755 typedef struct pubname_struct GTY(())
3756 {
3757 dw_die_ref die;
3758 char *name;
3759 }
3760 pubname_entry;
3761
3762 struct dw_ranges_struct GTY(())
3763 {
3764 int block_num;
3765 };
3766
3767 /* The limbo die list structure. */
3768 typedef struct limbo_die_struct GTY(())
3769 {
3770 dw_die_ref die;
3771 tree created_for;
3772 struct limbo_die_struct *next;
3773 }
3774 limbo_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. */
3853 static unsigned long next_die_offset;
3854 #endif
3855
3856 /* Record the root of the DIE's built for the current compilation unit. */
3857 static GTY(()) dw_die_ref comp_unit_die;
3858
3859 /* A list of DIEs with a NULL parent waiting to be relocated. */
3860 static GTY(()) limbo_die_node *limbo_die_list;
3861
3862 /* Filenames referenced by this compilation unit. */
3863 static 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. */
3867 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
3868
3869 /* Node of the variable location list. */
3870 struct 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. */
3879 struct 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 };
3890 typedef struct var_loc_list_def var_loc_list;
3891
3892
3893 /* Table of decl location linked lists. */
3894 static 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. */
3899 static GTY((length ("abbrev_die_table_allocated")))
3900 dw_die_ref *abbrev_die_table;
3901
3902 /* Number of elements currently allocated for abbrev_die_table. */
3903 static GTY(()) unsigned abbrev_die_table_allocated;
3904
3905 /* Number of elements in type_die_table currently in use. */
3906 static 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. */
3914 static 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. */
3918 static GTY(()) unsigned line_info_table_allocated;
3919
3920 /* Number of elements in line_info_table currently in use. */
3921 static GTY(()) unsigned line_info_table_in_use;
3922
3923 /* True if the compilation unit places functions in more than one section. */
3924 static 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. */
3928 static 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. */
3932 static GTY(()) unsigned separate_line_info_table_allocated;
3933
3934 /* Number of elements in separate_line_info_table currently in use. */
3935 static 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. */
3943 static GTY ((length ("pubname_table_allocated"))) pubname_ref pubname_table;
3944
3945 /* Number of elements currently allocated for pubname_table. */
3946 static GTY(()) unsigned pubname_table_allocated;
3947
3948 /* Number of elements in pubname_table currently in use. */
3949 static 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. */
3956 static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
3957
3958 /* Number of elements currently allocated for arange_table. */
3959 static GTY(()) unsigned arange_table_allocated;
3960
3961 /* Number of elements in arange_table currently in use. */
3962 static 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. */
3969 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
3970
3971 /* Number of elements currently allocated for ranges_table. */
3972 static GTY(()) unsigned ranges_table_allocated;
3973
3974 /* Number of elements in ranges_table currently in use. */
3975 static 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 */
3982 static GTY(()) bool have_location_lists;
3983
3984 /* Unique label counter. */
3985 static GTY(()) unsigned int loclabel_num;
3986
3987 #ifdef DWARF2_DEBUGGING_INFO
3988 /* Record whether the function being analyzed contains inlined functions. */
3989 static int current_function_has_inlines;
3990 #endif
3991 #if 0 && defined (MIPS_DEBUGGING_INFO)
3992 static int comp_unit_has_inlines;
3993 #endif
3994
3995 /* The last file entry emitted by maybe_emit_file(). */
3996 static GTY(()) struct dwarf_file_data * last_emitted_file;
3997
3998 /* Number of internal labels generated by gen_internal_sym(). */
3999 static GTY(()) int label_num;
4000
4001 /* Cached result of previous call to lookup_filename. */
4002 static 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. */
4008 static HOST_WIDE_INT frame_pointer_fb_offset;
4009
4010 /* Forward declarations for functions defined in this file. */
4011
4012 static int is_pseudo_reg (rtx);
4013 static tree type_main_variant (tree);
4014 static int is_tagged_type (tree);
4015 static const char *dwarf_tag_name (unsigned);
4016 static const char *dwarf_attr_name (unsigned);
4017 static const char *dwarf_form_name (unsigned);
4018 static tree decl_ultimate_origin (tree);
4019 static tree block_ultimate_origin (tree);
4020 static tree decl_class_context (tree);
4021 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
4022 static inline enum dw_val_class AT_class (dw_attr_ref);
4023 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
4024 static inline unsigned AT_flag (dw_attr_ref);
4025 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
4026 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
4027 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
4028 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
4029 static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long,
4030 unsigned long);
4031 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
4032 unsigned int, unsigned char *);
4033 static hashval_t debug_str_do_hash (const void *);
4034 static int debug_str_eq (const void *, const void *);
4035 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
4036 static inline const char *AT_string (dw_attr_ref);
4037 static int AT_string_form (dw_attr_ref);
4038 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
4039 static void add_AT_specification (dw_die_ref, dw_die_ref);
4040 static inline dw_die_ref AT_ref (dw_attr_ref);
4041 static inline int AT_ref_external (dw_attr_ref);
4042 static inline void set_AT_ref_external (dw_attr_ref, int);
4043 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
4044 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
4045 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
4046 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
4047 dw_loc_list_ref);
4048 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
4049 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
4050 static inline rtx AT_addr (dw_attr_ref);
4051 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
4052 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
4053 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
4054 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
4055 unsigned HOST_WIDE_INT);
4056 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
4057 unsigned long);
4058 static inline const char *AT_lbl (dw_attr_ref);
4059 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
4060 static const char *get_AT_low_pc (dw_die_ref);
4061 static const char *get_AT_hi_pc (dw_die_ref);
4062 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
4063 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
4064 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
4065 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
4066 static bool is_c_family (void);
4067 static bool is_cxx (void);
4068 static bool is_java (void);
4069 static bool is_fortran (void);
4070 static bool is_ada (void);
4071 static void remove_AT (dw_die_ref, enum dwarf_attribute);
4072 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
4073 static void add_child_die (dw_die_ref, dw_die_ref);
4074 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
4075 static dw_die_ref lookup_type_die (tree);
4076 static void equate_type_number_to_die (tree, dw_die_ref);
4077 static hashval_t decl_die_table_hash (const void *);
4078 static int decl_die_table_eq (const void *, const void *);
4079 static dw_die_ref lookup_decl_die (tree);
4080 static hashval_t decl_loc_table_hash (const void *);
4081 static int decl_loc_table_eq (const void *, const void *);
4082 static var_loc_list *lookup_decl_loc (tree);
4083 static void equate_decl_number_to_die (tree, dw_die_ref);
4084 static void add_var_loc_to_decl (tree, struct var_loc_node *);
4085 static void print_spaces (FILE *);
4086 static void print_die (dw_die_ref, FILE *);
4087 static void print_dwarf_line_table (FILE *);
4088 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
4089 static dw_die_ref pop_compile_unit (dw_die_ref);
4090 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
4091 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
4092 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
4093 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
4094 static int same_dw_val_p (dw_val_node *, dw_val_node *, int *);
4095 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
4096 static int same_die_p (dw_die_ref, dw_die_ref, int *);
4097 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
4098 static void compute_section_prefix (dw_die_ref);
4099 static int is_type_die (dw_die_ref);
4100 static int is_comdat_die (dw_die_ref);
4101 static int is_symbol_die (dw_die_ref);
4102 static void assign_symbol_names (dw_die_ref);
4103 static void break_out_includes (dw_die_ref);
4104 static hashval_t htab_cu_hash (const void *);
4105 static int htab_cu_eq (const void *, const void *);
4106 static void htab_cu_del (void *);
4107 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
4108 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
4109 static void add_sibling_attributes (dw_die_ref);
4110 static void build_abbrev_table (dw_die_ref);
4111 static void output_location_lists (dw_die_ref);
4112 static int constant_size (long unsigned);
4113 static unsigned long size_of_die (dw_die_ref);
4114 static void calc_die_sizes (dw_die_ref);
4115 static void mark_dies (dw_die_ref);
4116 static void unmark_dies (dw_die_ref);
4117 static void unmark_all_dies (dw_die_ref);
4118 static unsigned long size_of_pubnames (void);
4119 static unsigned long size_of_aranges (void);
4120 static enum dwarf_form value_format (dw_attr_ref);
4121 static void output_value_format (dw_attr_ref);
4122 static void output_abbrev_section (void);
4123 static void output_die_symbol (dw_die_ref);
4124 static void output_die (dw_die_ref);
4125 static void output_compilation_unit_header (void);
4126 static void output_comp_unit (dw_die_ref, int);
4127 static const char *dwarf2_name (tree, int);
4128 static void add_pubname (tree, dw_die_ref);
4129 static void output_pubnames (void);
4130 static void add_arange (tree, dw_die_ref);
4131 static void output_aranges (void);
4132 static unsigned int add_ranges (tree);
4133 static void output_ranges (void);
4134 static void output_line_info (void);
4135 static void output_file_names (void);
4136 static dw_die_ref base_type_die (tree);
4137 static tree root_type (tree);
4138 static int is_base_type (tree);
4139 static bool is_subrange_type (tree);
4140 static dw_die_ref subrange_type_die (tree, dw_die_ref);
4141 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
4142 static int type_is_enum (tree);
4143 static unsigned int dbx_reg_number (rtx);
4144 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
4145 static dw_loc_descr_ref reg_loc_descriptor (rtx);
4146 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int);
4147 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx);
4148 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
4149 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT);
4150 static int is_based_loc (rtx);
4151 static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode);
4152 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx);
4153 static dw_loc_descr_ref loc_descriptor (rtx);
4154 static dw_loc_descr_ref loc_descriptor_from_tree_1 (tree, int);
4155 static dw_loc_descr_ref loc_descriptor_from_tree (tree);
4156 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
4157 static tree field_type (tree);
4158 static unsigned int simple_type_align_in_bits (tree);
4159 static unsigned int simple_decl_align_in_bits (tree);
4160 static unsigned HOST_WIDE_INT simple_type_size_in_bits (tree);
4161 static HOST_WIDE_INT field_byte_offset (tree);
4162 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
4163 dw_loc_descr_ref);
4164 static void add_data_member_location_attribute (dw_die_ref, tree);
4165 static void add_const_value_attribute (dw_die_ref, rtx);
4166 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
4167 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
4168 static void insert_float (rtx, unsigned char *);
4169 static rtx rtl_for_decl_location (tree);
4170 static void add_location_or_const_value_attribute (dw_die_ref, tree,
4171 enum dwarf_attribute);
4172 static void tree_add_const_value_attribute (dw_die_ref, tree);
4173 static void add_name_attribute (dw_die_ref, const char *);
4174 static void add_comp_dir_attribute (dw_die_ref);
4175 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
4176 static void add_subscript_info (dw_die_ref, tree);
4177 static void add_byte_size_attribute (dw_die_ref, tree);
4178 static void add_bit_offset_attribute (dw_die_ref, tree);
4179 static void add_bit_size_attribute (dw_die_ref, tree);
4180 static void add_prototyped_attribute (dw_die_ref, tree);
4181 static void add_abstract_origin_attribute (dw_die_ref, tree);
4182 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
4183 static void add_src_coords_attributes (dw_die_ref, tree);
4184 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
4185 static void push_decl_scope (tree);
4186 static void pop_decl_scope (void);
4187 static dw_die_ref scope_die_for (tree, dw_die_ref);
4188 static inline int local_scope_p (dw_die_ref);
4189 static inline int class_or_namespace_scope_p (dw_die_ref);
4190 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
4191 static void add_calling_convention_attribute (dw_die_ref, tree);
4192 static const char *type_tag (tree);
4193 static tree member_declared_type (tree);
4194 #if 0
4195 static const char *decl_start_label (tree);
4196 #endif
4197 static void gen_array_type_die (tree, dw_die_ref);
4198 #if 0
4199 static void gen_entry_point_die (tree, dw_die_ref);
4200 #endif
4201 static void gen_inlined_enumeration_type_die (tree, dw_die_ref);
4202 static void gen_inlined_structure_type_die (tree, dw_die_ref);
4203 static void gen_inlined_union_type_die (tree, dw_die_ref);
4204 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
4205 static dw_die_ref gen_formal_parameter_die (tree, dw_die_ref);
4206 static void gen_unspecified_parameters_die (tree, dw_die_ref);
4207 static void gen_formal_types_die (tree, dw_die_ref);
4208 static void gen_subprogram_die (tree, dw_die_ref);
4209 static void gen_variable_die (tree, dw_die_ref);
4210 static void gen_label_die (tree, dw_die_ref);
4211 static void gen_lexical_block_die (tree, dw_die_ref, int);
4212 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
4213 static void gen_field_die (tree, dw_die_ref);
4214 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
4215 static dw_die_ref gen_compile_unit_die (const char *);
4216 static void gen_inheritance_die (tree, tree, dw_die_ref);
4217 static void gen_member_die (tree, dw_die_ref);
4218 static void gen_struct_or_union_type_die (tree, dw_die_ref);
4219 static void gen_subroutine_type_die (tree, dw_die_ref);
4220 static void gen_typedef_die (tree, dw_die_ref);
4221 static void gen_type_die (tree, dw_die_ref);
4222 static void gen_tagged_type_instantiation_die (tree, dw_die_ref);
4223 static void gen_block_die (tree, dw_die_ref, int);
4224 static void decls_for_scope (tree, dw_die_ref, int);
4225 static int is_redundant_typedef (tree);
4226 static void gen_namespace_die (tree);
4227 static void gen_decl_die (tree, dw_die_ref);
4228 static dw_die_ref force_decl_die (tree);
4229 static dw_die_ref force_type_die (tree);
4230 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
4231 static void declare_in_namespace (tree, dw_die_ref);
4232 static struct dwarf_file_data * lookup_filename (const char *);
4233 static void retry_incomplete_types (void);
4234 static void gen_type_die_for_member (tree, tree, dw_die_ref);
4235 static void splice_child_die (dw_die_ref, dw_die_ref);
4236 static int file_info_cmp (const void *, const void *);
4237 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
4238 const char *, const char *, unsigned);
4239 static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref,
4240 const char *, const char *,
4241 const char *);
4242 static void output_loc_list (dw_loc_list_ref);
4243 static char *gen_internal_sym (const char *);
4244
4245 static void prune_unmark_dies (dw_die_ref);
4246 static void prune_unused_types_mark (dw_die_ref, int);
4247 static void prune_unused_types_walk (dw_die_ref);
4248 static void prune_unused_types_walk_attribs (dw_die_ref);
4249 static void prune_unused_types_prune (dw_die_ref);
4250 static void prune_unused_types (void);
4251 static int maybe_emit_file (struct dwarf_file_data *fd);
4252
4253 /* Section names used to hold DWARF debugging information. */
4254 #ifndef DEBUG_INFO_SECTION
4255 #define DEBUG_INFO_SECTION ".debug_info"
4256 #endif
4257 #ifndef DEBUG_ABBREV_SECTION
4258 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
4259 #endif
4260 #ifndef DEBUG_ARANGES_SECTION
4261 #define DEBUG_ARANGES_SECTION ".debug_aranges"
4262 #endif
4263 #ifndef DEBUG_MACINFO_SECTION
4264 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
4265 #endif
4266 #ifndef DEBUG_LINE_SECTION
4267 #define DEBUG_LINE_SECTION ".debug_line"
4268 #endif
4269 #ifndef DEBUG_LOC_SECTION
4270 #define DEBUG_LOC_SECTION ".debug_loc"
4271 #endif
4272 #ifndef DEBUG_PUBNAMES_SECTION
4273 #define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
4274 #endif
4275 #ifndef DEBUG_STR_SECTION
4276 #define DEBUG_STR_SECTION ".debug_str"
4277 #endif
4278 #ifndef DEBUG_RANGES_SECTION
4279 #define DEBUG_RANGES_SECTION ".debug_ranges"
4280 #endif
4281
4282 /* Standard ELF section names for compiled code and data. */
4283 #ifndef TEXT_SECTION_NAME
4284 #define TEXT_SECTION_NAME ".text"
4285 #endif
4286
4287 /* Section flags for .debug_str section. */
4288 #define DEBUG_STR_SECTION_FLAGS \
4289 (HAVE_GAS_SHF_MERGE && flag_merge_constants \
4290 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
4291 : SECTION_DEBUG)
4292
4293 /* Labels we insert at beginning sections we can reference instead of
4294 the section names themselves. */
4295
4296 #ifndef TEXT_SECTION_LABEL
4297 #define TEXT_SECTION_LABEL "Ltext"
4298 #endif
4299 #ifndef COLD_TEXT_SECTION_LABEL
4300 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
4301 #endif
4302 #ifndef DEBUG_LINE_SECTION_LABEL
4303 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
4304 #endif
4305 #ifndef DEBUG_INFO_SECTION_LABEL
4306 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
4307 #endif
4308 #ifndef DEBUG_ABBREV_SECTION_LABEL
4309 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
4310 #endif
4311 #ifndef DEBUG_LOC_SECTION_LABEL
4312 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
4313 #endif
4314 #ifndef DEBUG_RANGES_SECTION_LABEL
4315 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
4316 #endif
4317 #ifndef DEBUG_MACINFO_SECTION_LABEL
4318 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
4319 #endif
4320
4321 /* Definitions of defaults for formats and names of various special
4322 (artificial) labels which may be generated within this file (when the -g
4323 options is used and DWARF2_DEBUGGING_INFO is in effect.
4324 If necessary, these may be overridden from within the tm.h file, but
4325 typically, overriding these defaults is unnecessary. */
4326
4327 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4328 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4329 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4330 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4331 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4332 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4333 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4334 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4335 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4336 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
4337
4338 #ifndef TEXT_END_LABEL
4339 #define TEXT_END_LABEL "Letext"
4340 #endif
4341 #ifndef COLD_END_LABEL
4342 #define COLD_END_LABEL "Letext_cold"
4343 #endif
4344 #ifndef BLOCK_BEGIN_LABEL
4345 #define BLOCK_BEGIN_LABEL "LBB"
4346 #endif
4347 #ifndef BLOCK_END_LABEL
4348 #define BLOCK_END_LABEL "LBE"
4349 #endif
4350 #ifndef LINE_CODE_LABEL
4351 #define LINE_CODE_LABEL "LM"
4352 #endif
4353 #ifndef SEPARATE_LINE_CODE_LABEL
4354 #define SEPARATE_LINE_CODE_LABEL "LSM"
4355 #endif
4356
4357 /* We allow a language front-end to designate a function that is to be
4358 called to "demangle" any name before it is put into a DIE. */
4359
4360 static const char *(*demangle_name_func) (const char *);
4361
4362 void
dwarf2out_set_demangle_name_func(const char * (* func)(const char *))4363 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
4364 {
4365 demangle_name_func = func;
4366 }
4367
4368 /* Test if rtl node points to a pseudo register. */
4369
4370 static inline int
is_pseudo_reg(rtx rtl)4371 is_pseudo_reg (rtx rtl)
4372 {
4373 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
4374 || (GET_CODE (rtl) == SUBREG
4375 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
4376 }
4377
4378 /* Return a reference to a type, with its const and volatile qualifiers
4379 removed. */
4380
4381 static inline tree
type_main_variant(tree type)4382 type_main_variant (tree type)
4383 {
4384 type = TYPE_MAIN_VARIANT (type);
4385
4386 /* ??? There really should be only one main variant among any group of
4387 variants of a given type (and all of the MAIN_VARIANT values for all
4388 members of the group should point to that one type) but sometimes the C
4389 front-end messes this up for array types, so we work around that bug
4390 here. */
4391 if (TREE_CODE (type) == ARRAY_TYPE)
4392 while (type != TYPE_MAIN_VARIANT (type))
4393 type = TYPE_MAIN_VARIANT (type);
4394
4395 return type;
4396 }
4397
4398 /* Return nonzero if the given type node represents a tagged type. */
4399
4400 static inline int
is_tagged_type(tree type)4401 is_tagged_type (tree type)
4402 {
4403 enum tree_code code = TREE_CODE (type);
4404
4405 return (code == RECORD_TYPE || code == UNION_TYPE
4406 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
4407 }
4408
4409 /* Convert a DIE tag into its string name. */
4410
4411 static const char *
dwarf_tag_name(unsigned int tag)4412 dwarf_tag_name (unsigned int tag)
4413 {
4414 switch (tag)
4415 {
4416 case DW_TAG_padding:
4417 return "DW_TAG_padding";
4418 case DW_TAG_array_type:
4419 return "DW_TAG_array_type";
4420 case DW_TAG_class_type:
4421 return "DW_TAG_class_type";
4422 case DW_TAG_entry_point:
4423 return "DW_TAG_entry_point";
4424 case DW_TAG_enumeration_type:
4425 return "DW_TAG_enumeration_type";
4426 case DW_TAG_formal_parameter:
4427 return "DW_TAG_formal_parameter";
4428 case DW_TAG_imported_declaration:
4429 return "DW_TAG_imported_declaration";
4430 case DW_TAG_label:
4431 return "DW_TAG_label";
4432 case DW_TAG_lexical_block:
4433 return "DW_TAG_lexical_block";
4434 case DW_TAG_member:
4435 return "DW_TAG_member";
4436 case DW_TAG_pointer_type:
4437 return "DW_TAG_pointer_type";
4438 case DW_TAG_reference_type:
4439 return "DW_TAG_reference_type";
4440 case DW_TAG_compile_unit:
4441 return "DW_TAG_compile_unit";
4442 case DW_TAG_string_type:
4443 return "DW_TAG_string_type";
4444 case DW_TAG_structure_type:
4445 return "DW_TAG_structure_type";
4446 case DW_TAG_subroutine_type:
4447 return "DW_TAG_subroutine_type";
4448 case DW_TAG_typedef:
4449 return "DW_TAG_typedef";
4450 case DW_TAG_union_type:
4451 return "DW_TAG_union_type";
4452 case DW_TAG_unspecified_parameters:
4453 return "DW_TAG_unspecified_parameters";
4454 case DW_TAG_variant:
4455 return "DW_TAG_variant";
4456 case DW_TAG_common_block:
4457 return "DW_TAG_common_block";
4458 case DW_TAG_common_inclusion:
4459 return "DW_TAG_common_inclusion";
4460 case DW_TAG_inheritance:
4461 return "DW_TAG_inheritance";
4462 case DW_TAG_inlined_subroutine:
4463 return "DW_TAG_inlined_subroutine";
4464 case DW_TAG_module:
4465 return "DW_TAG_module";
4466 case DW_TAG_ptr_to_member_type:
4467 return "DW_TAG_ptr_to_member_type";
4468 case DW_TAG_set_type:
4469 return "DW_TAG_set_type";
4470 case DW_TAG_subrange_type:
4471 return "DW_TAG_subrange_type";
4472 case DW_TAG_with_stmt:
4473 return "DW_TAG_with_stmt";
4474 case DW_TAG_access_declaration:
4475 return "DW_TAG_access_declaration";
4476 case DW_TAG_base_type:
4477 return "DW_TAG_base_type";
4478 case DW_TAG_catch_block:
4479 return "DW_TAG_catch_block";
4480 case DW_TAG_const_type:
4481 return "DW_TAG_const_type";
4482 case DW_TAG_constant:
4483 return "DW_TAG_constant";
4484 case DW_TAG_enumerator:
4485 return "DW_TAG_enumerator";
4486 case DW_TAG_file_type:
4487 return "DW_TAG_file_type";
4488 case DW_TAG_friend:
4489 return "DW_TAG_friend";
4490 case DW_TAG_namelist:
4491 return "DW_TAG_namelist";
4492 case DW_TAG_namelist_item:
4493 return "DW_TAG_namelist_item";
4494 case DW_TAG_namespace:
4495 return "DW_TAG_namespace";
4496 case DW_TAG_packed_type:
4497 return "DW_TAG_packed_type";
4498 case DW_TAG_subprogram:
4499 return "DW_TAG_subprogram";
4500 case DW_TAG_template_type_param:
4501 return "DW_TAG_template_type_param";
4502 case DW_TAG_template_value_param:
4503 return "DW_TAG_template_value_param";
4504 case DW_TAG_thrown_type:
4505 return "DW_TAG_thrown_type";
4506 case DW_TAG_try_block:
4507 return "DW_TAG_try_block";
4508 case DW_TAG_variant_part:
4509 return "DW_TAG_variant_part";
4510 case DW_TAG_variable:
4511 return "DW_TAG_variable";
4512 case DW_TAG_volatile_type:
4513 return "DW_TAG_volatile_type";
4514 case DW_TAG_imported_module:
4515 return "DW_TAG_imported_module";
4516 case DW_TAG_MIPS_loop:
4517 return "DW_TAG_MIPS_loop";
4518 case DW_TAG_format_label:
4519 return "DW_TAG_format_label";
4520 case DW_TAG_function_template:
4521 return "DW_TAG_function_template";
4522 case DW_TAG_class_template:
4523 return "DW_TAG_class_template";
4524 case DW_TAG_GNU_BINCL:
4525 return "DW_TAG_GNU_BINCL";
4526 case DW_TAG_GNU_EINCL:
4527 return "DW_TAG_GNU_EINCL";
4528 default:
4529 return "DW_TAG_<unknown>";
4530 }
4531 }
4532
4533 /* Convert a DWARF attribute code into its string name. */
4534
4535 static const char *
dwarf_attr_name(unsigned int attr)4536 dwarf_attr_name (unsigned int attr)
4537 {
4538 switch (attr)
4539 {
4540 case DW_AT_sibling:
4541 return "DW_AT_sibling";
4542 case DW_AT_location:
4543 return "DW_AT_location";
4544 case DW_AT_name:
4545 return "DW_AT_name";
4546 case DW_AT_ordering:
4547 return "DW_AT_ordering";
4548 case DW_AT_subscr_data:
4549 return "DW_AT_subscr_data";
4550 case DW_AT_byte_size:
4551 return "DW_AT_byte_size";
4552 case DW_AT_bit_offset:
4553 return "DW_AT_bit_offset";
4554 case DW_AT_bit_size:
4555 return "DW_AT_bit_size";
4556 case DW_AT_element_list:
4557 return "DW_AT_element_list";
4558 case DW_AT_stmt_list:
4559 return "DW_AT_stmt_list";
4560 case DW_AT_low_pc:
4561 return "DW_AT_low_pc";
4562 case DW_AT_high_pc:
4563 return "DW_AT_high_pc";
4564 case DW_AT_language:
4565 return "DW_AT_language";
4566 case DW_AT_member:
4567 return "DW_AT_member";
4568 case DW_AT_discr:
4569 return "DW_AT_discr";
4570 case DW_AT_discr_value:
4571 return "DW_AT_discr_value";
4572 case DW_AT_visibility:
4573 return "DW_AT_visibility";
4574 case DW_AT_import:
4575 return "DW_AT_import";
4576 case DW_AT_string_length:
4577 return "DW_AT_string_length";
4578 case DW_AT_common_reference:
4579 return "DW_AT_common_reference";
4580 case DW_AT_comp_dir:
4581 return "DW_AT_comp_dir";
4582 case DW_AT_const_value:
4583 return "DW_AT_const_value";
4584 case DW_AT_containing_type:
4585 return "DW_AT_containing_type";
4586 case DW_AT_default_value:
4587 return "DW_AT_default_value";
4588 case DW_AT_inline:
4589 return "DW_AT_inline";
4590 case DW_AT_is_optional:
4591 return "DW_AT_is_optional";
4592 case DW_AT_lower_bound:
4593 return "DW_AT_lower_bound";
4594 case DW_AT_producer:
4595 return "DW_AT_producer";
4596 case DW_AT_prototyped:
4597 return "DW_AT_prototyped";
4598 case DW_AT_return_addr:
4599 return "DW_AT_return_addr";
4600 case DW_AT_start_scope:
4601 return "DW_AT_start_scope";
4602 case DW_AT_stride_size:
4603 return "DW_AT_stride_size";
4604 case DW_AT_upper_bound:
4605 return "DW_AT_upper_bound";
4606 case DW_AT_abstract_origin:
4607 return "DW_AT_abstract_origin";
4608 case DW_AT_accessibility:
4609 return "DW_AT_accessibility";
4610 case DW_AT_address_class:
4611 return "DW_AT_address_class";
4612 case DW_AT_artificial:
4613 return "DW_AT_artificial";
4614 case DW_AT_base_types:
4615 return "DW_AT_base_types";
4616 case DW_AT_calling_convention:
4617 return "DW_AT_calling_convention";
4618 case DW_AT_count:
4619 return "DW_AT_count";
4620 case DW_AT_data_member_location:
4621 return "DW_AT_data_member_location";
4622 case DW_AT_decl_column:
4623 return "DW_AT_decl_column";
4624 case DW_AT_decl_file:
4625 return "DW_AT_decl_file";
4626 case DW_AT_decl_line:
4627 return "DW_AT_decl_line";
4628 case DW_AT_declaration:
4629 return "DW_AT_declaration";
4630 case DW_AT_discr_list:
4631 return "DW_AT_discr_list";
4632 case DW_AT_encoding:
4633 return "DW_AT_encoding";
4634 case DW_AT_external:
4635 return "DW_AT_external";
4636 case DW_AT_frame_base:
4637 return "DW_AT_frame_base";
4638 case DW_AT_friend:
4639 return "DW_AT_friend";
4640 case DW_AT_identifier_case:
4641 return "DW_AT_identifier_case";
4642 case DW_AT_macro_info:
4643 return "DW_AT_macro_info";
4644 case DW_AT_namelist_items:
4645 return "DW_AT_namelist_items";
4646 case DW_AT_priority:
4647 return "DW_AT_priority";
4648 case DW_AT_segment:
4649 return "DW_AT_segment";
4650 case DW_AT_specification:
4651 return "DW_AT_specification";
4652 case DW_AT_static_link:
4653 return "DW_AT_static_link";
4654 case DW_AT_type:
4655 return "DW_AT_type";
4656 case DW_AT_use_location:
4657 return "DW_AT_use_location";
4658 case DW_AT_variable_parameter:
4659 return "DW_AT_variable_parameter";
4660 case DW_AT_virtuality:
4661 return "DW_AT_virtuality";
4662 case DW_AT_vtable_elem_location:
4663 return "DW_AT_vtable_elem_location";
4664
4665 case DW_AT_allocated:
4666 return "DW_AT_allocated";
4667 case DW_AT_associated:
4668 return "DW_AT_associated";
4669 case DW_AT_data_location:
4670 return "DW_AT_data_location";
4671 case DW_AT_stride:
4672 return "DW_AT_stride";
4673 case DW_AT_entry_pc:
4674 return "DW_AT_entry_pc";
4675 case DW_AT_use_UTF8:
4676 return "DW_AT_use_UTF8";
4677 case DW_AT_extension:
4678 return "DW_AT_extension";
4679 case DW_AT_ranges:
4680 return "DW_AT_ranges";
4681 case DW_AT_trampoline:
4682 return "DW_AT_trampoline";
4683 case DW_AT_call_column:
4684 return "DW_AT_call_column";
4685 case DW_AT_call_file:
4686 return "DW_AT_call_file";
4687 case DW_AT_call_line:
4688 return "DW_AT_call_line";
4689
4690 case DW_AT_MIPS_fde:
4691 return "DW_AT_MIPS_fde";
4692 case DW_AT_MIPS_loop_begin:
4693 return "DW_AT_MIPS_loop_begin";
4694 case DW_AT_MIPS_tail_loop_begin:
4695 return "DW_AT_MIPS_tail_loop_begin";
4696 case DW_AT_MIPS_epilog_begin:
4697 return "DW_AT_MIPS_epilog_begin";
4698 case DW_AT_MIPS_loop_unroll_factor:
4699 return "DW_AT_MIPS_loop_unroll_factor";
4700 case DW_AT_MIPS_software_pipeline_depth:
4701 return "DW_AT_MIPS_software_pipeline_depth";
4702 case DW_AT_MIPS_linkage_name:
4703 return "DW_AT_MIPS_linkage_name";
4704 case DW_AT_MIPS_stride:
4705 return "DW_AT_MIPS_stride";
4706 case DW_AT_MIPS_abstract_name:
4707 return "DW_AT_MIPS_abstract_name";
4708 case DW_AT_MIPS_clone_origin:
4709 return "DW_AT_MIPS_clone_origin";
4710 case DW_AT_MIPS_has_inlines:
4711 return "DW_AT_MIPS_has_inlines";
4712
4713 case DW_AT_sf_names:
4714 return "DW_AT_sf_names";
4715 case DW_AT_src_info:
4716 return "DW_AT_src_info";
4717 case DW_AT_mac_info:
4718 return "DW_AT_mac_info";
4719 case DW_AT_src_coords:
4720 return "DW_AT_src_coords";
4721 case DW_AT_body_begin:
4722 return "DW_AT_body_begin";
4723 case DW_AT_body_end:
4724 return "DW_AT_body_end";
4725 case DW_AT_GNU_vector:
4726 return "DW_AT_GNU_vector";
4727
4728 case DW_AT_VMS_rtnbeg_pd_address:
4729 return "DW_AT_VMS_rtnbeg_pd_address";
4730
4731 default:
4732 return "DW_AT_<unknown>";
4733 }
4734 }
4735
4736 /* Convert a DWARF value form code into its string name. */
4737
4738 static const char *
dwarf_form_name(unsigned int form)4739 dwarf_form_name (unsigned int form)
4740 {
4741 switch (form)
4742 {
4743 case DW_FORM_addr:
4744 return "DW_FORM_addr";
4745 case DW_FORM_block2:
4746 return "DW_FORM_block2";
4747 case DW_FORM_block4:
4748 return "DW_FORM_block4";
4749 case DW_FORM_data2:
4750 return "DW_FORM_data2";
4751 case DW_FORM_data4:
4752 return "DW_FORM_data4";
4753 case DW_FORM_data8:
4754 return "DW_FORM_data8";
4755 case DW_FORM_string:
4756 return "DW_FORM_string";
4757 case DW_FORM_block:
4758 return "DW_FORM_block";
4759 case DW_FORM_block1:
4760 return "DW_FORM_block1";
4761 case DW_FORM_data1:
4762 return "DW_FORM_data1";
4763 case DW_FORM_flag:
4764 return "DW_FORM_flag";
4765 case DW_FORM_sdata:
4766 return "DW_FORM_sdata";
4767 case DW_FORM_strp:
4768 return "DW_FORM_strp";
4769 case DW_FORM_udata:
4770 return "DW_FORM_udata";
4771 case DW_FORM_ref_addr:
4772 return "DW_FORM_ref_addr";
4773 case DW_FORM_ref1:
4774 return "DW_FORM_ref1";
4775 case DW_FORM_ref2:
4776 return "DW_FORM_ref2";
4777 case DW_FORM_ref4:
4778 return "DW_FORM_ref4";
4779 case DW_FORM_ref8:
4780 return "DW_FORM_ref8";
4781 case DW_FORM_ref_udata:
4782 return "DW_FORM_ref_udata";
4783 case DW_FORM_indirect:
4784 return "DW_FORM_indirect";
4785 default:
4786 return "DW_FORM_<unknown>";
4787 }
4788 }
4789
4790 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
4791 instance of an inlined instance of a decl which is local to an inline
4792 function, so we have to trace all of the way back through the origin chain
4793 to find out what sort of node actually served as the original seed for the
4794 given block. */
4795
4796 static tree
decl_ultimate_origin(tree decl)4797 decl_ultimate_origin (tree decl)
4798 {
4799 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
4800 return NULL_TREE;
4801
4802 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
4803 nodes in the function to point to themselves; ignore that if
4804 we're trying to output the abstract instance of this function. */
4805 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
4806 return NULL_TREE;
4807
4808 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4809 most distant ancestor, this should never happen. */
4810 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
4811
4812 return DECL_ABSTRACT_ORIGIN (decl);
4813 }
4814
4815 /* Determine the "ultimate origin" of a block. The block may be an inlined
4816 instance of an inlined instance of a block which is local to an inline
4817 function, so we have to trace all of the way back through the origin chain
4818 to find out what sort of node actually served as the original seed for the
4819 given block. */
4820
4821 static tree
block_ultimate_origin(tree block)4822 block_ultimate_origin (tree block)
4823 {
4824 tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
4825
4826 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
4827 nodes in the function to point to themselves; ignore that if
4828 we're trying to output the abstract instance of this function. */
4829 if (BLOCK_ABSTRACT (block) && immediate_origin == block)
4830 return NULL_TREE;
4831
4832 if (immediate_origin == NULL_TREE)
4833 return NULL_TREE;
4834 else
4835 {
4836 tree ret_val;
4837 tree lookahead = immediate_origin;
4838
4839 do
4840 {
4841 ret_val = lookahead;
4842 lookahead = (TREE_CODE (ret_val) == BLOCK
4843 ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
4844 }
4845 while (lookahead != NULL && lookahead != ret_val);
4846
4847 /* The block's abstract origin chain may not be the *ultimate* origin of
4848 the block. It could lead to a DECL that has an abstract origin set.
4849 If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
4850 will give us if it has one). Note that DECL's abstract origins are
4851 supposed to be the most distant ancestor (or so decl_ultimate_origin
4852 claims), so we don't need to loop following the DECL origins. */
4853 if (DECL_P (ret_val))
4854 return DECL_ORIGIN (ret_val);
4855
4856 return ret_val;
4857 }
4858 }
4859
4860 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
4861 of a virtual function may refer to a base class, so we check the 'this'
4862 parameter. */
4863
4864 static tree
decl_class_context(tree decl)4865 decl_class_context (tree decl)
4866 {
4867 tree context = NULL_TREE;
4868
4869 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
4870 context = DECL_CONTEXT (decl);
4871 else
4872 context = TYPE_MAIN_VARIANT
4873 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
4874
4875 if (context && !TYPE_P (context))
4876 context = NULL_TREE;
4877
4878 return context;
4879 }
4880
4881 /* Add an attribute/value pair to a DIE. */
4882
4883 static inline void
add_dwarf_attr(dw_die_ref die,dw_attr_ref attr)4884 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
4885 {
4886 /* Maybe this should be an assert? */
4887 if (die == NULL)
4888 return;
4889
4890 if (die->die_attr == NULL)
4891 die->die_attr = VEC_alloc (dw_attr_node, gc, 1);
4892 VEC_safe_push (dw_attr_node, gc, die->die_attr, attr);
4893 }
4894
4895 static inline enum dw_val_class
AT_class(dw_attr_ref a)4896 AT_class (dw_attr_ref a)
4897 {
4898 return a->dw_attr_val.val_class;
4899 }
4900
4901 /* Add a flag value attribute to a DIE. */
4902
4903 static inline void
add_AT_flag(dw_die_ref die,enum dwarf_attribute attr_kind,unsigned int flag)4904 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
4905 {
4906 dw_attr_node attr;
4907
4908 attr.dw_attr = attr_kind;
4909 attr.dw_attr_val.val_class = dw_val_class_flag;
4910 attr.dw_attr_val.v.val_flag = flag;
4911 add_dwarf_attr (die, &attr);
4912 }
4913
4914 static inline unsigned
AT_flag(dw_attr_ref a)4915 AT_flag (dw_attr_ref a)
4916 {
4917 gcc_assert (a && AT_class (a) == dw_val_class_flag);
4918 return a->dw_attr_val.v.val_flag;
4919 }
4920
4921 /* Add a signed integer attribute value to a DIE. */
4922
4923 static inline void
add_AT_int(dw_die_ref die,enum dwarf_attribute attr_kind,HOST_WIDE_INT int_val)4924 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
4925 {
4926 dw_attr_node attr;
4927
4928 attr.dw_attr = attr_kind;
4929 attr.dw_attr_val.val_class = dw_val_class_const;
4930 attr.dw_attr_val.v.val_int = int_val;
4931 add_dwarf_attr (die, &attr);
4932 }
4933
4934 static inline HOST_WIDE_INT
AT_int(dw_attr_ref a)4935 AT_int (dw_attr_ref a)
4936 {
4937 gcc_assert (a && AT_class (a) == dw_val_class_const);
4938 return a->dw_attr_val.v.val_int;
4939 }
4940
4941 /* Add an unsigned integer attribute value to a DIE. */
4942
4943 static inline void
add_AT_unsigned(dw_die_ref die,enum dwarf_attribute attr_kind,unsigned HOST_WIDE_INT unsigned_val)4944 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
4945 unsigned HOST_WIDE_INT unsigned_val)
4946 {
4947 dw_attr_node attr;
4948
4949 attr.dw_attr = attr_kind;
4950 attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
4951 attr.dw_attr_val.v.val_unsigned = unsigned_val;
4952 add_dwarf_attr (die, &attr);
4953 }
4954
4955 static inline unsigned HOST_WIDE_INT
AT_unsigned(dw_attr_ref a)4956 AT_unsigned (dw_attr_ref a)
4957 {
4958 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
4959 return a->dw_attr_val.v.val_unsigned;
4960 }
4961
4962 /* Add an unsigned double integer attribute value to a DIE. */
4963
4964 static inline void
add_AT_long_long(dw_die_ref die,enum dwarf_attribute attr_kind,long unsigned int val_hi,long unsigned int val_low)4965 add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind,
4966 long unsigned int val_hi, long unsigned int val_low)
4967 {
4968 dw_attr_node attr;
4969
4970 attr.dw_attr = attr_kind;
4971 attr.dw_attr_val.val_class = dw_val_class_long_long;
4972 attr.dw_attr_val.v.val_long_long.hi = val_hi;
4973 attr.dw_attr_val.v.val_long_long.low = val_low;
4974 add_dwarf_attr (die, &attr);
4975 }
4976
4977 /* Add a floating point attribute value to a DIE and return it. */
4978
4979 static inline void
add_AT_vec(dw_die_ref die,enum dwarf_attribute attr_kind,unsigned int length,unsigned int elt_size,unsigned char * array)4980 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
4981 unsigned int length, unsigned int elt_size, unsigned char *array)
4982 {
4983 dw_attr_node attr;
4984
4985 attr.dw_attr = attr_kind;
4986 attr.dw_attr_val.val_class = dw_val_class_vec;
4987 attr.dw_attr_val.v.val_vec.length = length;
4988 attr.dw_attr_val.v.val_vec.elt_size = elt_size;
4989 attr.dw_attr_val.v.val_vec.array = array;
4990 add_dwarf_attr (die, &attr);
4991 }
4992
4993 /* Hash and equality functions for debug_str_hash. */
4994
4995 static hashval_t
debug_str_do_hash(const void * x)4996 debug_str_do_hash (const void *x)
4997 {
4998 return htab_hash_string (((const struct indirect_string_node *)x)->str);
4999 }
5000
5001 static int
debug_str_eq(const void * x1,const void * x2)5002 debug_str_eq (const void *x1, const void *x2)
5003 {
5004 return strcmp ((((const struct indirect_string_node *)x1)->str),
5005 (const char *)x2) == 0;
5006 }
5007
5008 /* Add a string attribute value to a DIE. */
5009
5010 static inline void
add_AT_string(dw_die_ref die,enum dwarf_attribute attr_kind,const char * str)5011 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
5012 {
5013 dw_attr_node attr;
5014 struct indirect_string_node *node;
5015 void **slot;
5016
5017 if (! debug_str_hash)
5018 debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
5019 debug_str_eq, NULL);
5020
5021 slot = htab_find_slot_with_hash (debug_str_hash, str,
5022 htab_hash_string (str), INSERT);
5023 if (*slot == NULL)
5024 *slot = ggc_alloc_cleared (sizeof (struct indirect_string_node));
5025 node = (struct indirect_string_node *) *slot;
5026 node->str = ggc_strdup (str);
5027 node->refcount++;
5028
5029 attr.dw_attr = attr_kind;
5030 attr.dw_attr_val.val_class = dw_val_class_str;
5031 attr.dw_attr_val.v.val_str = node;
5032 add_dwarf_attr (die, &attr);
5033 }
5034
5035 static inline const char *
AT_string(dw_attr_ref a)5036 AT_string (dw_attr_ref a)
5037 {
5038 gcc_assert (a && AT_class (a) == dw_val_class_str);
5039 return a->dw_attr_val.v.val_str->str;
5040 }
5041
5042 /* Find out whether a string should be output inline in DIE
5043 or out-of-line in .debug_str section. */
5044
5045 static int
AT_string_form(dw_attr_ref a)5046 AT_string_form (dw_attr_ref a)
5047 {
5048 struct indirect_string_node *node;
5049 unsigned int len;
5050 char label[32];
5051
5052 gcc_assert (a && AT_class (a) == dw_val_class_str);
5053
5054 node = a->dw_attr_val.v.val_str;
5055 if (node->form)
5056 return node->form;
5057
5058 len = strlen (node->str) + 1;
5059
5060 /* If the string is shorter or equal to the size of the reference, it is
5061 always better to put it inline. */
5062 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
5063 return node->form = DW_FORM_string;
5064
5065 /* If we cannot expect the linker to merge strings in .debug_str
5066 section, only put it into .debug_str if it is worth even in this
5067 single module. */
5068 if ((debug_str_section->common.flags & SECTION_MERGE) == 0
5069 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len)
5070 return node->form = DW_FORM_string;
5071
5072 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
5073 ++dw2_string_counter;
5074 node->label = xstrdup (label);
5075
5076 return node->form = DW_FORM_strp;
5077 }
5078
5079 /* Add a DIE reference attribute value to a DIE. */
5080
5081 static inline void
add_AT_die_ref(dw_die_ref die,enum dwarf_attribute attr_kind,dw_die_ref targ_die)5082 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
5083 {
5084 dw_attr_node attr;
5085
5086 attr.dw_attr = attr_kind;
5087 attr.dw_attr_val.val_class = dw_val_class_die_ref;
5088 attr.dw_attr_val.v.val_die_ref.die = targ_die;
5089 attr.dw_attr_val.v.val_die_ref.external = 0;
5090 add_dwarf_attr (die, &attr);
5091 }
5092
5093 /* Add an AT_specification attribute to a DIE, and also make the back
5094 pointer from the specification to the definition. */
5095
5096 static inline void
add_AT_specification(dw_die_ref die,dw_die_ref targ_die)5097 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
5098 {
5099 add_AT_die_ref (die, DW_AT_specification, targ_die);
5100 gcc_assert (!targ_die->die_definition);
5101 targ_die->die_definition = die;
5102 }
5103
5104 static inline dw_die_ref
AT_ref(dw_attr_ref a)5105 AT_ref (dw_attr_ref a)
5106 {
5107 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
5108 return a->dw_attr_val.v.val_die_ref.die;
5109 }
5110
5111 static inline int
AT_ref_external(dw_attr_ref a)5112 AT_ref_external (dw_attr_ref a)
5113 {
5114 if (a && AT_class (a) == dw_val_class_die_ref)
5115 return a->dw_attr_val.v.val_die_ref.external;
5116
5117 return 0;
5118 }
5119
5120 static inline void
set_AT_ref_external(dw_attr_ref a,int i)5121 set_AT_ref_external (dw_attr_ref a, int i)
5122 {
5123 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
5124 a->dw_attr_val.v.val_die_ref.external = i;
5125 }
5126
5127 /* Add an FDE reference attribute value to a DIE. */
5128
5129 static inline void
add_AT_fde_ref(dw_die_ref die,enum dwarf_attribute attr_kind,unsigned int targ_fde)5130 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
5131 {
5132 dw_attr_node attr;
5133
5134 attr.dw_attr = attr_kind;
5135 attr.dw_attr_val.val_class = dw_val_class_fde_ref;
5136 attr.dw_attr_val.v.val_fde_index = targ_fde;
5137 add_dwarf_attr (die, &attr);
5138 }
5139
5140 /* Add a location description attribute value to a DIE. */
5141
5142 static inline void
add_AT_loc(dw_die_ref die,enum dwarf_attribute attr_kind,dw_loc_descr_ref loc)5143 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
5144 {
5145 dw_attr_node attr;
5146
5147 attr.dw_attr = attr_kind;
5148 attr.dw_attr_val.val_class = dw_val_class_loc;
5149 attr.dw_attr_val.v.val_loc = loc;
5150 add_dwarf_attr (die, &attr);
5151 }
5152
5153 static inline dw_loc_descr_ref
AT_loc(dw_attr_ref a)5154 AT_loc (dw_attr_ref a)
5155 {
5156 gcc_assert (a && AT_class (a) == dw_val_class_loc);
5157 return a->dw_attr_val.v.val_loc;
5158 }
5159
5160 static inline void
add_AT_loc_list(dw_die_ref die,enum dwarf_attribute attr_kind,dw_loc_list_ref loc_list)5161 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
5162 {
5163 dw_attr_node attr;
5164
5165 attr.dw_attr = attr_kind;
5166 attr.dw_attr_val.val_class = dw_val_class_loc_list;
5167 attr.dw_attr_val.v.val_loc_list = loc_list;
5168 add_dwarf_attr (die, &attr);
5169 have_location_lists = true;
5170 }
5171
5172 static inline dw_loc_list_ref
AT_loc_list(dw_attr_ref a)5173 AT_loc_list (dw_attr_ref a)
5174 {
5175 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
5176 return a->dw_attr_val.v.val_loc_list;
5177 }
5178
5179 /* Add an address constant attribute value to a DIE. */
5180
5181 static inline void
add_AT_addr(dw_die_ref die,enum dwarf_attribute attr_kind,rtx addr)5182 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
5183 {
5184 dw_attr_node attr;
5185
5186 attr.dw_attr = attr_kind;
5187 attr.dw_attr_val.val_class = dw_val_class_addr;
5188 attr.dw_attr_val.v.val_addr = addr;
5189 add_dwarf_attr (die, &attr);
5190 }
5191
5192 /* Get the RTX from to an address DIE attribute. */
5193
5194 static inline rtx
AT_addr(dw_attr_ref a)5195 AT_addr (dw_attr_ref a)
5196 {
5197 gcc_assert (a && AT_class (a) == dw_val_class_addr);
5198 return a->dw_attr_val.v.val_addr;
5199 }
5200
5201 /* Add a file attribute value to a DIE. */
5202
5203 static inline void
add_AT_file(dw_die_ref die,enum dwarf_attribute attr_kind,struct dwarf_file_data * fd)5204 add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
5205 struct dwarf_file_data *fd)
5206 {
5207 dw_attr_node attr;
5208
5209 attr.dw_attr = attr_kind;
5210 attr.dw_attr_val.val_class = dw_val_class_file;
5211 attr.dw_attr_val.v.val_file = fd;
5212 add_dwarf_attr (die, &attr);
5213 }
5214
5215 /* Get the dwarf_file_data from a file DIE attribute. */
5216
5217 static inline struct dwarf_file_data *
AT_file(dw_attr_ref a)5218 AT_file (dw_attr_ref a)
5219 {
5220 gcc_assert (a && AT_class (a) == dw_val_class_file);
5221 return a->dw_attr_val.v.val_file;
5222 }
5223
5224 /* Add a label identifier attribute value to a DIE. */
5225
5226 static inline void
add_AT_lbl_id(dw_die_ref die,enum dwarf_attribute attr_kind,const char * lbl_id)5227 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
5228 {
5229 dw_attr_node attr;
5230
5231 attr.dw_attr = attr_kind;
5232 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
5233 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
5234 add_dwarf_attr (die, &attr);
5235 }
5236
5237 /* Add a section offset attribute value to a DIE, an offset into the
5238 debug_line section. */
5239
5240 static inline void
add_AT_lineptr(dw_die_ref die,enum dwarf_attribute attr_kind,const char * label)5241 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
5242 const char *label)
5243 {
5244 dw_attr_node attr;
5245
5246 attr.dw_attr = attr_kind;
5247 attr.dw_attr_val.val_class = dw_val_class_lineptr;
5248 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
5249 add_dwarf_attr (die, &attr);
5250 }
5251
5252 /* Add a section offset attribute value to a DIE, an offset into the
5253 debug_macinfo section. */
5254
5255 static inline void
add_AT_macptr(dw_die_ref die,enum dwarf_attribute attr_kind,const char * label)5256 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
5257 const char *label)
5258 {
5259 dw_attr_node attr;
5260
5261 attr.dw_attr = attr_kind;
5262 attr.dw_attr_val.val_class = dw_val_class_macptr;
5263 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
5264 add_dwarf_attr (die, &attr);
5265 }
5266
5267 /* Add an offset attribute value to a DIE. */
5268
5269 static inline void
add_AT_offset(dw_die_ref die,enum dwarf_attribute attr_kind,unsigned HOST_WIDE_INT offset)5270 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
5271 unsigned HOST_WIDE_INT offset)
5272 {
5273 dw_attr_node attr;
5274
5275 attr.dw_attr = attr_kind;
5276 attr.dw_attr_val.val_class = dw_val_class_offset;
5277 attr.dw_attr_val.v.val_offset = offset;
5278 add_dwarf_attr (die, &attr);
5279 }
5280
5281 /* Add an range_list attribute value to a DIE. */
5282
5283 static void
add_AT_range_list(dw_die_ref die,enum dwarf_attribute attr_kind,long unsigned int offset)5284 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
5285 long unsigned int offset)
5286 {
5287 dw_attr_node attr;
5288
5289 attr.dw_attr = attr_kind;
5290 attr.dw_attr_val.val_class = dw_val_class_range_list;
5291 attr.dw_attr_val.v.val_offset = offset;
5292 add_dwarf_attr (die, &attr);
5293 }
5294
5295 static inline const char *
AT_lbl(dw_attr_ref a)5296 AT_lbl (dw_attr_ref a)
5297 {
5298 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
5299 || AT_class (a) == dw_val_class_lineptr
5300 || AT_class (a) == dw_val_class_macptr));
5301 return a->dw_attr_val.v.val_lbl_id;
5302 }
5303
5304 /* Get the attribute of type attr_kind. */
5305
5306 static dw_attr_ref
get_AT(dw_die_ref die,enum dwarf_attribute attr_kind)5307 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5308 {
5309 dw_attr_ref a;
5310 unsigned ix;
5311 dw_die_ref spec = NULL;
5312
5313 if (! die)
5314 return NULL;
5315
5316 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
5317 if (a->dw_attr == attr_kind)
5318 return a;
5319 else if (a->dw_attr == DW_AT_specification
5320 || a->dw_attr == DW_AT_abstract_origin)
5321 spec = AT_ref (a);
5322
5323 if (spec)
5324 return get_AT (spec, attr_kind);
5325
5326 return NULL;
5327 }
5328
5329 /* Return the "low pc" attribute value, typically associated with a subprogram
5330 DIE. Return null if the "low pc" attribute is either not present, or if it
5331 cannot be represented as an assembler label identifier. */
5332
5333 static inline const char *
get_AT_low_pc(dw_die_ref die)5334 get_AT_low_pc (dw_die_ref die)
5335 {
5336 dw_attr_ref a = get_AT (die, DW_AT_low_pc);
5337
5338 return a ? AT_lbl (a) : NULL;
5339 }
5340
5341 /* Return the "high pc" attribute value, typically associated with a subprogram
5342 DIE. Return null if the "high pc" attribute is either not present, or if it
5343 cannot be represented as an assembler label identifier. */
5344
5345 static inline const char *
get_AT_hi_pc(dw_die_ref die)5346 get_AT_hi_pc (dw_die_ref die)
5347 {
5348 dw_attr_ref a = get_AT (die, DW_AT_high_pc);
5349
5350 return a ? AT_lbl (a) : NULL;
5351 }
5352
5353 /* Return the value of the string attribute designated by ATTR_KIND, or
5354 NULL if it is not present. */
5355
5356 static inline const char *
get_AT_string(dw_die_ref die,enum dwarf_attribute attr_kind)5357 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
5358 {
5359 dw_attr_ref a = get_AT (die, attr_kind);
5360
5361 return a ? AT_string (a) : NULL;
5362 }
5363
5364 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
5365 if it is not present. */
5366
5367 static inline int
get_AT_flag(dw_die_ref die,enum dwarf_attribute attr_kind)5368 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
5369 {
5370 dw_attr_ref a = get_AT (die, attr_kind);
5371
5372 return a ? AT_flag (a) : 0;
5373 }
5374
5375 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5376 if it is not present. */
5377
5378 static inline unsigned
get_AT_unsigned(dw_die_ref die,enum dwarf_attribute attr_kind)5379 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
5380 {
5381 dw_attr_ref a = get_AT (die, attr_kind);
5382
5383 return a ? AT_unsigned (a) : 0;
5384 }
5385
5386 static inline dw_die_ref
get_AT_ref(dw_die_ref die,enum dwarf_attribute attr_kind)5387 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
5388 {
5389 dw_attr_ref a = get_AT (die, attr_kind);
5390
5391 return a ? AT_ref (a) : NULL;
5392 }
5393
5394 static inline struct dwarf_file_data *
get_AT_file(dw_die_ref die,enum dwarf_attribute attr_kind)5395 get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
5396 {
5397 dw_attr_ref a = get_AT (die, attr_kind);
5398
5399 return a ? AT_file (a) : NULL;
5400 }
5401
5402 /* Return TRUE if the language is C or C++. */
5403
5404 static inline bool
is_c_family(void)5405 is_c_family (void)
5406 {
5407 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5408
5409 return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_ObjC
5410 || lang == DW_LANG_C99
5411 || lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus);
5412 }
5413
5414 /* Return TRUE if the language is C++. */
5415
5416 static inline bool
is_cxx(void)5417 is_cxx (void)
5418 {
5419 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5420
5421 return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
5422 }
5423
5424 /* Return TRUE if the language is Fortran. */
5425
5426 static inline bool
is_fortran(void)5427 is_fortran (void)
5428 {
5429 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5430
5431 return (lang == DW_LANG_Fortran77
5432 || lang == DW_LANG_Fortran90
5433 || lang == DW_LANG_Fortran95);
5434 }
5435
5436 /* Return TRUE if the language is Java. */
5437
5438 static inline bool
is_java(void)5439 is_java (void)
5440 {
5441 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5442
5443 return lang == DW_LANG_Java;
5444 }
5445
5446 /* Return TRUE if the language is Ada. */
5447
5448 static inline bool
is_ada(void)5449 is_ada (void)
5450 {
5451 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5452
5453 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
5454 }
5455
5456 /* Remove the specified attribute if present. */
5457
5458 static void
remove_AT(dw_die_ref die,enum dwarf_attribute attr_kind)5459 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5460 {
5461 dw_attr_ref a;
5462 unsigned ix;
5463
5464 if (! die)
5465 return;
5466
5467 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
5468 if (a->dw_attr == attr_kind)
5469 {
5470 if (AT_class (a) == dw_val_class_str)
5471 if (a->dw_attr_val.v.val_str->refcount)
5472 a->dw_attr_val.v.val_str->refcount--;
5473
5474 /* VEC_ordered_remove should help reduce the number of abbrevs
5475 that are needed. */
5476 VEC_ordered_remove (dw_attr_node, die->die_attr, ix);
5477 return;
5478 }
5479 }
5480
5481 /* Remove CHILD from its parent. PREV must have the property that
5482 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
5483
5484 static void
remove_child_with_prev(dw_die_ref child,dw_die_ref prev)5485 remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
5486 {
5487 gcc_assert (child->die_parent == prev->die_parent);
5488 gcc_assert (prev->die_sib == child);
5489 if (prev == child)
5490 {
5491 gcc_assert (child->die_parent->die_child == child);
5492 prev = NULL;
5493 }
5494 else
5495 prev->die_sib = child->die_sib;
5496 if (child->die_parent->die_child == child)
5497 child->die_parent->die_child = prev;
5498 }
5499
5500 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
5501 matches TAG. */
5502
5503 static void
remove_child_TAG(dw_die_ref die,enum dwarf_tag tag)5504 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
5505 {
5506 dw_die_ref c;
5507
5508 c = die->die_child;
5509 if (c) do {
5510 dw_die_ref prev = c;
5511 c = c->die_sib;
5512 while (c->die_tag == tag)
5513 {
5514 remove_child_with_prev (c, prev);
5515 /* Might have removed every child. */
5516 if (c == c->die_sib)
5517 return;
5518 c = c->die_sib;
5519 }
5520 } while (c != die->die_child);
5521 }
5522
5523 /* Add a CHILD_DIE as the last child of DIE. */
5524
5525 static void
add_child_die(dw_die_ref die,dw_die_ref child_die)5526 add_child_die (dw_die_ref die, dw_die_ref child_die)
5527 {
5528 /* FIXME this should probably be an assert. */
5529 if (! die || ! child_die)
5530 return;
5531 gcc_assert (die != child_die);
5532
5533 child_die->die_parent = die;
5534 if (die->die_child)
5535 {
5536 child_die->die_sib = die->die_child->die_sib;
5537 die->die_child->die_sib = child_die;
5538 }
5539 else
5540 child_die->die_sib = child_die;
5541 die->die_child = child_die;
5542 }
5543
5544 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5545 is the specification, to the end of PARENT's list of children.
5546 This is done by removing and re-adding it. */
5547
5548 static void
splice_child_die(dw_die_ref parent,dw_die_ref child)5549 splice_child_die (dw_die_ref parent, dw_die_ref child)
5550 {
5551 dw_die_ref p;
5552
5553 /* We want the declaration DIE from inside the class, not the
5554 specification DIE at toplevel. */
5555 if (child->die_parent != parent)
5556 {
5557 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
5558
5559 if (tmp)
5560 child = tmp;
5561 }
5562
5563 gcc_assert (child->die_parent == parent
5564 || (child->die_parent
5565 == get_AT_ref (parent, DW_AT_specification)));
5566
5567 for (p = child->die_parent->die_child; ; p = p->die_sib)
5568 if (p->die_sib == child)
5569 {
5570 remove_child_with_prev (child, p);
5571 break;
5572 }
5573
5574 add_child_die (parent, child);
5575 }
5576
5577 /* Return a pointer to a newly created DIE node. */
5578
5579 static inline dw_die_ref
new_die(enum dwarf_tag tag_value,dw_die_ref parent_die,tree t)5580 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
5581 {
5582 dw_die_ref die = ggc_alloc_cleared (sizeof (die_node));
5583
5584 die->die_tag = tag_value;
5585
5586 if (parent_die != NULL)
5587 add_child_die (parent_die, die);
5588 else
5589 {
5590 limbo_die_node *limbo_node;
5591
5592 limbo_node = ggc_alloc_cleared (sizeof (limbo_die_node));
5593 limbo_node->die = die;
5594 limbo_node->created_for = t;
5595 limbo_node->next = limbo_die_list;
5596 limbo_die_list = limbo_node;
5597 }
5598
5599 return die;
5600 }
5601
5602 /* Return the DIE associated with the given type specifier. */
5603
5604 static inline dw_die_ref
lookup_type_die(tree type)5605 lookup_type_die (tree type)
5606 {
5607 return TYPE_SYMTAB_DIE (type);
5608 }
5609
5610 /* Equate a DIE to a given type specifier. */
5611
5612 static inline void
equate_type_number_to_die(tree type,dw_die_ref type_die)5613 equate_type_number_to_die (tree type, dw_die_ref type_die)
5614 {
5615 TYPE_SYMTAB_DIE (type) = type_die;
5616 }
5617
5618 /* Returns a hash value for X (which really is a die_struct). */
5619
5620 static hashval_t
decl_die_table_hash(const void * x)5621 decl_die_table_hash (const void *x)
5622 {
5623 return (hashval_t) ((const dw_die_ref) x)->decl_id;
5624 }
5625
5626 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
5627
5628 static int
decl_die_table_eq(const void * x,const void * y)5629 decl_die_table_eq (const void *x, const void *y)
5630 {
5631 return (((const dw_die_ref) x)->decl_id == DECL_UID ((const tree) y));
5632 }
5633
5634 /* Return the DIE associated with a given declaration. */
5635
5636 static inline dw_die_ref
lookup_decl_die(tree decl)5637 lookup_decl_die (tree decl)
5638 {
5639 return htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
5640 }
5641
5642 /* Returns a hash value for X (which really is a var_loc_list). */
5643
5644 static hashval_t
decl_loc_table_hash(const void * x)5645 decl_loc_table_hash (const void *x)
5646 {
5647 return (hashval_t) ((const var_loc_list *) x)->decl_id;
5648 }
5649
5650 /* Return nonzero if decl_id of var_loc_list X is the same as
5651 UID of decl *Y. */
5652
5653 static int
decl_loc_table_eq(const void * x,const void * y)5654 decl_loc_table_eq (const void *x, const void *y)
5655 {
5656 return (((const var_loc_list *) x)->decl_id == DECL_UID ((const tree) y));
5657 }
5658
5659 /* Return the var_loc list associated with a given declaration. */
5660
5661 static inline var_loc_list *
lookup_decl_loc(tree decl)5662 lookup_decl_loc (tree decl)
5663 {
5664 return htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
5665 }
5666
5667 /* Equate a DIE to a particular declaration. */
5668
5669 static void
equate_decl_number_to_die(tree decl,dw_die_ref decl_die)5670 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
5671 {
5672 unsigned int decl_id = DECL_UID (decl);
5673 void **slot;
5674
5675 slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
5676 *slot = decl_die;
5677 decl_die->decl_id = decl_id;
5678 }
5679
5680 /* Add a variable location node to the linked list for DECL. */
5681
5682 static void
add_var_loc_to_decl(tree decl,struct var_loc_node * loc)5683 add_var_loc_to_decl (tree decl, struct var_loc_node *loc)
5684 {
5685 unsigned int decl_id = DECL_UID (decl);
5686 var_loc_list *temp;
5687 void **slot;
5688
5689 slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
5690 if (*slot == NULL)
5691 {
5692 temp = ggc_alloc_cleared (sizeof (var_loc_list));
5693 temp->decl_id = decl_id;
5694 *slot = temp;
5695 }
5696 else
5697 temp = *slot;
5698
5699 if (temp->last)
5700 {
5701 /* If the current location is the same as the end of the list,
5702 we have nothing to do. */
5703 if (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note),
5704 NOTE_VAR_LOCATION_LOC (loc->var_loc_note)))
5705 {
5706 /* Add LOC to the end of list and update LAST. */
5707 temp->last->next = loc;
5708 temp->last = loc;
5709 }
5710 }
5711 /* Do not add empty location to the beginning of the list. */
5712 else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX)
5713 {
5714 temp->first = loc;
5715 temp->last = loc;
5716 }
5717 }
5718
5719 /* Keep track of the number of spaces used to indent the
5720 output of the debugging routines that print the structure of
5721 the DIE internal representation. */
5722 static int print_indent;
5723
5724 /* Indent the line the number of spaces given by print_indent. */
5725
5726 static inline void
print_spaces(FILE * outfile)5727 print_spaces (FILE *outfile)
5728 {
5729 fprintf (outfile, "%*s", print_indent, "");
5730 }
5731
5732 /* Print the information associated with a given DIE, and its children.
5733 This routine is a debugging aid only. */
5734
5735 static void
print_die(dw_die_ref die,FILE * outfile)5736 print_die (dw_die_ref die, FILE *outfile)
5737 {
5738 dw_attr_ref a;
5739 dw_die_ref c;
5740 unsigned ix;
5741
5742 print_spaces (outfile);
5743 fprintf (outfile, "DIE %4lu: %s\n",
5744 die->die_offset, dwarf_tag_name (die->die_tag));
5745 print_spaces (outfile);
5746 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
5747 fprintf (outfile, " offset: %lu\n", die->die_offset);
5748
5749 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
5750 {
5751 print_spaces (outfile);
5752 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
5753
5754 switch (AT_class (a))
5755 {
5756 case dw_val_class_addr:
5757 fprintf (outfile, "address");
5758 break;
5759 case dw_val_class_offset:
5760 fprintf (outfile, "offset");
5761 break;
5762 case dw_val_class_loc:
5763 fprintf (outfile, "location descriptor");
5764 break;
5765 case dw_val_class_loc_list:
5766 fprintf (outfile, "location list -> label:%s",
5767 AT_loc_list (a)->ll_symbol);
5768 break;
5769 case dw_val_class_range_list:
5770 fprintf (outfile, "range list");
5771 break;
5772 case dw_val_class_const:
5773 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
5774 break;
5775 case dw_val_class_unsigned_const:
5776 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
5777 break;
5778 case dw_val_class_long_long:
5779 fprintf (outfile, "constant (%lu,%lu)",
5780 a->dw_attr_val.v.val_long_long.hi,
5781 a->dw_attr_val.v.val_long_long.low);
5782 break;
5783 case dw_val_class_vec:
5784 fprintf (outfile, "floating-point or vector constant");
5785 break;
5786 case dw_val_class_flag:
5787 fprintf (outfile, "%u", AT_flag (a));
5788 break;
5789 case dw_val_class_die_ref:
5790 if (AT_ref (a) != NULL)
5791 {
5792 if (AT_ref (a)->die_symbol)
5793 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
5794 else
5795 fprintf (outfile, "die -> %lu", AT_ref (a)->die_offset);
5796 }
5797 else
5798 fprintf (outfile, "die -> <null>");
5799 break;
5800 case dw_val_class_lbl_id:
5801 case dw_val_class_lineptr:
5802 case dw_val_class_macptr:
5803 fprintf (outfile, "label: %s", AT_lbl (a));
5804 break;
5805 case dw_val_class_str:
5806 if (AT_string (a) != NULL)
5807 fprintf (outfile, "\"%s\"", AT_string (a));
5808 else
5809 fprintf (outfile, "<null>");
5810 break;
5811 case dw_val_class_file:
5812 fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename,
5813 AT_file (a)->emitted_number);
5814 break;
5815 default:
5816 break;
5817 }
5818
5819 fprintf (outfile, "\n");
5820 }
5821
5822 if (die->die_child != NULL)
5823 {
5824 print_indent += 4;
5825 FOR_EACH_CHILD (die, c, print_die (c, outfile));
5826 print_indent -= 4;
5827 }
5828 if (print_indent == 0)
5829 fprintf (outfile, "\n");
5830 }
5831
5832 /* Print the contents of the source code line number correspondence table.
5833 This routine is a debugging aid only. */
5834
5835 static void
print_dwarf_line_table(FILE * outfile)5836 print_dwarf_line_table (FILE *outfile)
5837 {
5838 unsigned i;
5839 dw_line_info_ref line_info;
5840
5841 fprintf (outfile, "\n\nDWARF source line information\n");
5842 for (i = 1; i < line_info_table_in_use; i++)
5843 {
5844 line_info = &line_info_table[i];
5845 fprintf (outfile, "%5d: %4ld %6ld\n", i,
5846 line_info->dw_file_num,
5847 line_info->dw_line_num);
5848 }
5849
5850 fprintf (outfile, "\n\n");
5851 }
5852
5853 /* Print the information collected for a given DIE. */
5854
5855 void
debug_dwarf_die(dw_die_ref die)5856 debug_dwarf_die (dw_die_ref die)
5857 {
5858 print_die (die, stderr);
5859 }
5860
5861 /* Print all DWARF information collected for the compilation unit.
5862 This routine is a debugging aid only. */
5863
5864 void
debug_dwarf(void)5865 debug_dwarf (void)
5866 {
5867 print_indent = 0;
5868 print_die (comp_unit_die, stderr);
5869 if (! DWARF2_ASM_LINE_DEBUG_INFO)
5870 print_dwarf_line_table (stderr);
5871 }
5872
5873 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
5874 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
5875 DIE that marks the start of the DIEs for this include file. */
5876
5877 static dw_die_ref
push_new_compile_unit(dw_die_ref old_unit,dw_die_ref bincl_die)5878 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
5879 {
5880 const char *filename = get_AT_string (bincl_die, DW_AT_name);
5881 dw_die_ref new_unit = gen_compile_unit_die (filename);
5882
5883 new_unit->die_sib = old_unit;
5884 return new_unit;
5885 }
5886
5887 /* Close an include-file CU and reopen the enclosing one. */
5888
5889 static dw_die_ref
pop_compile_unit(dw_die_ref old_unit)5890 pop_compile_unit (dw_die_ref old_unit)
5891 {
5892 dw_die_ref new_unit = old_unit->die_sib;
5893
5894 old_unit->die_sib = NULL;
5895 return new_unit;
5896 }
5897
5898 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5899 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5900
5901 /* Calculate the checksum of a location expression. */
5902
5903 static inline void
loc_checksum(dw_loc_descr_ref loc,struct md5_ctx * ctx)5904 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
5905 {
5906 CHECKSUM (loc->dw_loc_opc);
5907 CHECKSUM (loc->dw_loc_oprnd1);
5908 CHECKSUM (loc->dw_loc_oprnd2);
5909 }
5910
5911 /* Calculate the checksum of an attribute. */
5912
5913 static void
attr_checksum(dw_attr_ref at,struct md5_ctx * ctx,int * mark)5914 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
5915 {
5916 dw_loc_descr_ref loc;
5917 rtx r;
5918
5919 CHECKSUM (at->dw_attr);
5920
5921 /* We don't care that this was compiled with a different compiler
5922 snapshot; if the output is the same, that's what matters. */
5923 if (at->dw_attr == DW_AT_producer)
5924 return;
5925
5926 switch (AT_class (at))
5927 {
5928 case dw_val_class_const:
5929 CHECKSUM (at->dw_attr_val.v.val_int);
5930 break;
5931 case dw_val_class_unsigned_const:
5932 CHECKSUM (at->dw_attr_val.v.val_unsigned);
5933 break;
5934 case dw_val_class_long_long:
5935 CHECKSUM (at->dw_attr_val.v.val_long_long);
5936 break;
5937 case dw_val_class_vec:
5938 CHECKSUM (at->dw_attr_val.v.val_vec);
5939 break;
5940 case dw_val_class_flag:
5941 CHECKSUM (at->dw_attr_val.v.val_flag);
5942 break;
5943 case dw_val_class_str:
5944 CHECKSUM_STRING (AT_string (at));
5945 break;
5946
5947 case dw_val_class_addr:
5948 r = AT_addr (at);
5949 gcc_assert (GET_CODE (r) == SYMBOL_REF);
5950 CHECKSUM_STRING (XSTR (r, 0));
5951 break;
5952
5953 case dw_val_class_offset:
5954 CHECKSUM (at->dw_attr_val.v.val_offset);
5955 break;
5956
5957 case dw_val_class_loc:
5958 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
5959 loc_checksum (loc, ctx);
5960 break;
5961
5962 case dw_val_class_die_ref:
5963 die_checksum (AT_ref (at), ctx, mark);
5964 break;
5965
5966 case dw_val_class_fde_ref:
5967 case dw_val_class_lbl_id:
5968 case dw_val_class_lineptr:
5969 case dw_val_class_macptr:
5970 break;
5971
5972 case dw_val_class_file:
5973 CHECKSUM_STRING (AT_file (at)->filename);
5974 break;
5975
5976 default:
5977 break;
5978 }
5979 }
5980
5981 /* Calculate the checksum of a DIE. */
5982
5983 static void
die_checksum(dw_die_ref die,struct md5_ctx * ctx,int * mark)5984 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
5985 {
5986 dw_die_ref c;
5987 dw_attr_ref a;
5988 unsigned ix;
5989
5990 /* To avoid infinite recursion. */
5991 if (die->die_mark)
5992 {
5993 CHECKSUM (die->die_mark);
5994 return;
5995 }
5996 die->die_mark = ++(*mark);
5997
5998 CHECKSUM (die->die_tag);
5999
6000 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6001 attr_checksum (a, ctx, mark);
6002
6003 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
6004 }
6005
6006 #undef CHECKSUM
6007 #undef CHECKSUM_STRING
6008
6009 /* Do the location expressions look same? */
6010 static inline int
same_loc_p(dw_loc_descr_ref loc1,dw_loc_descr_ref loc2,int * mark)6011 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
6012 {
6013 return loc1->dw_loc_opc == loc2->dw_loc_opc
6014 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
6015 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
6016 }
6017
6018 /* Do the values look the same? */
6019 static int
same_dw_val_p(dw_val_node * v1,dw_val_node * v2,int * mark)6020 same_dw_val_p (dw_val_node *v1, dw_val_node *v2, int *mark)
6021 {
6022 dw_loc_descr_ref loc1, loc2;
6023 rtx r1, r2;
6024
6025 if (v1->val_class != v2->val_class)
6026 return 0;
6027
6028 switch (v1->val_class)
6029 {
6030 case dw_val_class_const:
6031 return v1->v.val_int == v2->v.val_int;
6032 case dw_val_class_unsigned_const:
6033 return v1->v.val_unsigned == v2->v.val_unsigned;
6034 case dw_val_class_long_long:
6035 return v1->v.val_long_long.hi == v2->v.val_long_long.hi
6036 && v1->v.val_long_long.low == v2->v.val_long_long.low;
6037 case dw_val_class_vec:
6038 if (v1->v.val_vec.length != v2->v.val_vec.length
6039 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
6040 return 0;
6041 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
6042 v1->v.val_vec.length * v1->v.val_vec.elt_size))
6043 return 0;
6044 return 1;
6045 case dw_val_class_flag:
6046 return v1->v.val_flag == v2->v.val_flag;
6047 case dw_val_class_str:
6048 return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
6049
6050 case dw_val_class_addr:
6051 r1 = v1->v.val_addr;
6052 r2 = v2->v.val_addr;
6053 if (GET_CODE (r1) != GET_CODE (r2))
6054 return 0;
6055 gcc_assert (GET_CODE (r1) == SYMBOL_REF);
6056 return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
6057
6058 case dw_val_class_offset:
6059 return v1->v.val_offset == v2->v.val_offset;
6060
6061 case dw_val_class_loc:
6062 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
6063 loc1 && loc2;
6064 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
6065 if (!same_loc_p (loc1, loc2, mark))
6066 return 0;
6067 return !loc1 && !loc2;
6068
6069 case dw_val_class_die_ref:
6070 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
6071
6072 case dw_val_class_fde_ref:
6073 case dw_val_class_lbl_id:
6074 case dw_val_class_lineptr:
6075 case dw_val_class_macptr:
6076 return 1;
6077
6078 case dw_val_class_file:
6079 return v1->v.val_file == v2->v.val_file;
6080
6081 default:
6082 return 1;
6083 }
6084 }
6085
6086 /* Do the attributes look the same? */
6087
6088 static int
same_attr_p(dw_attr_ref at1,dw_attr_ref at2,int * mark)6089 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
6090 {
6091 if (at1->dw_attr != at2->dw_attr)
6092 return 0;
6093
6094 /* We don't care that this was compiled with a different compiler
6095 snapshot; if the output is the same, that's what matters. */
6096 if (at1->dw_attr == DW_AT_producer)
6097 return 1;
6098
6099 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
6100 }
6101
6102 /* Do the dies look the same? */
6103
6104 static int
same_die_p(dw_die_ref die1,dw_die_ref die2,int * mark)6105 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
6106 {
6107 dw_die_ref c1, c2;
6108 dw_attr_ref a1;
6109 unsigned ix;
6110
6111 /* To avoid infinite recursion. */
6112 if (die1->die_mark)
6113 return die1->die_mark == die2->die_mark;
6114 die1->die_mark = die2->die_mark = ++(*mark);
6115
6116 if (die1->die_tag != die2->die_tag)
6117 return 0;
6118
6119 if (VEC_length (dw_attr_node, die1->die_attr)
6120 != VEC_length (dw_attr_node, die2->die_attr))
6121 return 0;
6122
6123 for (ix = 0; VEC_iterate (dw_attr_node, die1->die_attr, ix, a1); ix++)
6124 if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark))
6125 return 0;
6126
6127 c1 = die1->die_child;
6128 c2 = die2->die_child;
6129 if (! c1)
6130 {
6131 if (c2)
6132 return 0;
6133 }
6134 else
6135 for (;;)
6136 {
6137 if (!same_die_p (c1, c2, mark))
6138 return 0;
6139 c1 = c1->die_sib;
6140 c2 = c2->die_sib;
6141 if (c1 == die1->die_child)
6142 {
6143 if (c2 == die2->die_child)
6144 break;
6145 else
6146 return 0;
6147 }
6148 }
6149
6150 return 1;
6151 }
6152
6153 /* Do the dies look the same? Wrapper around same_die_p. */
6154
6155 static int
same_die_p_wrap(dw_die_ref die1,dw_die_ref die2)6156 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
6157 {
6158 int mark = 0;
6159 int ret = same_die_p (die1, die2, &mark);
6160
6161 unmark_all_dies (die1);
6162 unmark_all_dies (die2);
6163
6164 return ret;
6165 }
6166
6167 /* The prefix to attach to symbols on DIEs in the current comdat debug
6168 info section. */
6169 static char *comdat_symbol_id;
6170
6171 /* The index of the current symbol within the current comdat CU. */
6172 static unsigned int comdat_symbol_number;
6173
6174 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
6175 children, and set comdat_symbol_id accordingly. */
6176
6177 static void
compute_section_prefix(dw_die_ref unit_die)6178 compute_section_prefix (dw_die_ref unit_die)
6179 {
6180 const char *die_name = get_AT_string (unit_die, DW_AT_name);
6181 const char *base = die_name ? lbasename (die_name) : "anonymous";
6182 char *name = alloca (strlen (base) + 64);
6183 char *p;
6184 int i, mark;
6185 unsigned char checksum[16];
6186 struct md5_ctx ctx;
6187
6188 /* Compute the checksum of the DIE, then append part of it as hex digits to
6189 the name filename of the unit. */
6190
6191 md5_init_ctx (&ctx);
6192 mark = 0;
6193 die_checksum (unit_die, &ctx, &mark);
6194 unmark_all_dies (unit_die);
6195 md5_finish_ctx (&ctx, checksum);
6196
6197 sprintf (name, "%s.", base);
6198 clean_symbol_name (name);
6199
6200 p = name + strlen (name);
6201 for (i = 0; i < 4; i++)
6202 {
6203 sprintf (p, "%.2x", checksum[i]);
6204 p += 2;
6205 }
6206
6207 comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
6208 comdat_symbol_number = 0;
6209 }
6210
6211 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
6212
6213 static int
is_type_die(dw_die_ref die)6214 is_type_die (dw_die_ref die)
6215 {
6216 switch (die->die_tag)
6217 {
6218 case DW_TAG_array_type:
6219 case DW_TAG_class_type:
6220 case DW_TAG_enumeration_type:
6221 case DW_TAG_pointer_type:
6222 case DW_TAG_reference_type:
6223 case DW_TAG_string_type:
6224 case DW_TAG_structure_type:
6225 case DW_TAG_subroutine_type:
6226 case DW_TAG_union_type:
6227 case DW_TAG_ptr_to_member_type:
6228 case DW_TAG_set_type:
6229 case DW_TAG_subrange_type:
6230 case DW_TAG_base_type:
6231 case DW_TAG_const_type:
6232 case DW_TAG_file_type:
6233 case DW_TAG_packed_type:
6234 case DW_TAG_volatile_type:
6235 case DW_TAG_typedef:
6236 return 1;
6237 default:
6238 return 0;
6239 }
6240 }
6241
6242 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
6243 Basically, we want to choose the bits that are likely to be shared between
6244 compilations (types) and leave out the bits that are specific to individual
6245 compilations (functions). */
6246
6247 static int
is_comdat_die(dw_die_ref c)6248 is_comdat_die (dw_die_ref c)
6249 {
6250 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
6251 we do for stabs. The advantage is a greater likelihood of sharing between
6252 objects that don't include headers in the same order (and therefore would
6253 put the base types in a different comdat). jason 8/28/00 */
6254
6255 if (c->die_tag == DW_TAG_base_type)
6256 return 0;
6257
6258 if (c->die_tag == DW_TAG_pointer_type
6259 || c->die_tag == DW_TAG_reference_type
6260 || c->die_tag == DW_TAG_const_type
6261 || c->die_tag == DW_TAG_volatile_type)
6262 {
6263 dw_die_ref t = get_AT_ref (c, DW_AT_type);
6264
6265 return t ? is_comdat_die (t) : 0;
6266 }
6267
6268 return is_type_die (c);
6269 }
6270
6271 /* Returns 1 iff C is the sort of DIE that might be referred to from another
6272 compilation unit. */
6273
6274 static int
is_symbol_die(dw_die_ref c)6275 is_symbol_die (dw_die_ref c)
6276 {
6277 return (is_type_die (c)
6278 || (get_AT (c, DW_AT_declaration)
6279 && !get_AT (c, DW_AT_specification))
6280 || c->die_tag == DW_TAG_namespace);
6281 }
6282
6283 static char *
gen_internal_sym(const char * prefix)6284 gen_internal_sym (const char *prefix)
6285 {
6286 char buf[256];
6287
6288 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
6289 return xstrdup (buf);
6290 }
6291
6292 /* Assign symbols to all worthy DIEs under DIE. */
6293
6294 static void
assign_symbol_names(dw_die_ref die)6295 assign_symbol_names (dw_die_ref die)
6296 {
6297 dw_die_ref c;
6298
6299 if (is_symbol_die (die))
6300 {
6301 if (comdat_symbol_id)
6302 {
6303 char *p = alloca (strlen (comdat_symbol_id) + 64);
6304
6305 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
6306 comdat_symbol_id, comdat_symbol_number++);
6307 die->die_symbol = xstrdup (p);
6308 }
6309 else
6310 die->die_symbol = gen_internal_sym ("LDIE");
6311 }
6312
6313 FOR_EACH_CHILD (die, c, assign_symbol_names (c));
6314 }
6315
6316 struct cu_hash_table_entry
6317 {
6318 dw_die_ref cu;
6319 unsigned min_comdat_num, max_comdat_num;
6320 struct cu_hash_table_entry *next;
6321 };
6322
6323 /* Routines to manipulate hash table of CUs. */
6324 static hashval_t
htab_cu_hash(const void * of)6325 htab_cu_hash (const void *of)
6326 {
6327 const struct cu_hash_table_entry *entry = of;
6328
6329 return htab_hash_string (entry->cu->die_symbol);
6330 }
6331
6332 static int
htab_cu_eq(const void * of1,const void * of2)6333 htab_cu_eq (const void *of1, const void *of2)
6334 {
6335 const struct cu_hash_table_entry *entry1 = of1;
6336 const struct die_struct *entry2 = of2;
6337
6338 return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
6339 }
6340
6341 static void
htab_cu_del(void * what)6342 htab_cu_del (void *what)
6343 {
6344 struct cu_hash_table_entry *next, *entry = what;
6345
6346 while (entry)
6347 {
6348 next = entry->next;
6349 free (entry);
6350 entry = next;
6351 }
6352 }
6353
6354 /* Check whether we have already seen this CU and set up SYM_NUM
6355 accordingly. */
6356 static int
check_duplicate_cu(dw_die_ref cu,htab_t htable,unsigned int * sym_num)6357 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
6358 {
6359 struct cu_hash_table_entry dummy;
6360 struct cu_hash_table_entry **slot, *entry, *last = &dummy;
6361
6362 dummy.max_comdat_num = 0;
6363
6364 slot = (struct cu_hash_table_entry **)
6365 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6366 INSERT);
6367 entry = *slot;
6368
6369 for (; entry; last = entry, entry = entry->next)
6370 {
6371 if (same_die_p_wrap (cu, entry->cu))
6372 break;
6373 }
6374
6375 if (entry)
6376 {
6377 *sym_num = entry->min_comdat_num;
6378 return 1;
6379 }
6380
6381 entry = XCNEW (struct cu_hash_table_entry);
6382 entry->cu = cu;
6383 entry->min_comdat_num = *sym_num = last->max_comdat_num;
6384 entry->next = *slot;
6385 *slot = entry;
6386
6387 return 0;
6388 }
6389
6390 /* Record SYM_NUM to record of CU in HTABLE. */
6391 static void
record_comdat_symbol_number(dw_die_ref cu,htab_t htable,unsigned int sym_num)6392 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
6393 {
6394 struct cu_hash_table_entry **slot, *entry;
6395
6396 slot = (struct cu_hash_table_entry **)
6397 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6398 NO_INSERT);
6399 entry = *slot;
6400
6401 entry->max_comdat_num = sym_num;
6402 }
6403
6404 /* Traverse the DIE (which is always comp_unit_die), and set up
6405 additional compilation units for each of the include files we see
6406 bracketed by BINCL/EINCL. */
6407
6408 static void
break_out_includes(dw_die_ref die)6409 break_out_includes (dw_die_ref die)
6410 {
6411 dw_die_ref c;
6412 dw_die_ref unit = NULL;
6413 limbo_die_node *node, **pnode;
6414 htab_t cu_hash_table;
6415
6416 c = die->die_child;
6417 if (c) do {
6418 dw_die_ref prev = c;
6419 c = c->die_sib;
6420 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
6421 || (unit && is_comdat_die (c)))
6422 {
6423 dw_die_ref next = c->die_sib;
6424
6425 /* This DIE is for a secondary CU; remove it from the main one. */
6426 remove_child_with_prev (c, prev);
6427
6428 if (c->die_tag == DW_TAG_GNU_BINCL)
6429 unit = push_new_compile_unit (unit, c);
6430 else if (c->die_tag == DW_TAG_GNU_EINCL)
6431 unit = pop_compile_unit (unit);
6432 else
6433 add_child_die (unit, c);
6434 c = next;
6435 if (c == die->die_child)
6436 break;
6437 }
6438 } while (c != die->die_child);
6439
6440 #if 0
6441 /* We can only use this in debugging, since the frontend doesn't check
6442 to make sure that we leave every include file we enter. */
6443 gcc_assert (!unit);
6444 #endif
6445
6446 assign_symbol_names (die);
6447 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
6448 for (node = limbo_die_list, pnode = &limbo_die_list;
6449 node;
6450 node = node->next)
6451 {
6452 int is_dupl;
6453
6454 compute_section_prefix (node->die);
6455 is_dupl = check_duplicate_cu (node->die, cu_hash_table,
6456 &comdat_symbol_number);
6457 assign_symbol_names (node->die);
6458 if (is_dupl)
6459 *pnode = node->next;
6460 else
6461 {
6462 pnode = &node->next;
6463 record_comdat_symbol_number (node->die, cu_hash_table,
6464 comdat_symbol_number);
6465 }
6466 }
6467 htab_delete (cu_hash_table);
6468 }
6469
6470 /* Traverse the DIE and add a sibling attribute if it may have the
6471 effect of speeding up access to siblings. To save some space,
6472 avoid generating sibling attributes for DIE's without children. */
6473
6474 static void
add_sibling_attributes(dw_die_ref die)6475 add_sibling_attributes (dw_die_ref die)
6476 {
6477 dw_die_ref c;
6478
6479 if (! die->die_child)
6480 return;
6481
6482 if (die->die_parent && die != die->die_parent->die_child)
6483 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
6484
6485 FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
6486 }
6487
6488 /* Output all location lists for the DIE and its children. */
6489
6490 static void
output_location_lists(dw_die_ref die)6491 output_location_lists (dw_die_ref die)
6492 {
6493 dw_die_ref c;
6494 dw_attr_ref a;
6495 unsigned ix;
6496
6497 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6498 if (AT_class (a) == dw_val_class_loc_list)
6499 output_loc_list (AT_loc_list (a));
6500
6501 FOR_EACH_CHILD (die, c, output_location_lists (c));
6502 }
6503
6504 /* The format of each DIE (and its attribute value pairs) is encoded in an
6505 abbreviation table. This routine builds the abbreviation table and assigns
6506 a unique abbreviation id for each abbreviation entry. The children of each
6507 die are visited recursively. */
6508
6509 static void
build_abbrev_table(dw_die_ref die)6510 build_abbrev_table (dw_die_ref die)
6511 {
6512 unsigned long abbrev_id;
6513 unsigned int n_alloc;
6514 dw_die_ref c;
6515 dw_attr_ref a;
6516 unsigned ix;
6517
6518 /* Scan the DIE references, and mark as external any that refer to
6519 DIEs from other CUs (i.e. those which are not marked). */
6520 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6521 if (AT_class (a) == dw_val_class_die_ref
6522 && AT_ref (a)->die_mark == 0)
6523 {
6524 gcc_assert (AT_ref (a)->die_symbol);
6525
6526 set_AT_ref_external (a, 1);
6527 }
6528
6529 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6530 {
6531 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6532 dw_attr_ref die_a, abbrev_a;
6533 unsigned ix;
6534 bool ok = true;
6535
6536 if (abbrev->die_tag != die->die_tag)
6537 continue;
6538 if ((abbrev->die_child != NULL) != (die->die_child != NULL))
6539 continue;
6540
6541 if (VEC_length (dw_attr_node, abbrev->die_attr)
6542 != VEC_length (dw_attr_node, die->die_attr))
6543 continue;
6544
6545 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, die_a); ix++)
6546 {
6547 abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix);
6548 if ((abbrev_a->dw_attr != die_a->dw_attr)
6549 || (value_format (abbrev_a) != value_format (die_a)))
6550 {
6551 ok = false;
6552 break;
6553 }
6554 }
6555 if (ok)
6556 break;
6557 }
6558
6559 if (abbrev_id >= abbrev_die_table_in_use)
6560 {
6561 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
6562 {
6563 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
6564 abbrev_die_table = ggc_realloc (abbrev_die_table,
6565 sizeof (dw_die_ref) * n_alloc);
6566
6567 memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
6568 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
6569 abbrev_die_table_allocated = n_alloc;
6570 }
6571
6572 ++abbrev_die_table_in_use;
6573 abbrev_die_table[abbrev_id] = die;
6574 }
6575
6576 die->die_abbrev = abbrev_id;
6577 FOR_EACH_CHILD (die, c, build_abbrev_table (c));
6578 }
6579
6580 /* Return the power-of-two number of bytes necessary to represent VALUE. */
6581
6582 static int
constant_size(long unsigned int value)6583 constant_size (long unsigned int value)
6584 {
6585 int log;
6586
6587 if (value == 0)
6588 log = 0;
6589 else
6590 log = floor_log2 (value);
6591
6592 log = log / 8;
6593 log = 1 << (floor_log2 (log) + 1);
6594
6595 return log;
6596 }
6597
6598 /* Return the size of a DIE as it is represented in the
6599 .debug_info section. */
6600
6601 static unsigned long
size_of_die(dw_die_ref die)6602 size_of_die (dw_die_ref die)
6603 {
6604 unsigned long size = 0;
6605 dw_attr_ref a;
6606 unsigned ix;
6607
6608 size += size_of_uleb128 (die->die_abbrev);
6609 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6610 {
6611 switch (AT_class (a))
6612 {
6613 case dw_val_class_addr:
6614 size += DWARF2_ADDR_SIZE;
6615 break;
6616 case dw_val_class_offset:
6617 size += DWARF_OFFSET_SIZE;
6618 break;
6619 case dw_val_class_loc:
6620 {
6621 unsigned long lsize = size_of_locs (AT_loc (a));
6622
6623 /* Block length. */
6624 size += constant_size (lsize);
6625 size += lsize;
6626 }
6627 break;
6628 case dw_val_class_loc_list:
6629 size += DWARF_OFFSET_SIZE;
6630 break;
6631 case dw_val_class_range_list:
6632 size += DWARF_OFFSET_SIZE;
6633 break;
6634 case dw_val_class_const:
6635 size += size_of_sleb128 (AT_int (a));
6636 break;
6637 case dw_val_class_unsigned_const:
6638 size += constant_size (AT_unsigned (a));
6639 break;
6640 case dw_val_class_long_long:
6641 size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */
6642 break;
6643 case dw_val_class_vec:
6644 size += 1 + (a->dw_attr_val.v.val_vec.length
6645 * a->dw_attr_val.v.val_vec.elt_size); /* block */
6646 break;
6647 case dw_val_class_flag:
6648 size += 1;
6649 break;
6650 case dw_val_class_die_ref:
6651 if (AT_ref_external (a))
6652 size += DWARF2_ADDR_SIZE;
6653 else
6654 size += DWARF_OFFSET_SIZE;
6655 break;
6656 case dw_val_class_fde_ref:
6657 size += DWARF_OFFSET_SIZE;
6658 break;
6659 case dw_val_class_lbl_id:
6660 size += DWARF2_ADDR_SIZE;
6661 break;
6662 case dw_val_class_lineptr:
6663 case dw_val_class_macptr:
6664 size += DWARF_OFFSET_SIZE;
6665 break;
6666 case dw_val_class_str:
6667 if (AT_string_form (a) == DW_FORM_strp)
6668 size += DWARF_OFFSET_SIZE;
6669 else
6670 size += strlen (a->dw_attr_val.v.val_str->str) + 1;
6671 break;
6672 case dw_val_class_file:
6673 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
6674 break;
6675 default:
6676 gcc_unreachable ();
6677 }
6678 }
6679
6680 return size;
6681 }
6682
6683 /* Size the debugging information associated with a given DIE. Visits the
6684 DIE's children recursively. Updates the global variable next_die_offset, on
6685 each time through. Uses the current value of next_die_offset to update the
6686 die_offset field in each DIE. */
6687
6688 static void
calc_die_sizes(dw_die_ref die)6689 calc_die_sizes (dw_die_ref die)
6690 {
6691 dw_die_ref c;
6692
6693 die->die_offset = next_die_offset;
6694 next_die_offset += size_of_die (die);
6695
6696 FOR_EACH_CHILD (die, c, calc_die_sizes (c));
6697
6698 if (die->die_child != NULL)
6699 /* Count the null byte used to terminate sibling lists. */
6700 next_die_offset += 1;
6701 }
6702
6703 /* Set the marks for a die and its children. We do this so
6704 that we know whether or not a reference needs to use FORM_ref_addr; only
6705 DIEs in the same CU will be marked. We used to clear out the offset
6706 and use that as the flag, but ran into ordering problems. */
6707
6708 static void
mark_dies(dw_die_ref die)6709 mark_dies (dw_die_ref die)
6710 {
6711 dw_die_ref c;
6712
6713 gcc_assert (!die->die_mark);
6714
6715 die->die_mark = 1;
6716 FOR_EACH_CHILD (die, c, mark_dies (c));
6717 }
6718
6719 /* Clear the marks for a die and its children. */
6720
6721 static void
unmark_dies(dw_die_ref die)6722 unmark_dies (dw_die_ref die)
6723 {
6724 dw_die_ref c;
6725
6726 gcc_assert (die->die_mark);
6727
6728 die->die_mark = 0;
6729 FOR_EACH_CHILD (die, c, unmark_dies (c));
6730 }
6731
6732 /* Clear the marks for a die, its children and referred dies. */
6733
6734 static void
unmark_all_dies(dw_die_ref die)6735 unmark_all_dies (dw_die_ref die)
6736 {
6737 dw_die_ref c;
6738 dw_attr_ref a;
6739 unsigned ix;
6740
6741 if (!die->die_mark)
6742 return;
6743 die->die_mark = 0;
6744
6745 FOR_EACH_CHILD (die, c, unmark_all_dies (c));
6746
6747 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6748 if (AT_class (a) == dw_val_class_die_ref)
6749 unmark_all_dies (AT_ref (a));
6750 }
6751
6752 /* Return the size of the .debug_pubnames table generated for the
6753 compilation unit. */
6754
6755 static unsigned long
size_of_pubnames(void)6756 size_of_pubnames (void)
6757 {
6758 unsigned long size;
6759 unsigned i;
6760
6761 size = DWARF_PUBNAMES_HEADER_SIZE;
6762 for (i = 0; i < pubname_table_in_use; i++)
6763 {
6764 pubname_ref p = &pubname_table[i];
6765 size += DWARF_OFFSET_SIZE + strlen (p->name) + 1;
6766 }
6767
6768 size += DWARF_OFFSET_SIZE;
6769 return size;
6770 }
6771
6772 /* Return the size of the information in the .debug_aranges section. */
6773
6774 static unsigned long
size_of_aranges(void)6775 size_of_aranges (void)
6776 {
6777 unsigned long size;
6778
6779 size = DWARF_ARANGES_HEADER_SIZE;
6780
6781 /* Count the address/length pair for this compilation unit. */
6782 size += 2 * DWARF2_ADDR_SIZE;
6783 size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
6784
6785 /* Count the two zero words used to terminated the address range table. */
6786 size += 2 * DWARF2_ADDR_SIZE;
6787 return size;
6788 }
6789
6790 /* Select the encoding of an attribute value. */
6791
6792 static enum dwarf_form
value_format(dw_attr_ref a)6793 value_format (dw_attr_ref a)
6794 {
6795 switch (a->dw_attr_val.val_class)
6796 {
6797 case dw_val_class_addr:
6798 return DW_FORM_addr;
6799 case dw_val_class_range_list:
6800 case dw_val_class_offset:
6801 case dw_val_class_loc_list:
6802 switch (DWARF_OFFSET_SIZE)
6803 {
6804 case 4:
6805 return DW_FORM_data4;
6806 case 8:
6807 return DW_FORM_data8;
6808 default:
6809 gcc_unreachable ();
6810 }
6811 case dw_val_class_loc:
6812 switch (constant_size (size_of_locs (AT_loc (a))))
6813 {
6814 case 1:
6815 return DW_FORM_block1;
6816 case 2:
6817 return DW_FORM_block2;
6818 default:
6819 gcc_unreachable ();
6820 }
6821 case dw_val_class_const:
6822 return DW_FORM_sdata;
6823 case dw_val_class_unsigned_const:
6824 switch (constant_size (AT_unsigned (a)))
6825 {
6826 case 1:
6827 return DW_FORM_data1;
6828 case 2:
6829 return DW_FORM_data2;
6830 case 4:
6831 return DW_FORM_data4;
6832 case 8:
6833 return DW_FORM_data8;
6834 default:
6835 gcc_unreachable ();
6836 }
6837 case dw_val_class_long_long:
6838 return DW_FORM_block1;
6839 case dw_val_class_vec:
6840 return DW_FORM_block1;
6841 case dw_val_class_flag:
6842 return DW_FORM_flag;
6843 case dw_val_class_die_ref:
6844 if (AT_ref_external (a))
6845 return DW_FORM_ref_addr;
6846 else
6847 return DW_FORM_ref;
6848 case dw_val_class_fde_ref:
6849 return DW_FORM_data;
6850 case dw_val_class_lbl_id:
6851 return DW_FORM_addr;
6852 case dw_val_class_lineptr:
6853 case dw_val_class_macptr:
6854 return DW_FORM_data;
6855 case dw_val_class_str:
6856 return AT_string_form (a);
6857 case dw_val_class_file:
6858 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
6859 {
6860 case 1:
6861 return DW_FORM_data1;
6862 case 2:
6863 return DW_FORM_data2;
6864 case 4:
6865 return DW_FORM_data4;
6866 default:
6867 gcc_unreachable ();
6868 }
6869
6870 default:
6871 gcc_unreachable ();
6872 }
6873 }
6874
6875 /* Output the encoding of an attribute value. */
6876
6877 static void
output_value_format(dw_attr_ref a)6878 output_value_format (dw_attr_ref a)
6879 {
6880 enum dwarf_form form = value_format (a);
6881
6882 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
6883 }
6884
6885 /* Output the .debug_abbrev section which defines the DIE abbreviation
6886 table. */
6887
6888 static void
output_abbrev_section(void)6889 output_abbrev_section (void)
6890 {
6891 unsigned long abbrev_id;
6892
6893 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6894 {
6895 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6896 unsigned ix;
6897 dw_attr_ref a_attr;
6898
6899 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
6900 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
6901 dwarf_tag_name (abbrev->die_tag));
6902
6903 if (abbrev->die_child != NULL)
6904 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
6905 else
6906 dw2_asm_output_data (1, DW_children_no, "DW_children_no");
6907
6908 for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr);
6909 ix++)
6910 {
6911 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
6912 dwarf_attr_name (a_attr->dw_attr));
6913 output_value_format (a_attr);
6914 }
6915
6916 dw2_asm_output_data (1, 0, NULL);
6917 dw2_asm_output_data (1, 0, NULL);
6918 }
6919
6920 /* Terminate the table. */
6921 dw2_asm_output_data (1, 0, NULL);
6922 }
6923
6924 /* Output a symbol we can use to refer to this DIE from another CU. */
6925
6926 static inline void
output_die_symbol(dw_die_ref die)6927 output_die_symbol (dw_die_ref die)
6928 {
6929 char *sym = die->die_symbol;
6930
6931 if (sym == 0)
6932 return;
6933
6934 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
6935 /* We make these global, not weak; if the target doesn't support
6936 .linkonce, it doesn't support combining the sections, so debugging
6937 will break. */
6938 targetm.asm_out.globalize_label (asm_out_file, sym);
6939
6940 ASM_OUTPUT_LABEL (asm_out_file, sym);
6941 }
6942
6943 /* Return a new location list, given the begin and end range, and the
6944 expression. gensym tells us whether to generate a new internal symbol for
6945 this location list node, which is done for the head of the list only. */
6946
6947 static inline dw_loc_list_ref
new_loc_list(dw_loc_descr_ref expr,const char * begin,const char * end,const char * section,unsigned int gensym)6948 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
6949 const char *section, unsigned int gensym)
6950 {
6951 dw_loc_list_ref retlist = ggc_alloc_cleared (sizeof (dw_loc_list_node));
6952
6953 retlist->begin = begin;
6954 retlist->end = end;
6955 retlist->expr = expr;
6956 retlist->section = section;
6957 if (gensym)
6958 retlist->ll_symbol = gen_internal_sym ("LLST");
6959
6960 return retlist;
6961 }
6962
6963 /* Add a location description expression to a location list. */
6964
6965 static inline void
add_loc_descr_to_loc_list(dw_loc_list_ref * list_head,dw_loc_descr_ref descr,const char * begin,const char * end,const char * section)6966 add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr,
6967 const char *begin, const char *end,
6968 const char *section)
6969 {
6970 dw_loc_list_ref *d;
6971
6972 /* Find the end of the chain. */
6973 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
6974 ;
6975
6976 /* Add a new location list node to the list. */
6977 *d = new_loc_list (descr, begin, end, section, 0);
6978 }
6979
6980 static void
dwarf2out_switch_text_section(void)6981 dwarf2out_switch_text_section (void)
6982 {
6983 dw_fde_ref fde;
6984
6985 gcc_assert (cfun);
6986
6987 fde = &fde_table[fde_table_in_use - 1];
6988 fde->dw_fde_switched_sections = true;
6989 fde->dw_fde_hot_section_label = cfun->hot_section_label;
6990 fde->dw_fde_hot_section_end_label = cfun->hot_section_end_label;
6991 fde->dw_fde_unlikely_section_label = cfun->cold_section_label;
6992 fde->dw_fde_unlikely_section_end_label = cfun->cold_section_end_label;
6993 have_multiple_function_sections = true;
6994
6995 /* Reset the current label on switching text sections, so that we
6996 don't attempt to advance_loc4 between labels in different sections. */
6997 fde->dw_fde_current_label = NULL;
6998 }
6999
7000 /* Output the location list given to us. */
7001
7002 static void
output_loc_list(dw_loc_list_ref list_head)7003 output_loc_list (dw_loc_list_ref list_head)
7004 {
7005 dw_loc_list_ref curr = list_head;
7006
7007 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
7008
7009 /* Walk the location list, and output each range + expression. */
7010 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
7011 {
7012 unsigned long size;
7013 if (!have_multiple_function_sections)
7014 {
7015 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
7016 "Location list begin address (%s)",
7017 list_head->ll_symbol);
7018 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
7019 "Location list end address (%s)",
7020 list_head->ll_symbol);
7021 }
7022 else
7023 {
7024 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
7025 "Location list begin address (%s)",
7026 list_head->ll_symbol);
7027 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
7028 "Location list end address (%s)",
7029 list_head->ll_symbol);
7030 }
7031 size = size_of_locs (curr->expr);
7032
7033 /* Output the block length for this list of location operations. */
7034 gcc_assert (size <= 0xffff);
7035 dw2_asm_output_data (2, size, "%s", "Location expression size");
7036
7037 output_loc_sequence (curr->expr);
7038 }
7039
7040 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7041 "Location list terminator begin (%s)",
7042 list_head->ll_symbol);
7043 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7044 "Location list terminator end (%s)",
7045 list_head->ll_symbol);
7046 }
7047
7048 /* Output the DIE and its attributes. Called recursively to generate
7049 the definitions of each child DIE. */
7050
7051 static void
output_die(dw_die_ref die)7052 output_die (dw_die_ref die)
7053 {
7054 dw_attr_ref a;
7055 dw_die_ref c;
7056 unsigned long size;
7057 unsigned ix;
7058
7059 /* If someone in another CU might refer to us, set up a symbol for
7060 them to point to. */
7061 if (die->die_symbol)
7062 output_die_symbol (die);
7063
7064 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
7065 die->die_offset, dwarf_tag_name (die->die_tag));
7066
7067 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7068 {
7069 const char *name = dwarf_attr_name (a->dw_attr);
7070
7071 switch (AT_class (a))
7072 {
7073 case dw_val_class_addr:
7074 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
7075 break;
7076
7077 case dw_val_class_offset:
7078 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
7079 "%s", name);
7080 break;
7081
7082 case dw_val_class_range_list:
7083 {
7084 char *p = strchr (ranges_section_label, '\0');
7085
7086 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
7087 a->dw_attr_val.v.val_offset);
7088 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
7089 debug_ranges_section, "%s", name);
7090 *p = '\0';
7091 }
7092 break;
7093
7094 case dw_val_class_loc:
7095 size = size_of_locs (AT_loc (a));
7096
7097 /* Output the block length for this list of location operations. */
7098 dw2_asm_output_data (constant_size (size), size, "%s", name);
7099
7100 output_loc_sequence (AT_loc (a));
7101 break;
7102
7103 case dw_val_class_const:
7104 /* ??? It would be slightly more efficient to use a scheme like is
7105 used for unsigned constants below, but gdb 4.x does not sign
7106 extend. Gdb 5.x does sign extend. */
7107 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
7108 break;
7109
7110 case dw_val_class_unsigned_const:
7111 dw2_asm_output_data (constant_size (AT_unsigned (a)),
7112 AT_unsigned (a), "%s", name);
7113 break;
7114
7115 case dw_val_class_long_long:
7116 {
7117 unsigned HOST_WIDE_INT first, second;
7118
7119 dw2_asm_output_data (1,
7120 2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7121 "%s", name);
7122
7123 if (WORDS_BIG_ENDIAN)
7124 {
7125 first = a->dw_attr_val.v.val_long_long.hi;
7126 second = a->dw_attr_val.v.val_long_long.low;
7127 }
7128 else
7129 {
7130 first = a->dw_attr_val.v.val_long_long.low;
7131 second = a->dw_attr_val.v.val_long_long.hi;
7132 }
7133
7134 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7135 first, "long long constant");
7136 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7137 second, NULL);
7138 }
7139 break;
7140
7141 case dw_val_class_vec:
7142 {
7143 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
7144 unsigned int len = a->dw_attr_val.v.val_vec.length;
7145 unsigned int i;
7146 unsigned char *p;
7147
7148 dw2_asm_output_data (1, len * elt_size, "%s", name);
7149 if (elt_size > sizeof (HOST_WIDE_INT))
7150 {
7151 elt_size /= 2;
7152 len *= 2;
7153 }
7154 for (i = 0, p = a->dw_attr_val.v.val_vec.array;
7155 i < len;
7156 i++, p += elt_size)
7157 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
7158 "fp or vector constant word %u", i);
7159 break;
7160 }
7161
7162 case dw_val_class_flag:
7163 dw2_asm_output_data (1, AT_flag (a), "%s", name);
7164 break;
7165
7166 case dw_val_class_loc_list:
7167 {
7168 char *sym = AT_loc_list (a)->ll_symbol;
7169
7170 gcc_assert (sym);
7171 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
7172 "%s", name);
7173 }
7174 break;
7175
7176 case dw_val_class_die_ref:
7177 if (AT_ref_external (a))
7178 {
7179 char *sym = AT_ref (a)->die_symbol;
7180
7181 gcc_assert (sym);
7182 dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, debug_info_section,
7183 "%s", name);
7184 }
7185 else
7186 {
7187 gcc_assert (AT_ref (a)->die_offset);
7188 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
7189 "%s", name);
7190 }
7191 break;
7192
7193 case dw_val_class_fde_ref:
7194 {
7195 char l1[20];
7196
7197 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
7198 a->dw_attr_val.v.val_fde_index * 2);
7199 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
7200 "%s", name);
7201 }
7202 break;
7203
7204 case dw_val_class_lbl_id:
7205 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
7206 break;
7207
7208 case dw_val_class_lineptr:
7209 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
7210 debug_line_section, "%s", name);
7211 break;
7212
7213 case dw_val_class_macptr:
7214 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
7215 debug_macinfo_section, "%s", name);
7216 break;
7217
7218 case dw_val_class_str:
7219 if (AT_string_form (a) == DW_FORM_strp)
7220 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
7221 a->dw_attr_val.v.val_str->label,
7222 debug_str_section,
7223 "%s: \"%s\"", name, AT_string (a));
7224 else
7225 dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
7226 break;
7227
7228 case dw_val_class_file:
7229 {
7230 int f = maybe_emit_file (a->dw_attr_val.v.val_file);
7231
7232 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
7233 a->dw_attr_val.v.val_file->filename);
7234 break;
7235 }
7236
7237 default:
7238 gcc_unreachable ();
7239 }
7240 }
7241
7242 FOR_EACH_CHILD (die, c, output_die (c));
7243
7244 /* Add null byte to terminate sibling list. */
7245 if (die->die_child != NULL)
7246 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
7247 die->die_offset);
7248 }
7249
7250 /* Output the compilation unit that appears at the beginning of the
7251 .debug_info section, and precedes the DIE descriptions. */
7252
7253 static void
output_compilation_unit_header(void)7254 output_compilation_unit_header (void)
7255 {
7256 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7257 dw2_asm_output_data (4, 0xffffffff,
7258 "Initial length escape value indicating 64-bit DWARF extension");
7259 dw2_asm_output_data (DWARF_OFFSET_SIZE,
7260 next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
7261 "Length of Compilation Unit Info");
7262 dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number");
7263 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
7264 debug_abbrev_section,
7265 "Offset Into Abbrev. Section");
7266 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
7267 }
7268
7269 /* Output the compilation unit DIE and its children. */
7270
7271 static void
output_comp_unit(dw_die_ref die,int output_if_empty)7272 output_comp_unit (dw_die_ref die, int output_if_empty)
7273 {
7274 const char *secname;
7275 char *oldsym, *tmp;
7276
7277 /* Unless we are outputting main CU, we may throw away empty ones. */
7278 if (!output_if_empty && die->die_child == NULL)
7279 return;
7280
7281 /* Even if there are no children of this DIE, we must output the information
7282 about the compilation unit. Otherwise, on an empty translation unit, we
7283 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
7284 will then complain when examining the file. First mark all the DIEs in
7285 this CU so we know which get local refs. */
7286 mark_dies (die);
7287
7288 build_abbrev_table (die);
7289
7290 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
7291 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
7292 calc_die_sizes (die);
7293
7294 oldsym = die->die_symbol;
7295 if (oldsym)
7296 {
7297 tmp = alloca (strlen (oldsym) + 24);
7298
7299 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
7300 secname = tmp;
7301 die->die_symbol = NULL;
7302 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
7303 }
7304 else
7305 switch_to_section (debug_info_section);
7306
7307 /* Output debugging information. */
7308 output_compilation_unit_header ();
7309 output_die (die);
7310
7311 /* Leave the marks on the main CU, so we can check them in
7312 output_pubnames. */
7313 if (oldsym)
7314 {
7315 unmark_dies (die);
7316 die->die_symbol = oldsym;
7317 }
7318 }
7319
7320 /* Return the DWARF2/3 pubname associated with a decl. */
7321
7322 static const char *
dwarf2_name(tree decl,int scope)7323 dwarf2_name (tree decl, int scope)
7324 {
7325 return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
7326 }
7327
7328 /* Add a new entry to .debug_pubnames if appropriate. */
7329
7330 static void
add_pubname(tree decl,dw_die_ref die)7331 add_pubname (tree decl, dw_die_ref die)
7332 {
7333 pubname_ref p;
7334
7335 if (! TREE_PUBLIC (decl))
7336 return;
7337
7338 if (pubname_table_in_use == pubname_table_allocated)
7339 {
7340 pubname_table_allocated += PUBNAME_TABLE_INCREMENT;
7341 pubname_table
7342 = ggc_realloc (pubname_table,
7343 (pubname_table_allocated * sizeof (pubname_entry)));
7344 memset (pubname_table + pubname_table_in_use, 0,
7345 PUBNAME_TABLE_INCREMENT * sizeof (pubname_entry));
7346 }
7347
7348 p = &pubname_table[pubname_table_in_use++];
7349 p->die = die;
7350 p->name = xstrdup (dwarf2_name (decl, 1));
7351 }
7352
7353 /* Output the public names table used to speed up access to externally
7354 visible names. For now, only generate entries for externally
7355 visible procedures. */
7356
7357 static void
output_pubnames(void)7358 output_pubnames (void)
7359 {
7360 unsigned i;
7361 unsigned long pubnames_length = size_of_pubnames ();
7362
7363 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7364 dw2_asm_output_data (4, 0xffffffff,
7365 "Initial length escape value indicating 64-bit DWARF extension");
7366 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
7367 "Length of Public Names Info");
7368 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7369 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7370 debug_info_section,
7371 "Offset of Compilation Unit Info");
7372 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
7373 "Compilation Unit Length");
7374
7375 for (i = 0; i < pubname_table_in_use; i++)
7376 {
7377 pubname_ref pub = &pubname_table[i];
7378
7379 /* We shouldn't see pubnames for DIEs outside of the main CU. */
7380 gcc_assert (pub->die->die_mark);
7381
7382 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
7383 "DIE offset");
7384
7385 dw2_asm_output_nstring (pub->name, -1, "external name");
7386 }
7387
7388 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
7389 }
7390
7391 /* Add a new entry to .debug_aranges if appropriate. */
7392
7393 static void
add_arange(tree decl,dw_die_ref die)7394 add_arange (tree decl, dw_die_ref die)
7395 {
7396 if (! DECL_SECTION_NAME (decl))
7397 return;
7398
7399 if (arange_table_in_use == arange_table_allocated)
7400 {
7401 arange_table_allocated += ARANGE_TABLE_INCREMENT;
7402 arange_table = ggc_realloc (arange_table,
7403 (arange_table_allocated
7404 * sizeof (dw_die_ref)));
7405 memset (arange_table + arange_table_in_use, 0,
7406 ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
7407 }
7408
7409 arange_table[arange_table_in_use++] = die;
7410 }
7411
7412 /* Output the information that goes into the .debug_aranges table.
7413 Namely, define the beginning and ending address range of the
7414 text section generated for this compilation unit. */
7415
7416 static void
output_aranges(void)7417 output_aranges (void)
7418 {
7419 unsigned i;
7420 unsigned long aranges_length = size_of_aranges ();
7421
7422 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7423 dw2_asm_output_data (4, 0xffffffff,
7424 "Initial length escape value indicating 64-bit DWARF extension");
7425 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
7426 "Length of Address Ranges Info");
7427 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7428 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7429 debug_info_section,
7430 "Offset of Compilation Unit Info");
7431 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
7432 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
7433
7434 /* We need to align to twice the pointer size here. */
7435 if (DWARF_ARANGES_PAD_SIZE)
7436 {
7437 /* Pad using a 2 byte words so that padding is correct for any
7438 pointer size. */
7439 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
7440 2 * DWARF2_ADDR_SIZE);
7441 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
7442 dw2_asm_output_data (2, 0, NULL);
7443 }
7444
7445 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
7446 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
7447 text_section_label, "Length");
7448 if (flag_reorder_blocks_and_partition)
7449 {
7450 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
7451 "Address");
7452 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
7453 cold_text_section_label, "Length");
7454 }
7455
7456 for (i = 0; i < arange_table_in_use; i++)
7457 {
7458 dw_die_ref die = arange_table[i];
7459
7460 /* We shouldn't see aranges for DIEs outside of the main CU. */
7461 gcc_assert (die->die_mark);
7462
7463 if (die->die_tag == DW_TAG_subprogram)
7464 {
7465 dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
7466 "Address");
7467 dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
7468 get_AT_low_pc (die), "Length");
7469 }
7470 else
7471 {
7472 /* A static variable; extract the symbol from DW_AT_location.
7473 Note that this code isn't currently hit, as we only emit
7474 aranges for functions (jason 9/23/99). */
7475 dw_attr_ref a = get_AT (die, DW_AT_location);
7476 dw_loc_descr_ref loc;
7477
7478 gcc_assert (a && AT_class (a) == dw_val_class_loc);
7479
7480 loc = AT_loc (a);
7481 gcc_assert (loc->dw_loc_opc == DW_OP_addr);
7482
7483 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
7484 loc->dw_loc_oprnd1.v.val_addr, "Address");
7485 dw2_asm_output_data (DWARF2_ADDR_SIZE,
7486 get_AT_unsigned (die, DW_AT_byte_size),
7487 "Length");
7488 }
7489 }
7490
7491 /* Output the terminator words. */
7492 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7493 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7494 }
7495
7496 /* Add a new entry to .debug_ranges. Return the offset at which it
7497 was placed. */
7498
7499 static unsigned int
add_ranges(tree block)7500 add_ranges (tree block)
7501 {
7502 unsigned int in_use = ranges_table_in_use;
7503
7504 if (in_use == ranges_table_allocated)
7505 {
7506 ranges_table_allocated += RANGES_TABLE_INCREMENT;
7507 ranges_table
7508 = ggc_realloc (ranges_table, (ranges_table_allocated
7509 * sizeof (struct dw_ranges_struct)));
7510 memset (ranges_table + ranges_table_in_use, 0,
7511 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
7512 }
7513
7514 ranges_table[in_use].block_num = (block ? BLOCK_NUMBER (block) : 0);
7515 ranges_table_in_use = in_use + 1;
7516
7517 return in_use * 2 * DWARF2_ADDR_SIZE;
7518 }
7519
7520 static void
output_ranges(void)7521 output_ranges (void)
7522 {
7523 unsigned i;
7524 static const char *const start_fmt = "Offset 0x%x";
7525 const char *fmt = start_fmt;
7526
7527 for (i = 0; i < ranges_table_in_use; i++)
7528 {
7529 int block_num = ranges_table[i].block_num;
7530
7531 if (block_num)
7532 {
7533 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
7534 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
7535
7536 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
7537 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
7538
7539 /* If all code is in the text section, then the compilation
7540 unit base address defaults to DW_AT_low_pc, which is the
7541 base of the text section. */
7542 if (!have_multiple_function_sections)
7543 {
7544 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
7545 text_section_label,
7546 fmt, i * 2 * DWARF2_ADDR_SIZE);
7547 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
7548 text_section_label, NULL);
7549 }
7550
7551 /* Otherwise, we add a DW_AT_entry_pc attribute to force the
7552 compilation unit base address to zero, which allows us to
7553 use absolute addresses, and not worry about whether the
7554 target supports cross-section arithmetic. */
7555 else
7556 {
7557 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
7558 fmt, i * 2 * DWARF2_ADDR_SIZE);
7559 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
7560 }
7561
7562 fmt = NULL;
7563 }
7564 else
7565 {
7566 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7567 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7568 fmt = start_fmt;
7569 }
7570 }
7571 }
7572
7573 /* Data structure containing information about input files. */
7574 struct file_info
7575 {
7576 const char *path; /* Complete file name. */
7577 const char *fname; /* File name part. */
7578 int length; /* Length of entire string. */
7579 struct dwarf_file_data * file_idx; /* Index in input file table. */
7580 int dir_idx; /* Index in directory table. */
7581 };
7582
7583 /* Data structure containing information about directories with source
7584 files. */
7585 struct dir_info
7586 {
7587 const char *path; /* Path including directory name. */
7588 int length; /* Path length. */
7589 int prefix; /* Index of directory entry which is a prefix. */
7590 int count; /* Number of files in this directory. */
7591 int dir_idx; /* Index of directory used as base. */
7592 };
7593
7594 /* Callback function for file_info comparison. We sort by looking at
7595 the directories in the path. */
7596
7597 static int
file_info_cmp(const void * p1,const void * p2)7598 file_info_cmp (const void *p1, const void *p2)
7599 {
7600 const struct file_info *s1 = p1;
7601 const struct file_info *s2 = p2;
7602 unsigned char *cp1;
7603 unsigned char *cp2;
7604
7605 /* Take care of file names without directories. We need to make sure that
7606 we return consistent values to qsort since some will get confused if
7607 we return the same value when identical operands are passed in opposite
7608 orders. So if neither has a directory, return 0 and otherwise return
7609 1 or -1 depending on which one has the directory. */
7610 if ((s1->path == s1->fname || s2->path == s2->fname))
7611 return (s2->path == s2->fname) - (s1->path == s1->fname);
7612
7613 cp1 = (unsigned char *) s1->path;
7614 cp2 = (unsigned char *) s2->path;
7615
7616 while (1)
7617 {
7618 ++cp1;
7619 ++cp2;
7620 /* Reached the end of the first path? If so, handle like above. */
7621 if ((cp1 == (unsigned char *) s1->fname)
7622 || (cp2 == (unsigned char *) s2->fname))
7623 return ((cp2 == (unsigned char *) s2->fname)
7624 - (cp1 == (unsigned char *) s1->fname));
7625
7626 /* Character of current path component the same? */
7627 else if (*cp1 != *cp2)
7628 return *cp1 - *cp2;
7629 }
7630 }
7631
7632 struct file_name_acquire_data
7633 {
7634 struct file_info *files;
7635 int used_files;
7636 int max_files;
7637 };
7638
7639 /* Traversal function for the hash table. */
7640
7641 static int
file_name_acquire(void ** slot,void * data)7642 file_name_acquire (void ** slot, void *data)
7643 {
7644 struct file_name_acquire_data *fnad = data;
7645 struct dwarf_file_data *d = *slot;
7646 struct file_info *fi;
7647 const char *f;
7648
7649 gcc_assert (fnad->max_files >= d->emitted_number);
7650
7651 if (! d->emitted_number)
7652 return 1;
7653
7654 gcc_assert (fnad->max_files != fnad->used_files);
7655
7656 fi = fnad->files + fnad->used_files++;
7657
7658 /* Skip all leading "./". */
7659 f = d->filename;
7660 while (f[0] == '.' && f[1] == '/')
7661 f += 2;
7662
7663 /* Create a new array entry. */
7664 fi->path = f;
7665 fi->length = strlen (f);
7666 fi->file_idx = d;
7667
7668 /* Search for the file name part. */
7669 f = strrchr (f, '/');
7670 fi->fname = f == NULL ? fi->path : f + 1;
7671 return 1;
7672 }
7673
7674 /* Output the directory table and the file name table. We try to minimize
7675 the total amount of memory needed. A heuristic is used to avoid large
7676 slowdowns with many input files. */
7677
7678 static void
output_file_names(void)7679 output_file_names (void)
7680 {
7681 struct file_name_acquire_data fnad;
7682 int numfiles;
7683 struct file_info *files;
7684 struct dir_info *dirs;
7685 int *saved;
7686 int *savehere;
7687 int *backmap;
7688 int ndirs;
7689 int idx_offset;
7690 int i;
7691 int idx;
7692
7693 if (!last_emitted_file)
7694 {
7695 dw2_asm_output_data (1, 0, "End directory table");
7696 dw2_asm_output_data (1, 0, "End file name table");
7697 return;
7698 }
7699
7700 numfiles = last_emitted_file->emitted_number;
7701
7702 /* Allocate the various arrays we need. */
7703 files = alloca (numfiles * sizeof (struct file_info));
7704 dirs = alloca (numfiles * sizeof (struct dir_info));
7705
7706 fnad.files = files;
7707 fnad.used_files = 0;
7708 fnad.max_files = numfiles;
7709 htab_traverse (file_table, file_name_acquire, &fnad);
7710 gcc_assert (fnad.used_files == fnad.max_files);
7711
7712 qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
7713
7714 /* Find all the different directories used. */
7715 dirs[0].path = files[0].path;
7716 dirs[0].length = files[0].fname - files[0].path;
7717 dirs[0].prefix = -1;
7718 dirs[0].count = 1;
7719 dirs[0].dir_idx = 0;
7720 files[0].dir_idx = 0;
7721 ndirs = 1;
7722
7723 for (i = 1; i < numfiles; i++)
7724 if (files[i].fname - files[i].path == dirs[ndirs - 1].length
7725 && memcmp (dirs[ndirs - 1].path, files[i].path,
7726 dirs[ndirs - 1].length) == 0)
7727 {
7728 /* Same directory as last entry. */
7729 files[i].dir_idx = ndirs - 1;
7730 ++dirs[ndirs - 1].count;
7731 }
7732 else
7733 {
7734 int j;
7735
7736 /* This is a new directory. */
7737 dirs[ndirs].path = files[i].path;
7738 dirs[ndirs].length = files[i].fname - files[i].path;
7739 dirs[ndirs].count = 1;
7740 dirs[ndirs].dir_idx = ndirs;
7741 files[i].dir_idx = ndirs;
7742
7743 /* Search for a prefix. */
7744 dirs[ndirs].prefix = -1;
7745 for (j = 0; j < ndirs; j++)
7746 if (dirs[j].length < dirs[ndirs].length
7747 && dirs[j].length > 1
7748 && (dirs[ndirs].prefix == -1
7749 || dirs[j].length > dirs[dirs[ndirs].prefix].length)
7750 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
7751 dirs[ndirs].prefix = j;
7752
7753 ++ndirs;
7754 }
7755
7756 /* Now to the actual work. We have to find a subset of the directories which
7757 allow expressing the file name using references to the directory table
7758 with the least amount of characters. We do not do an exhaustive search
7759 where we would have to check out every combination of every single
7760 possible prefix. Instead we use a heuristic which provides nearly optimal
7761 results in most cases and never is much off. */
7762 saved = alloca (ndirs * sizeof (int));
7763 savehere = alloca (ndirs * sizeof (int));
7764
7765 memset (saved, '\0', ndirs * sizeof (saved[0]));
7766 for (i = 0; i < ndirs; i++)
7767 {
7768 int j;
7769 int total;
7770
7771 /* We can always save some space for the current directory. But this
7772 does not mean it will be enough to justify adding the directory. */
7773 savehere[i] = dirs[i].length;
7774 total = (savehere[i] - saved[i]) * dirs[i].count;
7775
7776 for (j = i + 1; j < ndirs; j++)
7777 {
7778 savehere[j] = 0;
7779 if (saved[j] < dirs[i].length)
7780 {
7781 /* Determine whether the dirs[i] path is a prefix of the
7782 dirs[j] path. */
7783 int k;
7784
7785 k = dirs[j].prefix;
7786 while (k != -1 && k != (int) i)
7787 k = dirs[k].prefix;
7788
7789 if (k == (int) i)
7790 {
7791 /* Yes it is. We can possibly save some memory by
7792 writing the filenames in dirs[j] relative to
7793 dirs[i]. */
7794 savehere[j] = dirs[i].length;
7795 total += (savehere[j] - saved[j]) * dirs[j].count;
7796 }
7797 }
7798 }
7799
7800 /* Check whether we can save enough to justify adding the dirs[i]
7801 directory. */
7802 if (total > dirs[i].length + 1)
7803 {
7804 /* It's worthwhile adding. */
7805 for (j = i; j < ndirs; j++)
7806 if (savehere[j] > 0)
7807 {
7808 /* Remember how much we saved for this directory so far. */
7809 saved[j] = savehere[j];
7810
7811 /* Remember the prefix directory. */
7812 dirs[j].dir_idx = i;
7813 }
7814 }
7815 }
7816
7817 /* Emit the directory name table. */
7818 idx = 1;
7819 idx_offset = dirs[0].length > 0 ? 1 : 0;
7820 for (i = 1 - idx_offset; i < ndirs; i++)
7821 dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1,
7822 "Directory Entry: 0x%x", i + idx_offset);
7823
7824 dw2_asm_output_data (1, 0, "End directory table");
7825
7826 /* We have to emit them in the order of emitted_number since that's
7827 used in the debug info generation. To do this efficiently we
7828 generate a back-mapping of the indices first. */
7829 backmap = alloca (numfiles * sizeof (int));
7830 for (i = 0; i < numfiles; i++)
7831 backmap[files[i].file_idx->emitted_number - 1] = i;
7832
7833 /* Now write all the file names. */
7834 for (i = 0; i < numfiles; i++)
7835 {
7836 int file_idx = backmap[i];
7837 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
7838
7839 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
7840 "File Entry: 0x%x", (unsigned) i + 1);
7841
7842 /* Include directory index. */
7843 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
7844
7845 /* Modification time. */
7846 dw2_asm_output_data_uleb128 (0, NULL);
7847
7848 /* File length in bytes. */
7849 dw2_asm_output_data_uleb128 (0, NULL);
7850 }
7851
7852 dw2_asm_output_data (1, 0, "End file name table");
7853 }
7854
7855
7856 /* Output the source line number correspondence information. This
7857 information goes into the .debug_line section. */
7858
7859 static void
output_line_info(void)7860 output_line_info (void)
7861 {
7862 char l1[20], l2[20], p1[20], p2[20];
7863 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7864 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7865 unsigned opc;
7866 unsigned n_op_args;
7867 unsigned long lt_index;
7868 unsigned long current_line;
7869 long line_offset;
7870 long line_delta;
7871 unsigned long current_file;
7872 unsigned long function;
7873
7874 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
7875 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
7876 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
7877 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
7878
7879 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7880 dw2_asm_output_data (4, 0xffffffff,
7881 "Initial length escape value indicating 64-bit DWARF extension");
7882 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
7883 "Length of Source Line Info");
7884 ASM_OUTPUT_LABEL (asm_out_file, l1);
7885
7886 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7887 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
7888 ASM_OUTPUT_LABEL (asm_out_file, p1);
7889
7890 /* Define the architecture-dependent minimum instruction length (in
7891 bytes). In this implementation of DWARF, this field is used for
7892 information purposes only. Since GCC generates assembly language,
7893 we have no a priori knowledge of how many instruction bytes are
7894 generated for each source line, and therefore can use only the
7895 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
7896 commands. Accordingly, we fix this as `1', which is "correct
7897 enough" for all architectures, and don't let the target override. */
7898 dw2_asm_output_data (1, 1,
7899 "Minimum Instruction Length");
7900
7901 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
7902 "Default is_stmt_start flag");
7903 dw2_asm_output_data (1, DWARF_LINE_BASE,
7904 "Line Base Value (Special Opcodes)");
7905 dw2_asm_output_data (1, DWARF_LINE_RANGE,
7906 "Line Range Value (Special Opcodes)");
7907 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
7908 "Special Opcode Base");
7909
7910 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
7911 {
7912 switch (opc)
7913 {
7914 case DW_LNS_advance_pc:
7915 case DW_LNS_advance_line:
7916 case DW_LNS_set_file:
7917 case DW_LNS_set_column:
7918 case DW_LNS_fixed_advance_pc:
7919 n_op_args = 1;
7920 break;
7921 default:
7922 n_op_args = 0;
7923 break;
7924 }
7925
7926 dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
7927 opc, n_op_args);
7928 }
7929
7930 /* Write out the information about the files we use. */
7931 output_file_names ();
7932 ASM_OUTPUT_LABEL (asm_out_file, p2);
7933
7934 /* We used to set the address register to the first location in the text
7935 section here, but that didn't accomplish anything since we already
7936 have a line note for the opening brace of the first function. */
7937
7938 /* Generate the line number to PC correspondence table, encoded as
7939 a series of state machine operations. */
7940 current_file = 1;
7941 current_line = 1;
7942
7943 if (cfun && in_cold_section_p)
7944 strcpy (prev_line_label, cfun->cold_section_label);
7945 else
7946 strcpy (prev_line_label, text_section_label);
7947 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
7948 {
7949 dw_line_info_ref line_info = &line_info_table[lt_index];
7950
7951 #if 0
7952 /* Disable this optimization for now; GDB wants to see two line notes
7953 at the beginning of a function so it can find the end of the
7954 prologue. */
7955
7956 /* Don't emit anything for redundant notes. Just updating the
7957 address doesn't accomplish anything, because we already assume
7958 that anything after the last address is this line. */
7959 if (line_info->dw_line_num == current_line
7960 && line_info->dw_file_num == current_file)
7961 continue;
7962 #endif
7963
7964 /* Emit debug info for the address of the current line.
7965
7966 Unfortunately, we have little choice here currently, and must always
7967 use the most general form. GCC does not know the address delta
7968 itself, so we can't use DW_LNS_advance_pc. Many ports do have length
7969 attributes which will give an upper bound on the address range. We
7970 could perhaps use length attributes to determine when it is safe to
7971 use DW_LNS_fixed_advance_pc. */
7972
7973 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
7974 if (0)
7975 {
7976 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
7977 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7978 "DW_LNS_fixed_advance_pc");
7979 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
7980 }
7981 else
7982 {
7983 /* This can handle any delta. This takes
7984 4+DWARF2_ADDR_SIZE bytes. */
7985 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7986 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7987 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7988 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7989 }
7990
7991 strcpy (prev_line_label, line_label);
7992
7993 /* Emit debug info for the source file of the current line, if
7994 different from the previous line. */
7995 if (line_info->dw_file_num != current_file)
7996 {
7997 current_file = line_info->dw_file_num;
7998 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
7999 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
8000 }
8001
8002 /* Emit debug info for the current line number, choosing the encoding
8003 that uses the least amount of space. */
8004 if (line_info->dw_line_num != current_line)
8005 {
8006 line_offset = line_info->dw_line_num - current_line;
8007 line_delta = line_offset - DWARF_LINE_BASE;
8008 current_line = line_info->dw_line_num;
8009 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
8010 /* This can handle deltas from -10 to 234, using the current
8011 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
8012 takes 1 byte. */
8013 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
8014 "line %lu", current_line);
8015 else
8016 {
8017 /* This can handle any delta. This takes at least 4 bytes,
8018 depending on the value being encoded. */
8019 dw2_asm_output_data (1, DW_LNS_advance_line,
8020 "advance to line %lu", current_line);
8021 dw2_asm_output_data_sleb128 (line_offset, NULL);
8022 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8023 }
8024 }
8025 else
8026 /* We still need to start a new row, so output a copy insn. */
8027 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8028 }
8029
8030 /* Emit debug info for the address of the end of the function. */
8031 if (0)
8032 {
8033 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8034 "DW_LNS_fixed_advance_pc");
8035 dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
8036 }
8037 else
8038 {
8039 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8040 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8041 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8042 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
8043 }
8044
8045 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
8046 dw2_asm_output_data_uleb128 (1, NULL);
8047 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
8048
8049 function = 0;
8050 current_file = 1;
8051 current_line = 1;
8052 for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
8053 {
8054 dw_separate_line_info_ref line_info
8055 = &separate_line_info_table[lt_index];
8056
8057 #if 0
8058 /* Don't emit anything for redundant notes. */
8059 if (line_info->dw_line_num == current_line
8060 && line_info->dw_file_num == current_file
8061 && line_info->function == function)
8062 goto cont;
8063 #endif
8064
8065 /* Emit debug info for the address of the current line. If this is
8066 a new function, or the first line of a function, then we need
8067 to handle it differently. */
8068 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
8069 lt_index);
8070 if (function != line_info->function)
8071 {
8072 function = line_info->function;
8073
8074 /* Set the address register to the first line in the function. */
8075 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8076 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8077 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8078 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8079 }
8080 else
8081 {
8082 /* ??? See the DW_LNS_advance_pc comment above. */
8083 if (0)
8084 {
8085 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8086 "DW_LNS_fixed_advance_pc");
8087 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
8088 }
8089 else
8090 {
8091 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8092 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8093 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8094 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8095 }
8096 }
8097
8098 strcpy (prev_line_label, line_label);
8099
8100 /* Emit debug info for the source file of the current line, if
8101 different from the previous line. */
8102 if (line_info->dw_file_num != current_file)
8103 {
8104 current_file = line_info->dw_file_num;
8105 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
8106 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
8107 }
8108
8109 /* Emit debug info for the current line number, choosing the encoding
8110 that uses the least amount of space. */
8111 if (line_info->dw_line_num != current_line)
8112 {
8113 line_offset = line_info->dw_line_num - current_line;
8114 line_delta = line_offset - DWARF_LINE_BASE;
8115 current_line = line_info->dw_line_num;
8116 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
8117 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
8118 "line %lu", current_line);
8119 else
8120 {
8121 dw2_asm_output_data (1, DW_LNS_advance_line,
8122 "advance to line %lu", current_line);
8123 dw2_asm_output_data_sleb128 (line_offset, NULL);
8124 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8125 }
8126 }
8127 else
8128 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8129
8130 #if 0
8131 cont:
8132 #endif
8133
8134 lt_index++;
8135
8136 /* If we're done with a function, end its sequence. */
8137 if (lt_index == separate_line_info_table_in_use
8138 || separate_line_info_table[lt_index].function != function)
8139 {
8140 current_file = 1;
8141 current_line = 1;
8142
8143 /* Emit debug info for the address of the end of the function. */
8144 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
8145 if (0)
8146 {
8147 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8148 "DW_LNS_fixed_advance_pc");
8149 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
8150 }
8151 else
8152 {
8153 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8154 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8155 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8156 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8157 }
8158
8159 /* Output the marker for the end of this sequence. */
8160 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
8161 dw2_asm_output_data_uleb128 (1, NULL);
8162 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
8163 }
8164 }
8165
8166 /* Output the marker for the end of the line number info. */
8167 ASM_OUTPUT_LABEL (asm_out_file, l2);
8168 }
8169
8170 /* Given a pointer to a tree node for some base type, return a pointer to
8171 a DIE that describes the given type.
8172
8173 This routine must only be called for GCC type nodes that correspond to
8174 Dwarf base (fundamental) types. */
8175
8176 static dw_die_ref
base_type_die(tree type)8177 base_type_die (tree type)
8178 {
8179 dw_die_ref base_type_result;
8180 enum dwarf_type encoding;
8181
8182 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
8183 return 0;
8184
8185 switch (TREE_CODE (type))
8186 {
8187 case INTEGER_TYPE:
8188 if (TYPE_STRING_FLAG (type))
8189 {
8190 if (TYPE_UNSIGNED (type))
8191 encoding = DW_ATE_unsigned_char;
8192 else
8193 encoding = DW_ATE_signed_char;
8194 }
8195 else if (TYPE_UNSIGNED (type))
8196 encoding = DW_ATE_unsigned;
8197 else
8198 encoding = DW_ATE_signed;
8199 break;
8200
8201 case REAL_TYPE:
8202 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
8203 encoding = DW_ATE_decimal_float;
8204 else
8205 encoding = DW_ATE_float;
8206 break;
8207
8208 /* Dwarf2 doesn't know anything about complex ints, so use
8209 a user defined type for it. */
8210 case COMPLEX_TYPE:
8211 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
8212 encoding = DW_ATE_complex_float;
8213 else
8214 encoding = DW_ATE_lo_user;
8215 break;
8216
8217 case BOOLEAN_TYPE:
8218 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
8219 encoding = DW_ATE_boolean;
8220 break;
8221
8222 default:
8223 /* No other TREE_CODEs are Dwarf fundamental types. */
8224 gcc_unreachable ();
8225 }
8226
8227 base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
8228
8229 /* This probably indicates a bug. */
8230 if (! TYPE_NAME (type))
8231 add_name_attribute (base_type_result, "__unknown__");
8232
8233 add_AT_unsigned (base_type_result, DW_AT_byte_size,
8234 int_size_in_bytes (type));
8235 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
8236
8237 return base_type_result;
8238 }
8239
8240 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
8241 the Dwarf "root" type for the given input type. The Dwarf "root" type of
8242 a given type is generally the same as the given type, except that if the
8243 given type is a pointer or reference type, then the root type of the given
8244 type is the root type of the "basis" type for the pointer or reference
8245 type. (This definition of the "root" type is recursive.) Also, the root
8246 type of a `const' qualified type or a `volatile' qualified type is the
8247 root type of the given type without the qualifiers. */
8248
8249 static tree
root_type(tree type)8250 root_type (tree type)
8251 {
8252 if (TREE_CODE (type) == ERROR_MARK)
8253 return error_mark_node;
8254
8255 switch (TREE_CODE (type))
8256 {
8257 case ERROR_MARK:
8258 return error_mark_node;
8259
8260 case POINTER_TYPE:
8261 case REFERENCE_TYPE:
8262 return type_main_variant (root_type (TREE_TYPE (type)));
8263
8264 default:
8265 return type_main_variant (type);
8266 }
8267 }
8268
8269 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
8270 given input type is a Dwarf "fundamental" type. Otherwise return null. */
8271
8272 static inline int
is_base_type(tree type)8273 is_base_type (tree type)
8274 {
8275 switch (TREE_CODE (type))
8276 {
8277 case ERROR_MARK:
8278 case VOID_TYPE:
8279 case INTEGER_TYPE:
8280 case REAL_TYPE:
8281 case COMPLEX_TYPE:
8282 case BOOLEAN_TYPE:
8283 return 1;
8284
8285 case ARRAY_TYPE:
8286 case RECORD_TYPE:
8287 case UNION_TYPE:
8288 case QUAL_UNION_TYPE:
8289 case ENUMERAL_TYPE:
8290 case FUNCTION_TYPE:
8291 case METHOD_TYPE:
8292 case POINTER_TYPE:
8293 case REFERENCE_TYPE:
8294 case OFFSET_TYPE:
8295 case LANG_TYPE:
8296 case VECTOR_TYPE:
8297 return 0;
8298
8299 default:
8300 gcc_unreachable ();
8301 }
8302
8303 return 0;
8304 }
8305
8306 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
8307 node, return the size in bits for the type if it is a constant, or else
8308 return the alignment for the type if the type's size is not constant, or
8309 else return BITS_PER_WORD if the type actually turns out to be an
8310 ERROR_MARK node. */
8311
8312 static inline unsigned HOST_WIDE_INT
simple_type_size_in_bits(tree type)8313 simple_type_size_in_bits (tree type)
8314 {
8315 if (TREE_CODE (type) == ERROR_MARK)
8316 return BITS_PER_WORD;
8317 else if (TYPE_SIZE (type) == NULL_TREE)
8318 return 0;
8319 else if (host_integerp (TYPE_SIZE (type), 1))
8320 return tree_low_cst (TYPE_SIZE (type), 1);
8321 else
8322 return TYPE_ALIGN (type);
8323 }
8324
8325 /* Return true if the debug information for the given type should be
8326 emitted as a subrange type. */
8327
8328 static inline bool
is_subrange_type(tree type)8329 is_subrange_type (tree type)
8330 {
8331 tree subtype = TREE_TYPE (type);
8332
8333 /* Subrange types are identified by the fact that they are integer
8334 types, and that they have a subtype which is either an integer type
8335 or an enumeral type. */
8336
8337 if (TREE_CODE (type) != INTEGER_TYPE
8338 || subtype == NULL_TREE)
8339 return false;
8340
8341 if (TREE_CODE (subtype) != INTEGER_TYPE
8342 && TREE_CODE (subtype) != ENUMERAL_TYPE)
8343 return false;
8344
8345 if (TREE_CODE (type) == TREE_CODE (subtype)
8346 && int_size_in_bytes (type) == int_size_in_bytes (subtype)
8347 && TYPE_MIN_VALUE (type) != NULL
8348 && TYPE_MIN_VALUE (subtype) != NULL
8349 && tree_int_cst_equal (TYPE_MIN_VALUE (type), TYPE_MIN_VALUE (subtype))
8350 && TYPE_MAX_VALUE (type) != NULL
8351 && TYPE_MAX_VALUE (subtype) != NULL
8352 && tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype)))
8353 {
8354 /* The type and its subtype have the same representation. If in
8355 addition the two types also have the same name, then the given
8356 type is not a subrange type, but rather a plain base type. */
8357 /* FIXME: brobecker/2004-03-22:
8358 Sizetype INTEGER_CSTs nodes are canonicalized. It should
8359 therefore be sufficient to check the TYPE_SIZE node pointers
8360 rather than checking the actual size. Unfortunately, we have
8361 found some cases, such as in the Ada "integer" type, where
8362 this is not the case. Until this problem is solved, we need to
8363 keep checking the actual size. */
8364 tree type_name = TYPE_NAME (type);
8365 tree subtype_name = TYPE_NAME (subtype);
8366
8367 if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL)
8368 type_name = DECL_NAME (type_name);
8369
8370 if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL)
8371 subtype_name = DECL_NAME (subtype_name);
8372
8373 if (type_name == subtype_name)
8374 return false;
8375 }
8376
8377 return true;
8378 }
8379
8380 /* Given a pointer to a tree node for a subrange type, return a pointer
8381 to a DIE that describes the given type. */
8382
8383 static dw_die_ref
subrange_type_die(tree type,dw_die_ref context_die)8384 subrange_type_die (tree type, dw_die_ref context_die)
8385 {
8386 dw_die_ref subrange_die;
8387 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
8388
8389 if (context_die == NULL)
8390 context_die = comp_unit_die;
8391
8392 subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
8393
8394 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
8395 {
8396 /* The size of the subrange type and its base type do not match,
8397 so we need to generate a size attribute for the subrange type. */
8398 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
8399 }
8400
8401 if (TYPE_MIN_VALUE (type) != NULL)
8402 add_bound_info (subrange_die, DW_AT_lower_bound,
8403 TYPE_MIN_VALUE (type));
8404 if (TYPE_MAX_VALUE (type) != NULL)
8405 add_bound_info (subrange_die, DW_AT_upper_bound,
8406 TYPE_MAX_VALUE (type));
8407
8408 return subrange_die;
8409 }
8410
8411 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
8412 entry that chains various modifiers in front of the given type. */
8413
8414 static dw_die_ref
modified_type_die(tree type,int is_const_type,int is_volatile_type,dw_die_ref context_die)8415 modified_type_die (tree type, int is_const_type, int is_volatile_type,
8416 dw_die_ref context_die)
8417 {
8418 enum tree_code code = TREE_CODE (type);
8419 dw_die_ref mod_type_die;
8420 dw_die_ref sub_die = NULL;
8421 tree item_type = NULL;
8422 tree qualified_type;
8423 tree name;
8424
8425 if (code == ERROR_MARK)
8426 return NULL;
8427
8428 /* See if we already have the appropriately qualified variant of
8429 this type. */
8430 qualified_type
8431 = get_qualified_type (type,
8432 ((is_const_type ? TYPE_QUAL_CONST : 0)
8433 | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
8434
8435 /* If we do, then we can just use its DIE, if it exists. */
8436 if (qualified_type)
8437 {
8438 mod_type_die = lookup_type_die (qualified_type);
8439 if (mod_type_die)
8440 return mod_type_die;
8441 }
8442
8443 name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
8444
8445 /* Handle C typedef types. */
8446 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name))
8447 {
8448 tree dtype = TREE_TYPE (name);
8449
8450 if (qualified_type == dtype)
8451 {
8452 /* For a named type, use the typedef. */
8453 gen_type_die (qualified_type, context_die);
8454 return lookup_type_die (qualified_type);
8455 }
8456 else if (is_const_type < TYPE_READONLY (dtype)
8457 || is_volatile_type < TYPE_VOLATILE (dtype)
8458 || (is_const_type <= TYPE_READONLY (dtype)
8459 && is_volatile_type <= TYPE_VOLATILE (dtype)
8460 && DECL_ORIGINAL_TYPE (name) != type))
8461 /* cv-unqualified version of named type. Just use the unnamed
8462 type to which it refers. */
8463 return modified_type_die (DECL_ORIGINAL_TYPE (name),
8464 is_const_type, is_volatile_type,
8465 context_die);
8466 /* Else cv-qualified version of named type; fall through. */
8467 }
8468
8469 if (is_const_type)
8470 {
8471 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
8472 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
8473 }
8474 else if (is_volatile_type)
8475 {
8476 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
8477 sub_die = modified_type_die (type, 0, 0, context_die);
8478 }
8479 else if (code == POINTER_TYPE)
8480 {
8481 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
8482 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8483 simple_type_size_in_bits (type) / BITS_PER_UNIT);
8484 item_type = TREE_TYPE (type);
8485 }
8486 else if (code == REFERENCE_TYPE)
8487 {
8488 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
8489 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8490 simple_type_size_in_bits (type) / BITS_PER_UNIT);
8491 item_type = TREE_TYPE (type);
8492 }
8493 else if (is_subrange_type (type))
8494 {
8495 mod_type_die = subrange_type_die (type, context_die);
8496 item_type = TREE_TYPE (type);
8497 }
8498 else if (is_base_type (type))
8499 mod_type_die = base_type_die (type);
8500 else
8501 {
8502 gen_type_die (type, context_die);
8503
8504 /* We have to get the type_main_variant here (and pass that to the
8505 `lookup_type_die' routine) because the ..._TYPE node we have
8506 might simply be a *copy* of some original type node (where the
8507 copy was created to help us keep track of typedef names) and
8508 that copy might have a different TYPE_UID from the original
8509 ..._TYPE node. */
8510 if (TREE_CODE (type) != VECTOR_TYPE)
8511 return lookup_type_die (type_main_variant (type));
8512 else
8513 /* Vectors have the debugging information in the type,
8514 not the main variant. */
8515 return lookup_type_die (type);
8516 }
8517
8518 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
8519 don't output a DW_TAG_typedef, since there isn't one in the
8520 user's program; just attach a DW_AT_name to the type. */
8521 if (name
8522 && (TREE_CODE (name) != TYPE_DECL || TREE_TYPE (name) == qualified_type))
8523 {
8524 if (TREE_CODE (name) == TYPE_DECL)
8525 /* Could just call add_name_and_src_coords_attributes here,
8526 but since this is a builtin type it doesn't have any
8527 useful source coordinates anyway. */
8528 name = DECL_NAME (name);
8529 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
8530 }
8531
8532 if (qualified_type)
8533 equate_type_number_to_die (qualified_type, mod_type_die);
8534
8535 if (item_type)
8536 /* We must do this after the equate_type_number_to_die call, in case
8537 this is a recursive type. This ensures that the modified_type_die
8538 recursion will terminate even if the type is recursive. Recursive
8539 types are possible in Ada. */
8540 sub_die = modified_type_die (item_type,
8541 TYPE_READONLY (item_type),
8542 TYPE_VOLATILE (item_type),
8543 context_die);
8544
8545 if (sub_die != NULL)
8546 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
8547
8548 return mod_type_die;
8549 }
8550
8551 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
8552 an enumerated type. */
8553
8554 static inline int
type_is_enum(tree type)8555 type_is_enum (tree type)
8556 {
8557 return TREE_CODE (type) == ENUMERAL_TYPE;
8558 }
8559
8560 /* Return the DBX register number described by a given RTL node. */
8561
8562 static unsigned int
dbx_reg_number(rtx rtl)8563 dbx_reg_number (rtx rtl)
8564 {
8565 unsigned regno = REGNO (rtl);
8566
8567 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
8568
8569 #ifdef LEAF_REG_REMAP
8570 if (current_function_uses_only_leaf_regs)
8571 {
8572 int leaf_reg = LEAF_REG_REMAP (regno);
8573 if (leaf_reg != -1)
8574 regno = (unsigned) leaf_reg;
8575 }
8576 #endif
8577
8578 return DBX_REGISTER_NUMBER (regno);
8579 }
8580
8581 /* Optionally add a DW_OP_piece term to a location description expression.
8582 DW_OP_piece is only added if the location description expression already
8583 doesn't end with DW_OP_piece. */
8584
8585 static void
add_loc_descr_op_piece(dw_loc_descr_ref * list_head,int size)8586 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
8587 {
8588 dw_loc_descr_ref loc;
8589
8590 if (*list_head != NULL)
8591 {
8592 /* Find the end of the chain. */
8593 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
8594 ;
8595
8596 if (loc->dw_loc_opc != DW_OP_piece)
8597 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
8598 }
8599 }
8600
8601 /* Return a location descriptor that designates a machine register or
8602 zero if there is none. */
8603
8604 static dw_loc_descr_ref
reg_loc_descriptor(rtx rtl)8605 reg_loc_descriptor (rtx rtl)
8606 {
8607 rtx regs;
8608
8609 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
8610 return 0;
8611
8612 regs = targetm.dwarf_register_span (rtl);
8613
8614 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
8615 return multiple_reg_loc_descriptor (rtl, regs);
8616 else
8617 return one_reg_loc_descriptor (dbx_reg_number (rtl));
8618 }
8619
8620 /* Return a location descriptor that designates a machine register for
8621 a given hard register number. */
8622
8623 static dw_loc_descr_ref
one_reg_loc_descriptor(unsigned int regno)8624 one_reg_loc_descriptor (unsigned int regno)
8625 {
8626 if (regno <= 31)
8627 return new_loc_descr (DW_OP_reg0 + regno, 0, 0);
8628 else
8629 return new_loc_descr (DW_OP_regx, regno, 0);
8630 }
8631
8632 /* Given an RTL of a register, return a location descriptor that
8633 designates a value that spans more than one register. */
8634
8635 static dw_loc_descr_ref
multiple_reg_loc_descriptor(rtx rtl,rtx regs)8636 multiple_reg_loc_descriptor (rtx rtl, rtx regs)
8637 {
8638 int nregs, size, i;
8639 unsigned reg;
8640 dw_loc_descr_ref loc_result = NULL;
8641
8642 reg = REGNO (rtl);
8643 #ifdef LEAF_REG_REMAP
8644 if (current_function_uses_only_leaf_regs)
8645 {
8646 int leaf_reg = LEAF_REG_REMAP (reg);
8647 if (leaf_reg != -1)
8648 reg = (unsigned) leaf_reg;
8649 }
8650 #endif
8651 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
8652 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
8653
8654 /* Simple, contiguous registers. */
8655 if (regs == NULL_RTX)
8656 {
8657 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
8658
8659 loc_result = NULL;
8660 while (nregs--)
8661 {
8662 dw_loc_descr_ref t;
8663
8664 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg));
8665 add_loc_descr (&loc_result, t);
8666 add_loc_descr_op_piece (&loc_result, size);
8667 ++reg;
8668 }
8669 return loc_result;
8670 }
8671
8672 /* Now onto stupid register sets in non contiguous locations. */
8673
8674 gcc_assert (GET_CODE (regs) == PARALLEL);
8675
8676 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8677 loc_result = NULL;
8678
8679 for (i = 0; i < XVECLEN (regs, 0); ++i)
8680 {
8681 dw_loc_descr_ref t;
8682
8683 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)));
8684 add_loc_descr (&loc_result, t);
8685 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8686 add_loc_descr_op_piece (&loc_result, size);
8687 }
8688 return loc_result;
8689 }
8690
8691 /* Return a location descriptor that designates a constant. */
8692
8693 static dw_loc_descr_ref
int_loc_descriptor(HOST_WIDE_INT i)8694 int_loc_descriptor (HOST_WIDE_INT i)
8695 {
8696 enum dwarf_location_atom op;
8697
8698 /* Pick the smallest representation of a constant, rather than just
8699 defaulting to the LEB encoding. */
8700 if (i >= 0)
8701 {
8702 if (i <= 31)
8703 op = DW_OP_lit0 + i;
8704 else if (i <= 0xff)
8705 op = DW_OP_const1u;
8706 else if (i <= 0xffff)
8707 op = DW_OP_const2u;
8708 else if (HOST_BITS_PER_WIDE_INT == 32
8709 || i <= 0xffffffff)
8710 op = DW_OP_const4u;
8711 else
8712 op = DW_OP_constu;
8713 }
8714 else
8715 {
8716 if (i >= -0x80)
8717 op = DW_OP_const1s;
8718 else if (i >= -0x8000)
8719 op = DW_OP_const2s;
8720 else if (HOST_BITS_PER_WIDE_INT == 32
8721 || i >= -0x80000000)
8722 op = DW_OP_const4s;
8723 else
8724 op = DW_OP_consts;
8725 }
8726
8727 return new_loc_descr (op, i, 0);
8728 }
8729
8730 /* Return a location descriptor that designates a base+offset location. */
8731
8732 static dw_loc_descr_ref
based_loc_descr(rtx reg,HOST_WIDE_INT offset)8733 based_loc_descr (rtx reg, HOST_WIDE_INT offset)
8734 {
8735 unsigned int regno;
8736
8737 /* We only use "frame base" when we're sure we're talking about the
8738 post-prologue local stack frame. We do this by *not* running
8739 register elimination until this point, and recognizing the special
8740 argument pointer and soft frame pointer rtx's. */
8741 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
8742 {
8743 rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
8744
8745 if (elim != reg)
8746 {
8747 if (GET_CODE (elim) == PLUS)
8748 {
8749 offset += INTVAL (XEXP (elim, 1));
8750 elim = XEXP (elim, 0);
8751 }
8752 gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
8753 : stack_pointer_rtx));
8754 offset += frame_pointer_fb_offset;
8755
8756 return new_loc_descr (DW_OP_fbreg, offset, 0);
8757 }
8758 }
8759
8760 regno = dbx_reg_number (reg);
8761 if (regno <= 31)
8762 return new_loc_descr (DW_OP_breg0 + regno, offset, 0);
8763 else
8764 return new_loc_descr (DW_OP_bregx, regno, offset);
8765 }
8766
8767 /* Return true if this RTL expression describes a base+offset calculation. */
8768
8769 static inline int
is_based_loc(rtx rtl)8770 is_based_loc (rtx rtl)
8771 {
8772 return (GET_CODE (rtl) == PLUS
8773 && ((REG_P (XEXP (rtl, 0))
8774 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
8775 && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
8776 }
8777
8778 /* The following routine converts the RTL for a variable or parameter
8779 (resident in memory) into an equivalent Dwarf representation of a
8780 mechanism for getting the address of that same variable onto the top of a
8781 hypothetical "address evaluation" stack.
8782
8783 When creating memory location descriptors, we are effectively transforming
8784 the RTL for a memory-resident object into its Dwarf postfix expression
8785 equivalent. This routine recursively descends an RTL tree, turning
8786 it into Dwarf postfix code as it goes.
8787
8788 MODE is the mode of the memory reference, needed to handle some
8789 autoincrement addressing modes.
8790
8791 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
8792 location list for RTL.
8793
8794 Return 0 if we can't represent the location. */
8795
8796 static dw_loc_descr_ref
mem_loc_descriptor(rtx rtl,enum machine_mode mode)8797 mem_loc_descriptor (rtx rtl, enum machine_mode mode)
8798 {
8799 dw_loc_descr_ref mem_loc_result = NULL;
8800 enum dwarf_location_atom op;
8801
8802 /* Note that for a dynamically sized array, the location we will generate a
8803 description of here will be the lowest numbered location which is
8804 actually within the array. That's *not* necessarily the same as the
8805 zeroth element of the array. */
8806
8807 rtl = targetm.delegitimize_address (rtl);
8808
8809 switch (GET_CODE (rtl))
8810 {
8811 case POST_INC:
8812 case POST_DEC:
8813 case POST_MODIFY:
8814 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
8815 just fall into the SUBREG code. */
8816
8817 /* ... fall through ... */
8818
8819 case SUBREG:
8820 /* The case of a subreg may arise when we have a local (register)
8821 variable or a formal (register) parameter which doesn't quite fill
8822 up an entire register. For now, just assume that it is
8823 legitimate to make the Dwarf info refer to the whole register which
8824 contains the given subreg. */
8825 rtl = XEXP (rtl, 0);
8826
8827 /* ... fall through ... */
8828
8829 case REG:
8830 /* Whenever a register number forms a part of the description of the
8831 method for calculating the (dynamic) address of a memory resident
8832 object, DWARF rules require the register number be referred to as
8833 a "base register". This distinction is not based in any way upon
8834 what category of register the hardware believes the given register
8835 belongs to. This is strictly DWARF terminology we're dealing with
8836 here. Note that in cases where the location of a memory-resident
8837 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
8838 OP_CONST (0)) the actual DWARF location descriptor that we generate
8839 may just be OP_BASEREG (basereg). This may look deceptively like
8840 the object in question was allocated to a register (rather than in
8841 memory) so DWARF consumers need to be aware of the subtle
8842 distinction between OP_REG and OP_BASEREG. */
8843 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
8844 mem_loc_result = based_loc_descr (rtl, 0);
8845 break;
8846
8847 case MEM:
8848 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
8849 if (mem_loc_result != 0)
8850 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
8851 break;
8852
8853 case LO_SUM:
8854 rtl = XEXP (rtl, 1);
8855
8856 /* ... fall through ... */
8857
8858 case LABEL_REF:
8859 /* Some ports can transform a symbol ref into a label ref, because
8860 the symbol ref is too far away and has to be dumped into a constant
8861 pool. */
8862 case CONST:
8863 case SYMBOL_REF:
8864 /* Alternatively, the symbol in the constant pool might be referenced
8865 by a different symbol. */
8866 if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
8867 {
8868 bool marked;
8869 rtx tmp = get_pool_constant_mark (rtl, &marked);
8870
8871 if (GET_CODE (tmp) == SYMBOL_REF)
8872 {
8873 rtl = tmp;
8874 if (CONSTANT_POOL_ADDRESS_P (tmp))
8875 get_pool_constant_mark (tmp, &marked);
8876 else
8877 marked = true;
8878 }
8879
8880 /* If all references to this pool constant were optimized away,
8881 it was not output and thus we can't represent it.
8882 FIXME: might try to use DW_OP_const_value here, though
8883 DW_OP_piece complicates it. */
8884 if (!marked)
8885 return 0;
8886 }
8887
8888 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
8889 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
8890 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
8891 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
8892 break;
8893
8894 case PRE_MODIFY:
8895 /* Extract the PLUS expression nested inside and fall into
8896 PLUS code below. */
8897 rtl = XEXP (rtl, 1);
8898 goto plus;
8899
8900 case PRE_INC:
8901 case PRE_DEC:
8902 /* Turn these into a PLUS expression and fall into the PLUS code
8903 below. */
8904 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
8905 GEN_INT (GET_CODE (rtl) == PRE_INC
8906 ? GET_MODE_UNIT_SIZE (mode)
8907 : -GET_MODE_UNIT_SIZE (mode)));
8908
8909 /* ... fall through ... */
8910
8911 case PLUS:
8912 plus:
8913 if (is_based_loc (rtl))
8914 mem_loc_result = based_loc_descr (XEXP (rtl, 0),
8915 INTVAL (XEXP (rtl, 1)));
8916 else
8917 {
8918 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode);
8919 if (mem_loc_result == 0)
8920 break;
8921
8922 if (GET_CODE (XEXP (rtl, 1)) == CONST_INT
8923 && INTVAL (XEXP (rtl, 1)) >= 0)
8924 add_loc_descr (&mem_loc_result,
8925 new_loc_descr (DW_OP_plus_uconst,
8926 INTVAL (XEXP (rtl, 1)), 0));
8927 else
8928 {
8929 add_loc_descr (&mem_loc_result,
8930 mem_loc_descriptor (XEXP (rtl, 1), mode));
8931 add_loc_descr (&mem_loc_result,
8932 new_loc_descr (DW_OP_plus, 0, 0));
8933 }
8934 }
8935 break;
8936
8937 /* If a pseudo-reg is optimized away, it is possible for it to
8938 be replaced with a MEM containing a multiply or shift. */
8939 case MULT:
8940 op = DW_OP_mul;
8941 goto do_binop;
8942
8943 case ASHIFT:
8944 op = DW_OP_shl;
8945 goto do_binop;
8946
8947 case ASHIFTRT:
8948 op = DW_OP_shra;
8949 goto do_binop;
8950
8951 case LSHIFTRT:
8952 op = DW_OP_shr;
8953 goto do_binop;
8954
8955 do_binop:
8956 {
8957 dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode);
8958 dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode);
8959
8960 if (op0 == 0 || op1 == 0)
8961 break;
8962
8963 mem_loc_result = op0;
8964 add_loc_descr (&mem_loc_result, op1);
8965 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
8966 break;
8967 }
8968
8969 case CONST_INT:
8970 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
8971 break;
8972
8973 default:
8974 gcc_unreachable ();
8975 }
8976
8977 return mem_loc_result;
8978 }
8979
8980 /* Return a descriptor that describes the concatenation of two locations.
8981 This is typically a complex variable. */
8982
8983 static dw_loc_descr_ref
concat_loc_descriptor(rtx x0,rtx x1)8984 concat_loc_descriptor (rtx x0, rtx x1)
8985 {
8986 dw_loc_descr_ref cc_loc_result = NULL;
8987 dw_loc_descr_ref x0_ref = loc_descriptor (x0);
8988 dw_loc_descr_ref x1_ref = loc_descriptor (x1);
8989
8990 if (x0_ref == 0 || x1_ref == 0)
8991 return 0;
8992
8993 cc_loc_result = x0_ref;
8994 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
8995
8996 add_loc_descr (&cc_loc_result, x1_ref);
8997 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
8998
8999 return cc_loc_result;
9000 }
9001
9002 /* Output a proper Dwarf location descriptor for a variable or parameter
9003 which is either allocated in a register or in a memory location. For a
9004 register, we just generate an OP_REG and the register number. For a
9005 memory location we provide a Dwarf postfix expression describing how to
9006 generate the (dynamic) address of the object onto the address stack.
9007
9008 If we don't know how to describe it, return 0. */
9009
9010 static dw_loc_descr_ref
loc_descriptor(rtx rtl)9011 loc_descriptor (rtx rtl)
9012 {
9013 dw_loc_descr_ref loc_result = NULL;
9014
9015 switch (GET_CODE (rtl))
9016 {
9017 case SUBREG:
9018 /* The case of a subreg may arise when we have a local (register)
9019 variable or a formal (register) parameter which doesn't quite fill
9020 up an entire register. For now, just assume that it is
9021 legitimate to make the Dwarf info refer to the whole register which
9022 contains the given subreg. */
9023 rtl = SUBREG_REG (rtl);
9024
9025 /* ... fall through ... */
9026
9027 case REG:
9028 loc_result = reg_loc_descriptor (rtl);
9029 break;
9030
9031 case MEM:
9032 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
9033 break;
9034
9035 case CONCAT:
9036 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
9037 break;
9038
9039 case VAR_LOCATION:
9040 /* Single part. */
9041 if (GET_CODE (XEXP (rtl, 1)) != PARALLEL)
9042 {
9043 loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0));
9044 break;
9045 }
9046
9047 rtl = XEXP (rtl, 1);
9048 /* FALLTHRU */
9049
9050 case PARALLEL:
9051 {
9052 rtvec par_elems = XVEC (rtl, 0);
9053 int num_elem = GET_NUM_ELEM (par_elems);
9054 enum machine_mode mode;
9055 int i;
9056
9057 /* Create the first one, so we have something to add to. */
9058 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0));
9059 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
9060 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
9061 for (i = 1; i < num_elem; i++)
9062 {
9063 dw_loc_descr_ref temp;
9064
9065 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0));
9066 add_loc_descr (&loc_result, temp);
9067 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
9068 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
9069 }
9070 }
9071 break;
9072
9073 default:
9074 gcc_unreachable ();
9075 }
9076
9077 return loc_result;
9078 }
9079
9080 /* Similar, but generate the descriptor from trees instead of rtl. This comes
9081 up particularly with variable length arrays. WANT_ADDRESS is 2 if this is
9082 a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a
9083 top-level invocation, and we require the address of LOC; is 0 if we require
9084 the value of LOC. */
9085
9086 static dw_loc_descr_ref
loc_descriptor_from_tree_1(tree loc,int want_address)9087 loc_descriptor_from_tree_1 (tree loc, int want_address)
9088 {
9089 dw_loc_descr_ref ret, ret1;
9090 int have_address = 0;
9091 enum dwarf_location_atom op;
9092
9093 /* ??? Most of the time we do not take proper care for sign/zero
9094 extending the values properly. Hopefully this won't be a real
9095 problem... */
9096
9097 switch (TREE_CODE (loc))
9098 {
9099 case ERROR_MARK:
9100 return 0;
9101
9102 case PLACEHOLDER_EXPR:
9103 /* This case involves extracting fields from an object to determine the
9104 position of other fields. We don't try to encode this here. The
9105 only user of this is Ada, which encodes the needed information using
9106 the names of types. */
9107 return 0;
9108
9109 case CALL_EXPR:
9110 return 0;
9111
9112 case PREINCREMENT_EXPR:
9113 case PREDECREMENT_EXPR:
9114 case POSTINCREMENT_EXPR:
9115 case POSTDECREMENT_EXPR:
9116 /* There are no opcodes for these operations. */
9117 return 0;
9118
9119 case ADDR_EXPR:
9120 /* If we already want an address, there's nothing we can do. */
9121 if (want_address)
9122 return 0;
9123
9124 /* Otherwise, process the argument and look for the address. */
9125 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1);
9126
9127 case VAR_DECL:
9128 if (DECL_THREAD_LOCAL_P (loc))
9129 {
9130 rtx rtl;
9131
9132 /* If this is not defined, we have no way to emit the data. */
9133 if (!targetm.asm_out.output_dwarf_dtprel)
9134 return 0;
9135
9136 /* The way DW_OP_GNU_push_tls_address is specified, we can only
9137 look up addresses of objects in the current module. */
9138 if (DECL_EXTERNAL (loc))
9139 return 0;
9140
9141 rtl = rtl_for_decl_location (loc);
9142 if (rtl == NULL_RTX)
9143 return 0;
9144
9145 if (!MEM_P (rtl))
9146 return 0;
9147 rtl = XEXP (rtl, 0);
9148 if (! CONSTANT_P (rtl))
9149 return 0;
9150
9151 ret = new_loc_descr (INTERNAL_DW_OP_tls_addr, 0, 0);
9152 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9153 ret->dw_loc_oprnd1.v.val_addr = rtl;
9154
9155 ret1 = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
9156 add_loc_descr (&ret, ret1);
9157
9158 have_address = 1;
9159 break;
9160 }
9161 /* FALLTHRU */
9162
9163 case PARM_DECL:
9164 if (DECL_HAS_VALUE_EXPR_P (loc))
9165 return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc),
9166 want_address);
9167 /* FALLTHRU */
9168
9169 case RESULT_DECL:
9170 case FUNCTION_DECL:
9171 {
9172 rtx rtl = rtl_for_decl_location (loc);
9173
9174 if (rtl == NULL_RTX)
9175 return 0;
9176 else if (GET_CODE (rtl) == CONST_INT)
9177 {
9178 HOST_WIDE_INT val = INTVAL (rtl);
9179 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
9180 val &= GET_MODE_MASK (DECL_MODE (loc));
9181 ret = int_loc_descriptor (val);
9182 }
9183 else if (GET_CODE (rtl) == CONST_STRING)
9184 return 0;
9185 else if (CONSTANT_P (rtl))
9186 {
9187 ret = new_loc_descr (DW_OP_addr, 0, 0);
9188 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9189 ret->dw_loc_oprnd1.v.val_addr = rtl;
9190 }
9191 else
9192 {
9193 enum machine_mode mode;
9194
9195 /* Certain constructs can only be represented at top-level. */
9196 if (want_address == 2)
9197 return loc_descriptor (rtl);
9198
9199 mode = GET_MODE (rtl);
9200 if (MEM_P (rtl))
9201 {
9202 rtl = XEXP (rtl, 0);
9203 have_address = 1;
9204 }
9205 ret = mem_loc_descriptor (rtl, mode);
9206 }
9207 }
9208 break;
9209
9210 case INDIRECT_REF:
9211 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9212 have_address = 1;
9213 break;
9214
9215 case COMPOUND_EXPR:
9216 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address);
9217
9218 case NOP_EXPR:
9219 case CONVERT_EXPR:
9220 case NON_LVALUE_EXPR:
9221 case VIEW_CONVERT_EXPR:
9222 case SAVE_EXPR:
9223 case MODIFY_EXPR:
9224 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), want_address);
9225
9226 case COMPONENT_REF:
9227 case BIT_FIELD_REF:
9228 case ARRAY_REF:
9229 case ARRAY_RANGE_REF:
9230 {
9231 tree obj, offset;
9232 HOST_WIDE_INT bitsize, bitpos, bytepos;
9233 enum machine_mode mode;
9234 int volatilep;
9235 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
9236
9237 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
9238 &unsignedp, &volatilep, false);
9239
9240 if (obj == loc)
9241 return 0;
9242
9243 ret = loc_descriptor_from_tree_1 (obj, 1);
9244 if (ret == 0
9245 || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
9246 return 0;
9247
9248 if (offset != NULL_TREE)
9249 {
9250 /* Variable offset. */
9251 add_loc_descr (&ret, loc_descriptor_from_tree_1 (offset, 0));
9252 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9253 }
9254
9255 bytepos = bitpos / BITS_PER_UNIT;
9256 if (bytepos > 0)
9257 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
9258 else if (bytepos < 0)
9259 {
9260 add_loc_descr (&ret, int_loc_descriptor (bytepos));
9261 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9262 }
9263
9264 have_address = 1;
9265 break;
9266 }
9267
9268 case INTEGER_CST:
9269 if (host_integerp (loc, 0))
9270 ret = int_loc_descriptor (tree_low_cst (loc, 0));
9271 else
9272 return 0;
9273 break;
9274
9275 case CONSTRUCTOR:
9276 {
9277 /* Get an RTL for this, if something has been emitted. */
9278 rtx rtl = lookup_constant_def (loc);
9279 enum machine_mode mode;
9280
9281 if (!rtl || !MEM_P (rtl))
9282 return 0;
9283 mode = GET_MODE (rtl);
9284 rtl = XEXP (rtl, 0);
9285 ret = mem_loc_descriptor (rtl, mode);
9286 have_address = 1;
9287 break;
9288 }
9289
9290 case TRUTH_AND_EXPR:
9291 case TRUTH_ANDIF_EXPR:
9292 case BIT_AND_EXPR:
9293 op = DW_OP_and;
9294 goto do_binop;
9295
9296 case TRUTH_XOR_EXPR:
9297 case BIT_XOR_EXPR:
9298 op = DW_OP_xor;
9299 goto do_binop;
9300
9301 case TRUTH_OR_EXPR:
9302 case TRUTH_ORIF_EXPR:
9303 case BIT_IOR_EXPR:
9304 op = DW_OP_or;
9305 goto do_binop;
9306
9307 case FLOOR_DIV_EXPR:
9308 case CEIL_DIV_EXPR:
9309 case ROUND_DIV_EXPR:
9310 case TRUNC_DIV_EXPR:
9311 op = DW_OP_div;
9312 goto do_binop;
9313
9314 case MINUS_EXPR:
9315 op = DW_OP_minus;
9316 goto do_binop;
9317
9318 case FLOOR_MOD_EXPR:
9319 case CEIL_MOD_EXPR:
9320 case ROUND_MOD_EXPR:
9321 case TRUNC_MOD_EXPR:
9322 op = DW_OP_mod;
9323 goto do_binop;
9324
9325 case MULT_EXPR:
9326 op = DW_OP_mul;
9327 goto do_binop;
9328
9329 case LSHIFT_EXPR:
9330 op = DW_OP_shl;
9331 goto do_binop;
9332
9333 case RSHIFT_EXPR:
9334 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
9335 goto do_binop;
9336
9337 case PLUS_EXPR:
9338 if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
9339 && host_integerp (TREE_OPERAND (loc, 1), 0))
9340 {
9341 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9342 if (ret == 0)
9343 return 0;
9344
9345 add_loc_descr (&ret,
9346 new_loc_descr (DW_OP_plus_uconst,
9347 tree_low_cst (TREE_OPERAND (loc, 1),
9348 0),
9349 0));
9350 break;
9351 }
9352
9353 op = DW_OP_plus;
9354 goto do_binop;
9355
9356 case LE_EXPR:
9357 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9358 return 0;
9359
9360 op = DW_OP_le;
9361 goto do_binop;
9362
9363 case GE_EXPR:
9364 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9365 return 0;
9366
9367 op = DW_OP_ge;
9368 goto do_binop;
9369
9370 case LT_EXPR:
9371 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9372 return 0;
9373
9374 op = DW_OP_lt;
9375 goto do_binop;
9376
9377 case GT_EXPR:
9378 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9379 return 0;
9380
9381 op = DW_OP_gt;
9382 goto do_binop;
9383
9384 case EQ_EXPR:
9385 op = DW_OP_eq;
9386 goto do_binop;
9387
9388 case NE_EXPR:
9389 op = DW_OP_ne;
9390 goto do_binop;
9391
9392 do_binop:
9393 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9394 ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9395 if (ret == 0 || ret1 == 0)
9396 return 0;
9397
9398 add_loc_descr (&ret, ret1);
9399 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9400 break;
9401
9402 case TRUTH_NOT_EXPR:
9403 case BIT_NOT_EXPR:
9404 op = DW_OP_not;
9405 goto do_unop;
9406
9407 case ABS_EXPR:
9408 op = DW_OP_abs;
9409 goto do_unop;
9410
9411 case NEGATE_EXPR:
9412 op = DW_OP_neg;
9413 goto do_unop;
9414
9415 do_unop:
9416 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9417 if (ret == 0)
9418 return 0;
9419
9420 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9421 break;
9422
9423 case MIN_EXPR:
9424 case MAX_EXPR:
9425 {
9426 const enum tree_code code =
9427 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
9428
9429 loc = build3 (COND_EXPR, TREE_TYPE (loc),
9430 build2 (code, integer_type_node,
9431 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
9432 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
9433 }
9434
9435 /* ... fall through ... */
9436
9437 case COND_EXPR:
9438 {
9439 dw_loc_descr_ref lhs
9440 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9441 dw_loc_descr_ref rhs
9442 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0);
9443 dw_loc_descr_ref bra_node, jump_node, tmp;
9444
9445 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9446 if (ret == 0 || lhs == 0 || rhs == 0)
9447 return 0;
9448
9449 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
9450 add_loc_descr (&ret, bra_node);
9451
9452 add_loc_descr (&ret, rhs);
9453 jump_node = new_loc_descr (DW_OP_skip, 0, 0);
9454 add_loc_descr (&ret, jump_node);
9455
9456 add_loc_descr (&ret, lhs);
9457 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9458 bra_node->dw_loc_oprnd1.v.val_loc = lhs;
9459
9460 /* ??? Need a node to point the skip at. Use a nop. */
9461 tmp = new_loc_descr (DW_OP_nop, 0, 0);
9462 add_loc_descr (&ret, tmp);
9463 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9464 jump_node->dw_loc_oprnd1.v.val_loc = tmp;
9465 }
9466 break;
9467
9468 case FIX_TRUNC_EXPR:
9469 case FIX_CEIL_EXPR:
9470 case FIX_FLOOR_EXPR:
9471 case FIX_ROUND_EXPR:
9472 return 0;
9473
9474 default:
9475 /* Leave front-end specific codes as simply unknown. This comes
9476 up, for instance, with the C STMT_EXPR. */
9477 if ((unsigned int) TREE_CODE (loc)
9478 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
9479 return 0;
9480
9481 #ifdef ENABLE_CHECKING
9482 /* Otherwise this is a generic code; we should just lists all of
9483 these explicitly. We forgot one. */
9484 gcc_unreachable ();
9485 #else
9486 /* In a release build, we want to degrade gracefully: better to
9487 generate incomplete debugging information than to crash. */
9488 return NULL;
9489 #endif
9490 }
9491
9492 /* Show if we can't fill the request for an address. */
9493 if (want_address && !have_address)
9494 return 0;
9495
9496 /* If we've got an address and don't want one, dereference. */
9497 if (!want_address && have_address && ret)
9498 {
9499 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
9500
9501 if (size > DWARF2_ADDR_SIZE || size == -1)
9502 return 0;
9503 else if (size == DWARF2_ADDR_SIZE)
9504 op = DW_OP_deref;
9505 else
9506 op = DW_OP_deref_size;
9507
9508 add_loc_descr (&ret, new_loc_descr (op, size, 0));
9509 }
9510
9511 return ret;
9512 }
9513
9514 static inline dw_loc_descr_ref
loc_descriptor_from_tree(tree loc)9515 loc_descriptor_from_tree (tree loc)
9516 {
9517 return loc_descriptor_from_tree_1 (loc, 2);
9518 }
9519
9520 /* Given a value, round it up to the lowest multiple of `boundary'
9521 which is not less than the value itself. */
9522
9523 static inline HOST_WIDE_INT
ceiling(HOST_WIDE_INT value,unsigned int boundary)9524 ceiling (HOST_WIDE_INT value, unsigned int boundary)
9525 {
9526 return (((value + boundary - 1) / boundary) * boundary);
9527 }
9528
9529 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
9530 pointer to the declared type for the relevant field variable, or return
9531 `integer_type_node' if the given node turns out to be an
9532 ERROR_MARK node. */
9533
9534 static inline tree
field_type(tree decl)9535 field_type (tree decl)
9536 {
9537 tree type;
9538
9539 if (TREE_CODE (decl) == ERROR_MARK)
9540 return integer_type_node;
9541
9542 type = DECL_BIT_FIELD_TYPE (decl);
9543 if (type == NULL_TREE)
9544 type = TREE_TYPE (decl);
9545
9546 return type;
9547 }
9548
9549 /* Given a pointer to a tree node, return the alignment in bits for
9550 it, or else return BITS_PER_WORD if the node actually turns out to
9551 be an ERROR_MARK node. */
9552
9553 static inline unsigned
simple_type_align_in_bits(tree type)9554 simple_type_align_in_bits (tree type)
9555 {
9556 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
9557 }
9558
9559 static inline unsigned
simple_decl_align_in_bits(tree decl)9560 simple_decl_align_in_bits (tree decl)
9561 {
9562 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
9563 }
9564
9565 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
9566 lowest addressed byte of the "containing object" for the given FIELD_DECL,
9567 or return 0 if we are unable to determine what that offset is, either
9568 because the argument turns out to be a pointer to an ERROR_MARK node, or
9569 because the offset is actually variable. (We can't handle the latter case
9570 just yet). */
9571
9572 static HOST_WIDE_INT
field_byte_offset(tree decl)9573 field_byte_offset (tree decl)
9574 {
9575 unsigned int type_align_in_bits;
9576 unsigned int decl_align_in_bits;
9577 unsigned HOST_WIDE_INT type_size_in_bits;
9578 HOST_WIDE_INT object_offset_in_bits;
9579 tree type;
9580 tree field_size_tree;
9581 HOST_WIDE_INT bitpos_int;
9582 HOST_WIDE_INT deepest_bitpos;
9583 unsigned HOST_WIDE_INT field_size_in_bits;
9584
9585 if (TREE_CODE (decl) == ERROR_MARK)
9586 return 0;
9587
9588 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
9589
9590 type = field_type (decl);
9591 field_size_tree = DECL_SIZE (decl);
9592
9593 /* The size could be unspecified if there was an error, or for
9594 a flexible array member. */
9595 if (! field_size_tree)
9596 field_size_tree = bitsize_zero_node;
9597
9598 /* We cannot yet cope with fields whose positions are variable, so
9599 for now, when we see such things, we simply return 0. Someday, we may
9600 be able to handle such cases, but it will be damn difficult. */
9601 if (! host_integerp (bit_position (decl), 0))
9602 return 0;
9603
9604 bitpos_int = int_bit_position (decl);
9605
9606 /* If we don't know the size of the field, pretend it's a full word. */
9607 if (host_integerp (field_size_tree, 1))
9608 field_size_in_bits = tree_low_cst (field_size_tree, 1);
9609 else
9610 field_size_in_bits = BITS_PER_WORD;
9611
9612 type_size_in_bits = simple_type_size_in_bits (type);
9613 type_align_in_bits = simple_type_align_in_bits (type);
9614 decl_align_in_bits = simple_decl_align_in_bits (decl);
9615
9616 /* The GCC front-end doesn't make any attempt to keep track of the starting
9617 bit offset (relative to the start of the containing structure type) of the
9618 hypothetical "containing object" for a bit-field. Thus, when computing
9619 the byte offset value for the start of the "containing object" of a
9620 bit-field, we must deduce this information on our own. This can be rather
9621 tricky to do in some cases. For example, handling the following structure
9622 type definition when compiling for an i386/i486 target (which only aligns
9623 long long's to 32-bit boundaries) can be very tricky:
9624
9625 struct S { int field1; long long field2:31; };
9626
9627 Fortunately, there is a simple rule-of-thumb which can be used in such
9628 cases. When compiling for an i386/i486, GCC will allocate 8 bytes for the
9629 structure shown above. It decides to do this based upon one simple rule
9630 for bit-field allocation. GCC allocates each "containing object" for each
9631 bit-field at the first (i.e. lowest addressed) legitimate alignment
9632 boundary (based upon the required minimum alignment for the declared type
9633 of the field) which it can possibly use, subject to the condition that
9634 there is still enough available space remaining in the containing object
9635 (when allocated at the selected point) to fully accommodate all of the
9636 bits of the bit-field itself.
9637
9638 This simple rule makes it obvious why GCC allocates 8 bytes for each
9639 object of the structure type shown above. When looking for a place to
9640 allocate the "containing object" for `field2', the compiler simply tries
9641 to allocate a 64-bit "containing object" at each successive 32-bit
9642 boundary (starting at zero) until it finds a place to allocate that 64-
9643 bit field such that at least 31 contiguous (and previously unallocated)
9644 bits remain within that selected 64 bit field. (As it turns out, for the
9645 example above, the compiler finds it is OK to allocate the "containing
9646 object" 64-bit field at bit-offset zero within the structure type.)
9647
9648 Here we attempt to work backwards from the limited set of facts we're
9649 given, and we try to deduce from those facts, where GCC must have believed
9650 that the containing object started (within the structure type). The value
9651 we deduce is then used (by the callers of this routine) to generate
9652 DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields
9653 and, in the case of DW_AT_location, regular fields as well). */
9654
9655 /* Figure out the bit-distance from the start of the structure to the
9656 "deepest" bit of the bit-field. */
9657 deepest_bitpos = bitpos_int + field_size_in_bits;
9658
9659 /* This is the tricky part. Use some fancy footwork to deduce where the
9660 lowest addressed bit of the containing object must be. */
9661 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9662
9663 /* Round up to type_align by default. This works best for bitfields. */
9664 object_offset_in_bits += type_align_in_bits - 1;
9665 object_offset_in_bits /= type_align_in_bits;
9666 object_offset_in_bits *= type_align_in_bits;
9667
9668 if (object_offset_in_bits > bitpos_int)
9669 {
9670 /* Sigh, the decl must be packed. */
9671 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9672
9673 /* Round up to decl_align instead. */
9674 object_offset_in_bits += decl_align_in_bits - 1;
9675 object_offset_in_bits /= decl_align_in_bits;
9676 object_offset_in_bits *= decl_align_in_bits;
9677 }
9678
9679 return object_offset_in_bits / BITS_PER_UNIT;
9680 }
9681
9682 /* The following routines define various Dwarf attributes and any data
9683 associated with them. */
9684
9685 /* Add a location description attribute value to a DIE.
9686
9687 This emits location attributes suitable for whole variables and
9688 whole parameters. Note that the location attributes for struct fields are
9689 generated by the routine `data_member_location_attribute' below. */
9690
9691 static inline void
add_AT_location_description(dw_die_ref die,enum dwarf_attribute attr_kind,dw_loc_descr_ref descr)9692 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
9693 dw_loc_descr_ref descr)
9694 {
9695 if (descr != 0)
9696 add_AT_loc (die, attr_kind, descr);
9697 }
9698
9699 /* Attach the specialized form of location attribute used for data members of
9700 struct and union types. In the special case of a FIELD_DECL node which
9701 represents a bit-field, the "offset" part of this special location
9702 descriptor must indicate the distance in bytes from the lowest-addressed
9703 byte of the containing struct or union type to the lowest-addressed byte of
9704 the "containing object" for the bit-field. (See the `field_byte_offset'
9705 function above).
9706
9707 For any given bit-field, the "containing object" is a hypothetical object
9708 (of some integral or enum type) within which the given bit-field lives. The
9709 type of this hypothetical "containing object" is always the same as the
9710 declared type of the individual bit-field itself (for GCC anyway... the
9711 DWARF spec doesn't actually mandate this). Note that it is the size (in
9712 bytes) of the hypothetical "containing object" which will be given in the
9713 DW_AT_byte_size attribute for this bit-field. (See the
9714 `byte_size_attribute' function below.) It is also used when calculating the
9715 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
9716 function below.) */
9717
9718 static void
add_data_member_location_attribute(dw_die_ref die,tree decl)9719 add_data_member_location_attribute (dw_die_ref die, tree decl)
9720 {
9721 HOST_WIDE_INT offset;
9722 dw_loc_descr_ref loc_descr = 0;
9723
9724 if (TREE_CODE (decl) == TREE_BINFO)
9725 {
9726 /* We're working on the TAG_inheritance for a base class. */
9727 if (BINFO_VIRTUAL_P (decl) && is_cxx ())
9728 {
9729 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
9730 aren't at a fixed offset from all (sub)objects of the same
9731 type. We need to extract the appropriate offset from our
9732 vtable. The following dwarf expression means
9733
9734 BaseAddr = ObAddr + *((*ObAddr) - Offset)
9735
9736 This is specific to the V3 ABI, of course. */
9737
9738 dw_loc_descr_ref tmp;
9739
9740 /* Make a copy of the object address. */
9741 tmp = new_loc_descr (DW_OP_dup, 0, 0);
9742 add_loc_descr (&loc_descr, tmp);
9743
9744 /* Extract the vtable address. */
9745 tmp = new_loc_descr (DW_OP_deref, 0, 0);
9746 add_loc_descr (&loc_descr, tmp);
9747
9748 /* Calculate the address of the offset. */
9749 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
9750 gcc_assert (offset < 0);
9751
9752 tmp = int_loc_descriptor (-offset);
9753 add_loc_descr (&loc_descr, tmp);
9754 tmp = new_loc_descr (DW_OP_minus, 0, 0);
9755 add_loc_descr (&loc_descr, tmp);
9756
9757 /* Extract the offset. */
9758 tmp = new_loc_descr (DW_OP_deref, 0, 0);
9759 add_loc_descr (&loc_descr, tmp);
9760
9761 /* Add it to the object address. */
9762 tmp = new_loc_descr (DW_OP_plus, 0, 0);
9763 add_loc_descr (&loc_descr, tmp);
9764 }
9765 else
9766 offset = tree_low_cst (BINFO_OFFSET (decl), 0);
9767 }
9768 else
9769 offset = field_byte_offset (decl);
9770
9771 if (! loc_descr)
9772 {
9773 enum dwarf_location_atom op;
9774
9775 /* The DWARF2 standard says that we should assume that the structure
9776 address is already on the stack, so we can specify a structure field
9777 address by using DW_OP_plus_uconst. */
9778
9779 #ifdef MIPS_DEBUGGING_INFO
9780 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
9781 operator correctly. It works only if we leave the offset on the
9782 stack. */
9783 op = DW_OP_constu;
9784 #else
9785 op = DW_OP_plus_uconst;
9786 #endif
9787
9788 loc_descr = new_loc_descr (op, offset, 0);
9789 }
9790
9791 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
9792 }
9793
9794 /* Writes integer values to dw_vec_const array. */
9795
9796 static void
insert_int(HOST_WIDE_INT val,unsigned int size,unsigned char * dest)9797 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
9798 {
9799 while (size != 0)
9800 {
9801 *dest++ = val & 0xff;
9802 val >>= 8;
9803 --size;
9804 }
9805 }
9806
9807 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
9808
9809 static HOST_WIDE_INT
extract_int(const unsigned char * src,unsigned int size)9810 extract_int (const unsigned char *src, unsigned int size)
9811 {
9812 HOST_WIDE_INT val = 0;
9813
9814 src += size;
9815 while (size != 0)
9816 {
9817 val <<= 8;
9818 val |= *--src & 0xff;
9819 --size;
9820 }
9821 return val;
9822 }
9823
9824 /* Writes floating point values to dw_vec_const array. */
9825
9826 static void
insert_float(rtx rtl,unsigned char * array)9827 insert_float (rtx rtl, unsigned char *array)
9828 {
9829 REAL_VALUE_TYPE rv;
9830 long val[4];
9831 int i;
9832
9833 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
9834 real_to_target (val, &rv, GET_MODE (rtl));
9835
9836 /* real_to_target puts 32-bit pieces in each long. Pack them. */
9837 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
9838 {
9839 insert_int (val[i], 4, array);
9840 array += 4;
9841 }
9842 }
9843
9844 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
9845 does not have a "location" either in memory or in a register. These
9846 things can arise in GNU C when a constant is passed as an actual parameter
9847 to an inlined function. They can also arise in C++ where declared
9848 constants do not necessarily get memory "homes". */
9849
9850 static void
add_const_value_attribute(dw_die_ref die,rtx rtl)9851 add_const_value_attribute (dw_die_ref die, rtx rtl)
9852 {
9853 switch (GET_CODE (rtl))
9854 {
9855 case CONST_INT:
9856 {
9857 HOST_WIDE_INT val = INTVAL (rtl);
9858
9859 if (val < 0)
9860 add_AT_int (die, DW_AT_const_value, val);
9861 else
9862 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
9863 }
9864 break;
9865
9866 case CONST_DOUBLE:
9867 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
9868 floating-point constant. A CONST_DOUBLE is used whenever the
9869 constant requires more than one word in order to be adequately
9870 represented. We output CONST_DOUBLEs as blocks. */
9871 {
9872 enum machine_mode mode = GET_MODE (rtl);
9873
9874 if (SCALAR_FLOAT_MODE_P (mode))
9875 {
9876 unsigned int length = GET_MODE_SIZE (mode);
9877 unsigned char *array = ggc_alloc (length);
9878
9879 insert_float (rtl, array);
9880 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
9881 }
9882 else
9883 {
9884 /* ??? We really should be using HOST_WIDE_INT throughout. */
9885 gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT);
9886
9887 add_AT_long_long (die, DW_AT_const_value,
9888 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
9889 }
9890 }
9891 break;
9892
9893 case CONST_VECTOR:
9894 {
9895 enum machine_mode mode = GET_MODE (rtl);
9896 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
9897 unsigned int length = CONST_VECTOR_NUNITS (rtl);
9898 unsigned char *array = ggc_alloc (length * elt_size);
9899 unsigned int i;
9900 unsigned char *p;
9901
9902 switch (GET_MODE_CLASS (mode))
9903 {
9904 case MODE_VECTOR_INT:
9905 for (i = 0, p = array; i < length; i++, p += elt_size)
9906 {
9907 rtx elt = CONST_VECTOR_ELT (rtl, i);
9908 HOST_WIDE_INT lo, hi;
9909
9910 switch (GET_CODE (elt))
9911 {
9912 case CONST_INT:
9913 lo = INTVAL (elt);
9914 hi = -(lo < 0);
9915 break;
9916
9917 case CONST_DOUBLE:
9918 lo = CONST_DOUBLE_LOW (elt);
9919 hi = CONST_DOUBLE_HIGH (elt);
9920 break;
9921
9922 default:
9923 gcc_unreachable ();
9924 }
9925
9926 if (elt_size <= sizeof (HOST_WIDE_INT))
9927 insert_int (lo, elt_size, p);
9928 else
9929 {
9930 unsigned char *p0 = p;
9931 unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
9932
9933 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
9934 if (WORDS_BIG_ENDIAN)
9935 {
9936 p0 = p1;
9937 p1 = p;
9938 }
9939 insert_int (lo, sizeof (HOST_WIDE_INT), p0);
9940 insert_int (hi, sizeof (HOST_WIDE_INT), p1);
9941 }
9942 }
9943 break;
9944
9945 case MODE_VECTOR_FLOAT:
9946 for (i = 0, p = array; i < length; i++, p += elt_size)
9947 {
9948 rtx elt = CONST_VECTOR_ELT (rtl, i);
9949 insert_float (elt, p);
9950 }
9951 break;
9952
9953 default:
9954 gcc_unreachable ();
9955 }
9956
9957 add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
9958 }
9959 break;
9960
9961 case CONST_STRING:
9962 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
9963 break;
9964
9965 case SYMBOL_REF:
9966 case LABEL_REF:
9967 case CONST:
9968 add_AT_addr (die, DW_AT_const_value, rtl);
9969 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
9970 break;
9971
9972 case PLUS:
9973 /* In cases where an inlined instance of an inline function is passed
9974 the address of an `auto' variable (which is local to the caller) we
9975 can get a situation where the DECL_RTL of the artificial local
9976 variable (for the inlining) which acts as a stand-in for the
9977 corresponding formal parameter (of the inline function) will look
9978 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
9979 exactly a compile-time constant expression, but it isn't the address
9980 of the (artificial) local variable either. Rather, it represents the
9981 *value* which the artificial local variable always has during its
9982 lifetime. We currently have no way to represent such quasi-constant
9983 values in Dwarf, so for now we just punt and generate nothing. */
9984 break;
9985
9986 default:
9987 /* No other kinds of rtx should be possible here. */
9988 gcc_unreachable ();
9989 }
9990
9991 }
9992
9993 /* Determine whether the evaluation of EXPR references any variables
9994 or functions which aren't otherwise used (and therefore may not be
9995 output). */
9996 static tree
reference_to_unused(tree * tp,int * walk_subtrees,void * data ATTRIBUTE_UNUSED)9997 reference_to_unused (tree * tp, int * walk_subtrees,
9998 void * data ATTRIBUTE_UNUSED)
9999 {
10000 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
10001 *walk_subtrees = 0;
10002
10003 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
10004 && ! TREE_ASM_WRITTEN (*tp))
10005 return *tp;
10006 else if (!flag_unit_at_a_time)
10007 return NULL_TREE;
10008 else if (!cgraph_global_info_ready
10009 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL))
10010 gcc_unreachable ();
10011 else if (DECL_P (*tp) && TREE_CODE (*tp) == VAR_DECL)
10012 {
10013 struct cgraph_varpool_node *node = cgraph_varpool_node (*tp);
10014 if (!node->needed)
10015 return *tp;
10016 }
10017 else if (DECL_P (*tp) && TREE_CODE (*tp) == FUNCTION_DECL
10018 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp)))
10019 {
10020 struct cgraph_node *node = cgraph_node (*tp);
10021 if (!node->output)
10022 return *tp;
10023 }
10024
10025 return NULL_TREE;
10026 }
10027
10028 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
10029 for use in a later add_const_value_attribute call. */
10030
10031 static rtx
rtl_for_decl_init(tree init,tree type)10032 rtl_for_decl_init (tree init, tree type)
10033 {
10034 rtx rtl = NULL_RTX;
10035
10036 /* If a variable is initialized with a string constant without embedded
10037 zeros, build CONST_STRING. */
10038 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
10039 {
10040 tree enttype = TREE_TYPE (type);
10041 tree domain = TYPE_DOMAIN (type);
10042 enum machine_mode mode = TYPE_MODE (enttype);
10043
10044 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
10045 && domain
10046 && integer_zerop (TYPE_MIN_VALUE (domain))
10047 && compare_tree_int (TYPE_MAX_VALUE (domain),
10048 TREE_STRING_LENGTH (init) - 1) == 0
10049 && ((size_t) TREE_STRING_LENGTH (init)
10050 == strlen (TREE_STRING_POINTER (init)) + 1))
10051 rtl = gen_rtx_CONST_STRING (VOIDmode,
10052 ggc_strdup (TREE_STRING_POINTER (init)));
10053 }
10054 /* Other aggregates, and complex values, could be represented using
10055 CONCAT: FIXME! */
10056 else if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE)
10057 ;
10058 /* Vectors only work if their mode is supported by the target.
10059 FIXME: generic vectors ought to work too. */
10060 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_MODE (type) == BLKmode)
10061 ;
10062 /* If the initializer is something that we know will expand into an
10063 immediate RTL constant, expand it now. We must be careful not to
10064 reference variables which won't be output. */
10065 else if (initializer_constant_valid_p (init, type)
10066 && ! walk_tree (&init, reference_to_unused, NULL, NULL))
10067 {
10068 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
10069
10070 /* If expand_expr returns a MEM, it wasn't immediate. */
10071 gcc_assert (!rtl || !MEM_P (rtl));
10072 }
10073
10074 return rtl;
10075 }
10076
10077 /* Generate RTL for the variable DECL to represent its location. */
10078
10079 static rtx
rtl_for_decl_location(tree decl)10080 rtl_for_decl_location (tree decl)
10081 {
10082 rtx rtl;
10083
10084 /* Here we have to decide where we are going to say the parameter "lives"
10085 (as far as the debugger is concerned). We only have a couple of
10086 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
10087
10088 DECL_RTL normally indicates where the parameter lives during most of the
10089 activation of the function. If optimization is enabled however, this
10090 could be either NULL or else a pseudo-reg. Both of those cases indicate
10091 that the parameter doesn't really live anywhere (as far as the code
10092 generation parts of GCC are concerned) during most of the function's
10093 activation. That will happen (for example) if the parameter is never
10094 referenced within the function.
10095
10096 We could just generate a location descriptor here for all non-NULL
10097 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
10098 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
10099 where DECL_RTL is NULL or is a pseudo-reg.
10100
10101 Note however that we can only get away with using DECL_INCOMING_RTL as
10102 a backup substitute for DECL_RTL in certain limited cases. In cases
10103 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
10104 we can be sure that the parameter was passed using the same type as it is
10105 declared to have within the function, and that its DECL_INCOMING_RTL
10106 points us to a place where a value of that type is passed.
10107
10108 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
10109 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
10110 because in these cases DECL_INCOMING_RTL points us to a value of some
10111 type which is *different* from the type of the parameter itself. Thus,
10112 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
10113 such cases, the debugger would end up (for example) trying to fetch a
10114 `float' from a place which actually contains the first part of a
10115 `double'. That would lead to really incorrect and confusing
10116 output at debug-time.
10117
10118 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
10119 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
10120 are a couple of exceptions however. On little-endian machines we can
10121 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
10122 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
10123 an integral type that is smaller than TREE_TYPE (decl). These cases arise
10124 when (on a little-endian machine) a non-prototyped function has a
10125 parameter declared to be of type `short' or `char'. In such cases,
10126 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
10127 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
10128 passed `int' value. If the debugger then uses that address to fetch
10129 a `short' or a `char' (on a little-endian machine) the result will be
10130 the correct data, so we allow for such exceptional cases below.
10131
10132 Note that our goal here is to describe the place where the given formal
10133 parameter lives during most of the function's activation (i.e. between the
10134 end of the prologue and the start of the epilogue). We'll do that as best
10135 as we can. Note however that if the given formal parameter is modified
10136 sometime during the execution of the function, then a stack backtrace (at
10137 debug-time) will show the function as having been called with the *new*
10138 value rather than the value which was originally passed in. This happens
10139 rarely enough that it is not a major problem, but it *is* a problem, and
10140 I'd like to fix it.
10141
10142 A future version of dwarf2out.c may generate two additional attributes for
10143 any given DW_TAG_formal_parameter DIE which will describe the "passed
10144 type" and the "passed location" for the given formal parameter in addition
10145 to the attributes we now generate to indicate the "declared type" and the
10146 "active location" for each parameter. This additional set of attributes
10147 could be used by debuggers for stack backtraces. Separately, note that
10148 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
10149 This happens (for example) for inlined-instances of inline function formal
10150 parameters which are never referenced. This really shouldn't be
10151 happening. All PARM_DECL nodes should get valid non-NULL
10152 DECL_INCOMING_RTL values. FIXME. */
10153
10154 /* Use DECL_RTL as the "location" unless we find something better. */
10155 rtl = DECL_RTL_IF_SET (decl);
10156
10157 /* When generating abstract instances, ignore everything except
10158 constants, symbols living in memory, and symbols living in
10159 fixed registers. */
10160 if (! reload_completed)
10161 {
10162 if (rtl
10163 && (CONSTANT_P (rtl)
10164 || (MEM_P (rtl)
10165 && CONSTANT_P (XEXP (rtl, 0)))
10166 || (REG_P (rtl)
10167 && TREE_CODE (decl) == VAR_DECL
10168 && TREE_STATIC (decl))))
10169 {
10170 rtl = targetm.delegitimize_address (rtl);
10171 return rtl;
10172 }
10173 rtl = NULL_RTX;
10174 }
10175 else if (TREE_CODE (decl) == PARM_DECL)
10176 {
10177 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
10178 {
10179 tree declared_type = TREE_TYPE (decl);
10180 tree passed_type = DECL_ARG_TYPE (decl);
10181 enum machine_mode dmode = TYPE_MODE (declared_type);
10182 enum machine_mode pmode = TYPE_MODE (passed_type);
10183
10184 /* This decl represents a formal parameter which was optimized out.
10185 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
10186 all cases where (rtl == NULL_RTX) just below. */
10187 if (dmode == pmode)
10188 rtl = DECL_INCOMING_RTL (decl);
10189 else if (SCALAR_INT_MODE_P (dmode)
10190 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
10191 && DECL_INCOMING_RTL (decl))
10192 {
10193 rtx inc = DECL_INCOMING_RTL (decl);
10194 if (REG_P (inc))
10195 rtl = inc;
10196 else if (MEM_P (inc))
10197 {
10198 if (BYTES_BIG_ENDIAN)
10199 rtl = adjust_address_nv (inc, dmode,
10200 GET_MODE_SIZE (pmode)
10201 - GET_MODE_SIZE (dmode));
10202 else
10203 rtl = inc;
10204 }
10205 }
10206 }
10207
10208 /* If the parm was passed in registers, but lives on the stack, then
10209 make a big endian correction if the mode of the type of the
10210 parameter is not the same as the mode of the rtl. */
10211 /* ??? This is the same series of checks that are made in dbxout.c before
10212 we reach the big endian correction code there. It isn't clear if all
10213 of these checks are necessary here, but keeping them all is the safe
10214 thing to do. */
10215 else if (MEM_P (rtl)
10216 && XEXP (rtl, 0) != const0_rtx
10217 && ! CONSTANT_P (XEXP (rtl, 0))
10218 /* Not passed in memory. */
10219 && !MEM_P (DECL_INCOMING_RTL (decl))
10220 /* Not passed by invisible reference. */
10221 && (!REG_P (XEXP (rtl, 0))
10222 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
10223 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
10224 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
10225 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
10226 #endif
10227 )
10228 /* Big endian correction check. */
10229 && BYTES_BIG_ENDIAN
10230 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
10231 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
10232 < UNITS_PER_WORD))
10233 {
10234 int offset = (UNITS_PER_WORD
10235 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
10236
10237 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10238 plus_constant (XEXP (rtl, 0), offset));
10239 }
10240 }
10241 else if (TREE_CODE (decl) == VAR_DECL
10242 && rtl
10243 && MEM_P (rtl)
10244 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
10245 && BYTES_BIG_ENDIAN)
10246 {
10247 int rsize = GET_MODE_SIZE (GET_MODE (rtl));
10248 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
10249
10250 /* If a variable is declared "register" yet is smaller than
10251 a register, then if we store the variable to memory, it
10252 looks like we're storing a register-sized value, when in
10253 fact we are not. We need to adjust the offset of the
10254 storage location to reflect the actual value's bytes,
10255 else gdb will not be able to display it. */
10256 if (rsize > dsize)
10257 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10258 plus_constant (XEXP (rtl, 0), rsize-dsize));
10259 }
10260
10261 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
10262 and will have been substituted directly into all expressions that use it.
10263 C does not have such a concept, but C++ and other languages do. */
10264 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
10265 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
10266
10267 if (rtl)
10268 rtl = targetm.delegitimize_address (rtl);
10269
10270 /* If we don't look past the constant pool, we risk emitting a
10271 reference to a constant pool entry that isn't referenced from
10272 code, and thus is not emitted. */
10273 if (rtl)
10274 rtl = avoid_constant_pool_reference (rtl);
10275
10276 return rtl;
10277 }
10278
10279 /* We need to figure out what section we should use as the base for the
10280 address ranges where a given location is valid.
10281 1. If this particular DECL has a section associated with it, use that.
10282 2. If this function has a section associated with it, use that.
10283 3. Otherwise, use the text section.
10284 XXX: If you split a variable across multiple sections, we won't notice. */
10285
10286 static const char *
secname_for_decl(tree decl)10287 secname_for_decl (tree decl)
10288 {
10289 const char *secname;
10290
10291 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
10292 {
10293 tree sectree = DECL_SECTION_NAME (decl);
10294 secname = TREE_STRING_POINTER (sectree);
10295 }
10296 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
10297 {
10298 tree sectree = DECL_SECTION_NAME (current_function_decl);
10299 secname = TREE_STRING_POINTER (sectree);
10300 }
10301 else if (cfun && in_cold_section_p)
10302 secname = cfun->cold_section_label;
10303 else
10304 secname = text_section_label;
10305
10306 return secname;
10307 }
10308
10309 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
10310 data attribute for a variable or a parameter. We generate the
10311 DW_AT_const_value attribute only in those cases where the given variable
10312 or parameter does not have a true "location" either in memory or in a
10313 register. This can happen (for example) when a constant is passed as an
10314 actual argument in a call to an inline function. (It's possible that
10315 these things can crop up in other ways also.) Note that one type of
10316 constant value which can be passed into an inlined function is a constant
10317 pointer. This can happen for example if an actual argument in an inlined
10318 function call evaluates to a compile-time constant address. */
10319
10320 static void
add_location_or_const_value_attribute(dw_die_ref die,tree decl,enum dwarf_attribute attr)10321 add_location_or_const_value_attribute (dw_die_ref die, tree decl,
10322 enum dwarf_attribute attr)
10323 {
10324 rtx rtl;
10325 dw_loc_descr_ref descr;
10326 var_loc_list *loc_list;
10327 struct var_loc_node *node;
10328 if (TREE_CODE (decl) == ERROR_MARK)
10329 return;
10330
10331 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
10332 || TREE_CODE (decl) == RESULT_DECL);
10333
10334 /* See if we possibly have multiple locations for this variable. */
10335 loc_list = lookup_decl_loc (decl);
10336
10337 /* If it truly has multiple locations, the first and last node will
10338 differ. */
10339 if (loc_list && loc_list->first != loc_list->last)
10340 {
10341 const char *endname, *secname;
10342 dw_loc_list_ref list;
10343 rtx varloc;
10344
10345 /* Now that we know what section we are using for a base,
10346 actually construct the list of locations.
10347 The first location information is what is passed to the
10348 function that creates the location list, and the remaining
10349 locations just get added on to that list.
10350 Note that we only know the start address for a location
10351 (IE location changes), so to build the range, we use
10352 the range [current location start, next location start].
10353 This means we have to special case the last node, and generate
10354 a range of [last location start, end of function label]. */
10355
10356 node = loc_list->first;
10357 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10358 secname = secname_for_decl (decl);
10359
10360 list = new_loc_list (loc_descriptor (varloc),
10361 node->label, node->next->label, secname, 1);
10362 node = node->next;
10363
10364 for (; node->next; node = node->next)
10365 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10366 {
10367 /* The variable has a location between NODE->LABEL and
10368 NODE->NEXT->LABEL. */
10369 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10370 add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
10371 node->label, node->next->label, secname);
10372 }
10373
10374 /* If the variable has a location at the last label
10375 it keeps its location until the end of function. */
10376 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10377 {
10378 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
10379
10380 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10381 if (!current_function_decl)
10382 endname = text_end_label;
10383 else
10384 {
10385 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
10386 current_function_funcdef_no);
10387 endname = ggc_strdup (label_id);
10388 }
10389 add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
10390 node->label, endname, secname);
10391 }
10392
10393 /* Finally, add the location list to the DIE, and we are done. */
10394 add_AT_loc_list (die, attr, list);
10395 return;
10396 }
10397
10398 /* Try to get some constant RTL for this decl, and use that as the value of
10399 the location. */
10400
10401 rtl = rtl_for_decl_location (decl);
10402 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING))
10403 {
10404 add_const_value_attribute (die, rtl);
10405 return;
10406 }
10407
10408 /* If we have tried to generate the location otherwise, and it
10409 didn't work out (we wouldn't be here if we did), and we have a one entry
10410 location list, try generating a location from that. */
10411 if (loc_list && loc_list->first)
10412 {
10413 node = loc_list->first;
10414 descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note));
10415 if (descr)
10416 {
10417 add_AT_location_description (die, attr, descr);
10418 return;
10419 }
10420 }
10421
10422 /* We couldn't get any rtl, so try directly generating the location
10423 description from the tree. */
10424 descr = loc_descriptor_from_tree (decl);
10425 if (descr)
10426 {
10427 add_AT_location_description (die, attr, descr);
10428 return;
10429 }
10430 /* None of that worked, so it must not really have a location;
10431 try adding a constant value attribute from the DECL_INITIAL. */
10432 tree_add_const_value_attribute (die, decl);
10433 }
10434
10435 /* If we don't have a copy of this variable in memory for some reason (such
10436 as a C++ member constant that doesn't have an out-of-line definition),
10437 we should tell the debugger about the constant value. */
10438
10439 static void
tree_add_const_value_attribute(dw_die_ref var_die,tree decl)10440 tree_add_const_value_attribute (dw_die_ref var_die, tree decl)
10441 {
10442 tree init = DECL_INITIAL (decl);
10443 tree type = TREE_TYPE (decl);
10444 rtx rtl;
10445
10446 if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init)
10447 /* OK */;
10448 else
10449 return;
10450
10451 rtl = rtl_for_decl_init (init, type);
10452 if (rtl)
10453 add_const_value_attribute (var_die, rtl);
10454 }
10455
10456 /* Convert the CFI instructions for the current function into a
10457 location list. This is used for DW_AT_frame_base when we targeting
10458 a dwarf2 consumer that does not support the dwarf3
10459 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
10460 expressions. */
10461
10462 static dw_loc_list_ref
convert_cfa_to_fb_loc_list(HOST_WIDE_INT offset)10463 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
10464 {
10465 dw_fde_ref fde;
10466 dw_loc_list_ref list, *list_tail;
10467 dw_cfi_ref cfi;
10468 dw_cfa_location last_cfa, next_cfa;
10469 const char *start_label, *last_label, *section;
10470
10471 fde = &fde_table[fde_table_in_use - 1];
10472
10473 section = secname_for_decl (current_function_decl);
10474 list_tail = &list;
10475 list = NULL;
10476
10477 next_cfa.reg = INVALID_REGNUM;
10478 next_cfa.offset = 0;
10479 next_cfa.indirect = 0;
10480 next_cfa.base_offset = 0;
10481
10482 start_label = fde->dw_fde_begin;
10483
10484 /* ??? Bald assumption that the CIE opcode list does not contain
10485 advance opcodes. */
10486 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
10487 lookup_cfa_1 (cfi, &next_cfa);
10488
10489 last_cfa = next_cfa;
10490 last_label = start_label;
10491
10492 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
10493 switch (cfi->dw_cfi_opc)
10494 {
10495 case DW_CFA_set_loc:
10496 case DW_CFA_advance_loc1:
10497 case DW_CFA_advance_loc2:
10498 case DW_CFA_advance_loc4:
10499 if (!cfa_equal_p (&last_cfa, &next_cfa))
10500 {
10501 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
10502 start_label, last_label, section,
10503 list == NULL);
10504
10505 list_tail = &(*list_tail)->dw_loc_next;
10506 last_cfa = next_cfa;
10507 start_label = last_label;
10508 }
10509 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
10510 break;
10511
10512 case DW_CFA_advance_loc:
10513 /* The encoding is complex enough that we should never emit this. */
10514 case DW_CFA_remember_state:
10515 case DW_CFA_restore_state:
10516 /* We don't handle these two in this function. It would be possible
10517 if it were to be required. */
10518 gcc_unreachable ();
10519
10520 default:
10521 lookup_cfa_1 (cfi, &next_cfa);
10522 break;
10523 }
10524
10525 if (!cfa_equal_p (&last_cfa, &next_cfa))
10526 {
10527 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
10528 start_label, last_label, section,
10529 list == NULL);
10530 list_tail = &(*list_tail)->dw_loc_next;
10531 start_label = last_label;
10532 }
10533 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
10534 start_label, fde->dw_fde_end, section,
10535 list == NULL);
10536
10537 return list;
10538 }
10539
10540 /* Compute a displacement from the "steady-state frame pointer" to the
10541 frame base (often the same as the CFA), and store it in
10542 frame_pointer_fb_offset. OFFSET is added to the displacement
10543 before the latter is negated. */
10544
10545 static void
compute_frame_pointer_to_fb_displacement(HOST_WIDE_INT offset)10546 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
10547 {
10548 rtx reg, elim;
10549
10550 #ifdef FRAME_POINTER_CFA_OFFSET
10551 reg = frame_pointer_rtx;
10552 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
10553 #else
10554 reg = arg_pointer_rtx;
10555 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
10556 #endif
10557
10558 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10559 if (GET_CODE (elim) == PLUS)
10560 {
10561 offset += INTVAL (XEXP (elim, 1));
10562 elim = XEXP (elim, 0);
10563 }
10564 gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
10565 : stack_pointer_rtx));
10566
10567 frame_pointer_fb_offset = -offset;
10568 }
10569
10570 /* Generate a DW_AT_name attribute given some string value to be included as
10571 the value of the attribute. */
10572
10573 static void
add_name_attribute(dw_die_ref die,const char * name_string)10574 add_name_attribute (dw_die_ref die, const char *name_string)
10575 {
10576 if (name_string != NULL && *name_string != 0)
10577 {
10578 if (demangle_name_func)
10579 name_string = (*demangle_name_func) (name_string);
10580
10581 add_AT_string (die, DW_AT_name, name_string);
10582 }
10583 }
10584
10585 /* Generate a DW_AT_comp_dir attribute for DIE. */
10586
10587 static void
add_comp_dir_attribute(dw_die_ref die)10588 add_comp_dir_attribute (dw_die_ref die)
10589 {
10590 const char *wd = get_src_pwd ();
10591 if (wd != NULL)
10592 add_AT_string (die, DW_AT_comp_dir, wd);
10593 }
10594
10595 /* Given a tree node describing an array bound (either lower or upper) output
10596 a representation for that bound. */
10597
10598 static void
add_bound_info(dw_die_ref subrange_die,enum dwarf_attribute bound_attr,tree bound)10599 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
10600 {
10601 switch (TREE_CODE (bound))
10602 {
10603 case ERROR_MARK:
10604 return;
10605
10606 /* All fixed-bounds are represented by INTEGER_CST nodes. */
10607 case INTEGER_CST:
10608 if (! host_integerp (bound, 0)
10609 || (bound_attr == DW_AT_lower_bound
10610 && (((is_c_family () || is_java ()) && integer_zerop (bound))
10611 || (is_fortran () && integer_onep (bound)))))
10612 /* Use the default. */
10613 ;
10614 else
10615 add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
10616 break;
10617
10618 case CONVERT_EXPR:
10619 case NOP_EXPR:
10620 case NON_LVALUE_EXPR:
10621 case VIEW_CONVERT_EXPR:
10622 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
10623 break;
10624
10625 case SAVE_EXPR:
10626 break;
10627
10628 case VAR_DECL:
10629 case PARM_DECL:
10630 case RESULT_DECL:
10631 {
10632 dw_die_ref decl_die = lookup_decl_die (bound);
10633
10634 /* ??? Can this happen, or should the variable have been bound
10635 first? Probably it can, since I imagine that we try to create
10636 the types of parameters in the order in which they exist in
10637 the list, and won't have created a forward reference to a
10638 later parameter. */
10639 if (decl_die != NULL)
10640 add_AT_die_ref (subrange_die, bound_attr, decl_die);
10641 break;
10642 }
10643
10644 default:
10645 {
10646 /* Otherwise try to create a stack operation procedure to
10647 evaluate the value of the array bound. */
10648
10649 dw_die_ref ctx, decl_die;
10650 dw_loc_descr_ref loc;
10651
10652 loc = loc_descriptor_from_tree (bound);
10653 if (loc == NULL)
10654 break;
10655
10656 if (current_function_decl == 0)
10657 ctx = comp_unit_die;
10658 else
10659 ctx = lookup_decl_die (current_function_decl);
10660
10661 decl_die = new_die (DW_TAG_variable, ctx, bound);
10662 add_AT_flag (decl_die, DW_AT_artificial, 1);
10663 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
10664 add_AT_loc (decl_die, DW_AT_location, loc);
10665
10666 add_AT_die_ref (subrange_die, bound_attr, decl_die);
10667 break;
10668 }
10669 }
10670 }
10671
10672 /* Note that the block of subscript information for an array type also
10673 includes information about the element type of type given array type. */
10674
10675 static void
add_subscript_info(dw_die_ref type_die,tree type)10676 add_subscript_info (dw_die_ref type_die, tree type)
10677 {
10678 #ifndef MIPS_DEBUGGING_INFO
10679 unsigned dimension_number;
10680 #endif
10681 tree lower, upper;
10682 dw_die_ref subrange_die;
10683
10684 /* The GNU compilers represent multidimensional array types as sequences of
10685 one dimensional array types whose element types are themselves array
10686 types. Here we squish that down, so that each multidimensional array
10687 type gets only one array_type DIE in the Dwarf debugging info. The draft
10688 Dwarf specification say that we are allowed to do this kind of
10689 compression in C (because there is no difference between an array or
10690 arrays and a multidimensional array in C) but for other source languages
10691 (e.g. Ada) we probably shouldn't do this. */
10692
10693 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
10694 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
10695 We work around this by disabling this feature. See also
10696 gen_array_type_die. */
10697 #ifndef MIPS_DEBUGGING_INFO
10698 for (dimension_number = 0;
10699 TREE_CODE (type) == ARRAY_TYPE;
10700 type = TREE_TYPE (type), dimension_number++)
10701 #endif
10702 {
10703 tree domain = TYPE_DOMAIN (type);
10704
10705 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
10706 and (in GNU C only) variable bounds. Handle all three forms
10707 here. */
10708 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
10709 if (domain)
10710 {
10711 /* We have an array type with specified bounds. */
10712 lower = TYPE_MIN_VALUE (domain);
10713 upper = TYPE_MAX_VALUE (domain);
10714
10715 /* Define the index type. */
10716 if (TREE_TYPE (domain))
10717 {
10718 /* ??? This is probably an Ada unnamed subrange type. Ignore the
10719 TREE_TYPE field. We can't emit debug info for this
10720 because it is an unnamed integral type. */
10721 if (TREE_CODE (domain) == INTEGER_TYPE
10722 && TYPE_NAME (domain) == NULL_TREE
10723 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
10724 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
10725 ;
10726 else
10727 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
10728 type_die);
10729 }
10730
10731 /* ??? If upper is NULL, the array has unspecified length,
10732 but it does have a lower bound. This happens with Fortran
10733 dimension arr(N:*)
10734 Since the debugger is definitely going to need to know N
10735 to produce useful results, go ahead and output the lower
10736 bound solo, and hope the debugger can cope. */
10737
10738 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
10739 if (upper)
10740 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
10741 }
10742
10743 /* Otherwise we have an array type with an unspecified length. The
10744 DWARF-2 spec does not say how to handle this; let's just leave out the
10745 bounds. */
10746 }
10747 }
10748
10749 static void
add_byte_size_attribute(dw_die_ref die,tree tree_node)10750 add_byte_size_attribute (dw_die_ref die, tree tree_node)
10751 {
10752 unsigned size;
10753
10754 switch (TREE_CODE (tree_node))
10755 {
10756 case ERROR_MARK:
10757 size = 0;
10758 break;
10759 case ENUMERAL_TYPE:
10760 case RECORD_TYPE:
10761 case UNION_TYPE:
10762 case QUAL_UNION_TYPE:
10763 size = int_size_in_bytes (tree_node);
10764 break;
10765 case FIELD_DECL:
10766 /* For a data member of a struct or union, the DW_AT_byte_size is
10767 generally given as the number of bytes normally allocated for an
10768 object of the *declared* type of the member itself. This is true
10769 even for bit-fields. */
10770 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
10771 break;
10772 default:
10773 gcc_unreachable ();
10774 }
10775
10776 /* Note that `size' might be -1 when we get to this point. If it is, that
10777 indicates that the byte size of the entity in question is variable. We
10778 have no good way of expressing this fact in Dwarf at the present time,
10779 so just let the -1 pass on through. */
10780 add_AT_unsigned (die, DW_AT_byte_size, size);
10781 }
10782
10783 /* For a FIELD_DECL node which represents a bit-field, output an attribute
10784 which specifies the distance in bits from the highest order bit of the
10785 "containing object" for the bit-field to the highest order bit of the
10786 bit-field itself.
10787
10788 For any given bit-field, the "containing object" is a hypothetical object
10789 (of some integral or enum type) within which the given bit-field lives. The
10790 type of this hypothetical "containing object" is always the same as the
10791 declared type of the individual bit-field itself. The determination of the
10792 exact location of the "containing object" for a bit-field is rather
10793 complicated. It's handled by the `field_byte_offset' function (above).
10794
10795 Note that it is the size (in bytes) of the hypothetical "containing object"
10796 which will be given in the DW_AT_byte_size attribute for this bit-field.
10797 (See `byte_size_attribute' above). */
10798
10799 static inline void
add_bit_offset_attribute(dw_die_ref die,tree decl)10800 add_bit_offset_attribute (dw_die_ref die, tree decl)
10801 {
10802 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
10803 tree type = DECL_BIT_FIELD_TYPE (decl);
10804 HOST_WIDE_INT bitpos_int;
10805 HOST_WIDE_INT highest_order_object_bit_offset;
10806 HOST_WIDE_INT highest_order_field_bit_offset;
10807 HOST_WIDE_INT unsigned bit_offset;
10808
10809 /* Must be a field and a bit field. */
10810 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
10811
10812 /* We can't yet handle bit-fields whose offsets are variable, so if we
10813 encounter such things, just return without generating any attribute
10814 whatsoever. Likewise for variable or too large size. */
10815 if (! host_integerp (bit_position (decl), 0)
10816 || ! host_integerp (DECL_SIZE (decl), 1))
10817 return;
10818
10819 bitpos_int = int_bit_position (decl);
10820
10821 /* Note that the bit offset is always the distance (in bits) from the
10822 highest-order bit of the "containing object" to the highest-order bit of
10823 the bit-field itself. Since the "high-order end" of any object or field
10824 is different on big-endian and little-endian machines, the computation
10825 below must take account of these differences. */
10826 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
10827 highest_order_field_bit_offset = bitpos_int;
10828
10829 if (! BYTES_BIG_ENDIAN)
10830 {
10831 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
10832 highest_order_object_bit_offset += simple_type_size_in_bits (type);
10833 }
10834
10835 bit_offset
10836 = (! BYTES_BIG_ENDIAN
10837 ? highest_order_object_bit_offset - highest_order_field_bit_offset
10838 : highest_order_field_bit_offset - highest_order_object_bit_offset);
10839
10840 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
10841 }
10842
10843 /* For a FIELD_DECL node which represents a bit field, output an attribute
10844 which specifies the length in bits of the given field. */
10845
10846 static inline void
add_bit_size_attribute(dw_die_ref die,tree decl)10847 add_bit_size_attribute (dw_die_ref die, tree decl)
10848 {
10849 /* Must be a field and a bit field. */
10850 gcc_assert (TREE_CODE (decl) == FIELD_DECL
10851 && DECL_BIT_FIELD_TYPE (decl));
10852
10853 if (host_integerp (DECL_SIZE (decl), 1))
10854 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
10855 }
10856
10857 /* If the compiled language is ANSI C, then add a 'prototyped'
10858 attribute, if arg types are given for the parameters of a function. */
10859
10860 static inline void
add_prototyped_attribute(dw_die_ref die,tree func_type)10861 add_prototyped_attribute (dw_die_ref die, tree func_type)
10862 {
10863 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
10864 && TYPE_ARG_TYPES (func_type) != NULL)
10865 add_AT_flag (die, DW_AT_prototyped, 1);
10866 }
10867
10868 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
10869 by looking in either the type declaration or object declaration
10870 equate table. */
10871
10872 static inline void
add_abstract_origin_attribute(dw_die_ref die,tree origin)10873 add_abstract_origin_attribute (dw_die_ref die, tree origin)
10874 {
10875 dw_die_ref origin_die = NULL;
10876
10877 if (TREE_CODE (origin) != FUNCTION_DECL)
10878 {
10879 /* We may have gotten separated from the block for the inlined
10880 function, if we're in an exception handler or some such; make
10881 sure that the abstract function has been written out.
10882
10883 Doing this for nested functions is wrong, however; functions are
10884 distinct units, and our context might not even be inline. */
10885 tree fn = origin;
10886
10887 if (TYPE_P (fn))
10888 fn = TYPE_STUB_DECL (fn);
10889
10890 fn = decl_function_context (fn);
10891 if (fn)
10892 dwarf2out_abstract_function (fn);
10893 }
10894
10895 if (DECL_P (origin))
10896 origin_die = lookup_decl_die (origin);
10897 else if (TYPE_P (origin))
10898 origin_die = lookup_type_die (origin);
10899
10900 /* XXX: Functions that are never lowered don't always have correct block
10901 trees (in the case of java, they simply have no block tree, in some other
10902 languages). For these functions, there is nothing we can really do to
10903 output correct debug info for inlined functions in all cases. Rather
10904 than die, we'll just produce deficient debug info now, in that we will
10905 have variables without a proper abstract origin. In the future, when all
10906 functions are lowered, we should re-add a gcc_assert (origin_die)
10907 here. */
10908
10909 if (origin_die)
10910 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
10911 }
10912
10913 /* We do not currently support the pure_virtual attribute. */
10914
10915 static inline void
add_pure_or_virtual_attribute(dw_die_ref die,tree func_decl)10916 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
10917 {
10918 if (DECL_VINDEX (func_decl))
10919 {
10920 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
10921
10922 if (host_integerp (DECL_VINDEX (func_decl), 0))
10923 add_AT_loc (die, DW_AT_vtable_elem_location,
10924 new_loc_descr (DW_OP_constu,
10925 tree_low_cst (DECL_VINDEX (func_decl), 0),
10926 0));
10927
10928 /* GNU extension: Record what type this method came from originally. */
10929 if (debug_info_level > DINFO_LEVEL_TERSE)
10930 add_AT_die_ref (die, DW_AT_containing_type,
10931 lookup_type_die (DECL_CONTEXT (func_decl)));
10932 }
10933 }
10934
10935 /* Add source coordinate attributes for the given decl. */
10936
10937 static void
add_src_coords_attributes(dw_die_ref die,tree decl)10938 add_src_coords_attributes (dw_die_ref die, tree decl)
10939 {
10940 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
10941
10942 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
10943 add_AT_unsigned (die, DW_AT_decl_line, s.line);
10944 }
10945
10946 /* Add a DW_AT_name attribute and source coordinate attribute for the
10947 given decl, but only if it actually has a name. */
10948
10949 static void
add_name_and_src_coords_attributes(dw_die_ref die,tree decl)10950 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
10951 {
10952 tree decl_name;
10953
10954 decl_name = DECL_NAME (decl);
10955 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
10956 {
10957 add_name_attribute (die, dwarf2_name (decl, 0));
10958 if (! DECL_ARTIFICIAL (decl))
10959 add_src_coords_attributes (die, decl);
10960
10961 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
10962 && TREE_PUBLIC (decl)
10963 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
10964 && !DECL_ABSTRACT (decl)
10965 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl)))
10966 add_AT_string (die, DW_AT_MIPS_linkage_name,
10967 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
10968 }
10969
10970 #ifdef VMS_DEBUGGING_INFO
10971 /* Get the function's name, as described by its RTL. This may be different
10972 from the DECL_NAME name used in the source file. */
10973 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
10974 {
10975 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
10976 XEXP (DECL_RTL (decl), 0));
10977 VEC_safe_push (tree, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
10978 }
10979 #endif
10980 }
10981
10982 /* Push a new declaration scope. */
10983
10984 static void
push_decl_scope(tree scope)10985 push_decl_scope (tree scope)
10986 {
10987 VEC_safe_push (tree, gc, decl_scope_table, scope);
10988 }
10989
10990 /* Pop a declaration scope. */
10991
10992 static inline void
pop_decl_scope(void)10993 pop_decl_scope (void)
10994 {
10995 VEC_pop (tree, decl_scope_table);
10996 }
10997
10998 /* Return the DIE for the scope that immediately contains this type.
10999 Non-named types get global scope. Named types nested in other
11000 types get their containing scope if it's open, or global scope
11001 otherwise. All other types (i.e. function-local named types) get
11002 the current active scope. */
11003
11004 static dw_die_ref
scope_die_for(tree t,dw_die_ref context_die)11005 scope_die_for (tree t, dw_die_ref context_die)
11006 {
11007 dw_die_ref scope_die = NULL;
11008 tree containing_scope;
11009 int i;
11010
11011 /* Non-types always go in the current scope. */
11012 gcc_assert (TYPE_P (t));
11013
11014 containing_scope = TYPE_CONTEXT (t);
11015
11016 /* Use the containing namespace if it was passed in (for a declaration). */
11017 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
11018 {
11019 if (context_die == lookup_decl_die (containing_scope))
11020 /* OK */;
11021 else
11022 containing_scope = NULL_TREE;
11023 }
11024
11025 /* Ignore function type "scopes" from the C frontend. They mean that
11026 a tagged type is local to a parmlist of a function declarator, but
11027 that isn't useful to DWARF. */
11028 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
11029 containing_scope = NULL_TREE;
11030
11031 if (containing_scope == NULL_TREE)
11032 scope_die = comp_unit_die;
11033 else if (TYPE_P (containing_scope))
11034 {
11035 /* For types, we can just look up the appropriate DIE. But
11036 first we check to see if we're in the middle of emitting it
11037 so we know where the new DIE should go. */
11038 for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
11039 if (VEC_index (tree, decl_scope_table, i) == containing_scope)
11040 break;
11041
11042 if (i < 0)
11043 {
11044 gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
11045 || TREE_ASM_WRITTEN (containing_scope));
11046
11047 /* If none of the current dies are suitable, we get file scope. */
11048 scope_die = comp_unit_die;
11049 }
11050 else
11051 scope_die = lookup_type_die (containing_scope);
11052 }
11053 else
11054 scope_die = context_die;
11055
11056 return scope_die;
11057 }
11058
11059 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
11060
11061 static inline int
local_scope_p(dw_die_ref context_die)11062 local_scope_p (dw_die_ref context_die)
11063 {
11064 for (; context_die; context_die = context_die->die_parent)
11065 if (context_die->die_tag == DW_TAG_inlined_subroutine
11066 || context_die->die_tag == DW_TAG_subprogram)
11067 return 1;
11068
11069 return 0;
11070 }
11071
11072 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
11073 whether or not to treat a DIE in this context as a declaration. */
11074
11075 static inline int
class_or_namespace_scope_p(dw_die_ref context_die)11076 class_or_namespace_scope_p (dw_die_ref context_die)
11077 {
11078 return (context_die
11079 && (context_die->die_tag == DW_TAG_structure_type
11080 || context_die->die_tag == DW_TAG_union_type
11081 || context_die->die_tag == DW_TAG_namespace));
11082 }
11083
11084 /* Many forms of DIEs require a "type description" attribute. This
11085 routine locates the proper "type descriptor" die for the type given
11086 by 'type', and adds a DW_AT_type attribute below the given die. */
11087
11088 static void
add_type_attribute(dw_die_ref object_die,tree type,int decl_const,int decl_volatile,dw_die_ref context_die)11089 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
11090 int decl_volatile, dw_die_ref context_die)
11091 {
11092 enum tree_code code = TREE_CODE (type);
11093 dw_die_ref type_die = NULL;
11094
11095 /* ??? If this type is an unnamed subrange type of an integral or
11096 floating-point type, use the inner type. This is because we have no
11097 support for unnamed types in base_type_die. This can happen if this is
11098 an Ada subrange type. Correct solution is emit a subrange type die. */
11099 if ((code == INTEGER_TYPE || code == REAL_TYPE)
11100 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
11101 type = TREE_TYPE (type), code = TREE_CODE (type);
11102
11103 if (code == ERROR_MARK
11104 /* Handle a special case. For functions whose return type is void, we
11105 generate *no* type attribute. (Note that no object may have type
11106 `void', so this only applies to function return types). */
11107 || code == VOID_TYPE)
11108 return;
11109
11110 type_die = modified_type_die (type,
11111 decl_const || TYPE_READONLY (type),
11112 decl_volatile || TYPE_VOLATILE (type),
11113 context_die);
11114
11115 if (type_die != NULL)
11116 add_AT_die_ref (object_die, DW_AT_type, type_die);
11117 }
11118
11119 /* Given an object die, add the calling convention attribute for the
11120 function call type. */
11121 static void
add_calling_convention_attribute(dw_die_ref subr_die,tree type)11122 add_calling_convention_attribute (dw_die_ref subr_die, tree type)
11123 {
11124 enum dwarf_calling_convention value = DW_CC_normal;
11125
11126 value = targetm.dwarf_calling_convention (type);
11127
11128 /* Only add the attribute if the backend requests it, and
11129 is not DW_CC_normal. */
11130 if (value && (value != DW_CC_normal))
11131 add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
11132 }
11133
11134 /* Given a tree pointer to a struct, class, union, or enum type node, return
11135 a pointer to the (string) tag name for the given type, or zero if the type
11136 was declared without a tag. */
11137
11138 static const char *
type_tag(tree type)11139 type_tag (tree type)
11140 {
11141 const char *name = 0;
11142
11143 if (TYPE_NAME (type) != 0)
11144 {
11145 tree t = 0;
11146
11147 /* Find the IDENTIFIER_NODE for the type name. */
11148 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
11149 t = TYPE_NAME (type);
11150
11151 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
11152 a TYPE_DECL node, regardless of whether or not a `typedef' was
11153 involved. */
11154 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11155 && ! DECL_IGNORED_P (TYPE_NAME (type)))
11156 t = DECL_NAME (TYPE_NAME (type));
11157
11158 /* Now get the name as a string, or invent one. */
11159 if (t != 0)
11160 name = IDENTIFIER_POINTER (t);
11161 }
11162
11163 return (name == 0 || *name == '\0') ? 0 : name;
11164 }
11165
11166 /* Return the type associated with a data member, make a special check
11167 for bit field types. */
11168
11169 static inline tree
member_declared_type(tree member)11170 member_declared_type (tree member)
11171 {
11172 return (DECL_BIT_FIELD_TYPE (member)
11173 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
11174 }
11175
11176 /* Get the decl's label, as described by its RTL. This may be different
11177 from the DECL_NAME name used in the source file. */
11178
11179 #if 0
11180 static const char *
11181 decl_start_label (tree decl)
11182 {
11183 rtx x;
11184 const char *fnname;
11185
11186 x = DECL_RTL (decl);
11187 gcc_assert (MEM_P (x));
11188
11189 x = XEXP (x, 0);
11190 gcc_assert (GET_CODE (x) == SYMBOL_REF);
11191
11192 fnname = XSTR (x, 0);
11193 return fnname;
11194 }
11195 #endif
11196
11197 /* These routines generate the internal representation of the DIE's for
11198 the compilation unit. Debugging information is collected by walking
11199 the declaration trees passed in from dwarf2out_decl(). */
11200
11201 static void
gen_array_type_die(tree type,dw_die_ref context_die)11202 gen_array_type_die (tree type, dw_die_ref context_die)
11203 {
11204 dw_die_ref scope_die = scope_die_for (type, context_die);
11205 dw_die_ref array_die;
11206 tree element_type;
11207
11208 /* ??? The SGI dwarf reader fails for array of array of enum types unless
11209 the inner array type comes before the outer array type. Thus we must
11210 call gen_type_die before we call new_die. See below also. */
11211 #ifdef MIPS_DEBUGGING_INFO
11212 gen_type_die (TREE_TYPE (type), context_die);
11213 #endif
11214
11215 array_die = new_die (DW_TAG_array_type, scope_die, type);
11216 add_name_attribute (array_die, type_tag (type));
11217 equate_type_number_to_die (type, array_die);
11218
11219 if (TREE_CODE (type) == VECTOR_TYPE)
11220 {
11221 /* The frontend feeds us a representation for the vector as a struct
11222 containing an array. Pull out the array type. */
11223 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
11224 add_AT_flag (array_die, DW_AT_GNU_vector, 1);
11225 }
11226
11227 #if 0
11228 /* We default the array ordering. SDB will probably do
11229 the right things even if DW_AT_ordering is not present. It's not even
11230 an issue until we start to get into multidimensional arrays anyway. If
11231 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
11232 then we'll have to put the DW_AT_ordering attribute back in. (But if
11233 and when we find out that we need to put these in, we will only do so
11234 for multidimensional arrays. */
11235 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
11236 #endif
11237
11238 #ifdef MIPS_DEBUGGING_INFO
11239 /* The SGI compilers handle arrays of unknown bound by setting
11240 AT_declaration and not emitting any subrange DIEs. */
11241 if (! TYPE_DOMAIN (type))
11242 add_AT_flag (array_die, DW_AT_declaration, 1);
11243 else
11244 #endif
11245 add_subscript_info (array_die, type);
11246
11247 /* Add representation of the type of the elements of this array type. */
11248 element_type = TREE_TYPE (type);
11249
11250 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
11251 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
11252 We work around this by disabling this feature. See also
11253 add_subscript_info. */
11254 #ifndef MIPS_DEBUGGING_INFO
11255 while (TREE_CODE (element_type) == ARRAY_TYPE)
11256 element_type = TREE_TYPE (element_type);
11257
11258 gen_type_die (element_type, context_die);
11259 #endif
11260
11261 add_type_attribute (array_die, element_type, 0, 0, context_die);
11262 }
11263
11264 #if 0
11265 static void
11266 gen_entry_point_die (tree decl, dw_die_ref context_die)
11267 {
11268 tree origin = decl_ultimate_origin (decl);
11269 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
11270
11271 if (origin != NULL)
11272 add_abstract_origin_attribute (decl_die, origin);
11273 else
11274 {
11275 add_name_and_src_coords_attributes (decl_die, decl);
11276 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
11277 0, 0, context_die);
11278 }
11279
11280 if (DECL_ABSTRACT (decl))
11281 equate_decl_number_to_die (decl, decl_die);
11282 else
11283 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
11284 }
11285 #endif
11286
11287 /* Walk through the list of incomplete types again, trying once more to
11288 emit full debugging info for them. */
11289
11290 static void
retry_incomplete_types(void)11291 retry_incomplete_types (void)
11292 {
11293 int i;
11294
11295 for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
11296 gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die);
11297 }
11298
11299 /* Generate a DIE to represent an inlined instance of an enumeration type. */
11300
11301 static void
gen_inlined_enumeration_type_die(tree type,dw_die_ref context_die)11302 gen_inlined_enumeration_type_die (tree type, dw_die_ref context_die)
11303 {
11304 dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type);
11305
11306 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11307 be incomplete and such types are not marked. */
11308 add_abstract_origin_attribute (type_die, type);
11309 }
11310
11311 /* Generate a DIE to represent an inlined instance of a structure type. */
11312
11313 static void
gen_inlined_structure_type_die(tree type,dw_die_ref context_die)11314 gen_inlined_structure_type_die (tree type, dw_die_ref context_die)
11315 {
11316 dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die, type);
11317
11318 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11319 be incomplete and such types are not marked. */
11320 add_abstract_origin_attribute (type_die, type);
11321 }
11322
11323 /* Generate a DIE to represent an inlined instance of a union type. */
11324
11325 static void
gen_inlined_union_type_die(tree type,dw_die_ref context_die)11326 gen_inlined_union_type_die (tree type, dw_die_ref context_die)
11327 {
11328 dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type);
11329
11330 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11331 be incomplete and such types are not marked. */
11332 add_abstract_origin_attribute (type_die, type);
11333 }
11334
11335 /* Generate a DIE to represent an enumeration type. Note that these DIEs
11336 include all of the information about the enumeration values also. Each
11337 enumerated type name/value is listed as a child of the enumerated type
11338 DIE. */
11339
11340 static dw_die_ref
gen_enumeration_type_die(tree type,dw_die_ref context_die)11341 gen_enumeration_type_die (tree type, dw_die_ref context_die)
11342 {
11343 dw_die_ref type_die = lookup_type_die (type);
11344
11345 if (type_die == NULL)
11346 {
11347 type_die = new_die (DW_TAG_enumeration_type,
11348 scope_die_for (type, context_die), type);
11349 equate_type_number_to_die (type, type_die);
11350 add_name_attribute (type_die, type_tag (type));
11351 }
11352 else if (! TYPE_SIZE (type))
11353 return type_die;
11354 else
11355 remove_AT (type_die, DW_AT_declaration);
11356
11357 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
11358 given enum type is incomplete, do not generate the DW_AT_byte_size
11359 attribute or the DW_AT_element_list attribute. */
11360 if (TYPE_SIZE (type))
11361 {
11362 tree link;
11363
11364 TREE_ASM_WRITTEN (type) = 1;
11365 add_byte_size_attribute (type_die, type);
11366 if (TYPE_STUB_DECL (type) != NULL_TREE)
11367 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
11368
11369 /* If the first reference to this type was as the return type of an
11370 inline function, then it may not have a parent. Fix this now. */
11371 if (type_die->die_parent == NULL)
11372 add_child_die (scope_die_for (type, context_die), type_die);
11373
11374 for (link = TYPE_VALUES (type);
11375 link != NULL; link = TREE_CHAIN (link))
11376 {
11377 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
11378 tree value = TREE_VALUE (link);
11379
11380 add_name_attribute (enum_die,
11381 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
11382
11383 if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
11384 /* DWARF2 does not provide a way of indicating whether or
11385 not enumeration constants are signed or unsigned. GDB
11386 always assumes the values are signed, so we output all
11387 values as if they were signed. That means that
11388 enumeration constants with very large unsigned values
11389 will appear to have negative values in the debugger. */
11390 add_AT_int (enum_die, DW_AT_const_value,
11391 tree_low_cst (value, tree_int_cst_sgn (value) > 0));
11392 }
11393 }
11394 else
11395 add_AT_flag (type_die, DW_AT_declaration, 1);
11396
11397 return type_die;
11398 }
11399
11400 /* Generate a DIE to represent either a real live formal parameter decl or to
11401 represent just the type of some formal parameter position in some function
11402 type.
11403
11404 Note that this routine is a bit unusual because its argument may be a
11405 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
11406 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
11407 node. If it's the former then this function is being called to output a
11408 DIE to represent a formal parameter object (or some inlining thereof). If
11409 it's the latter, then this function is only being called to output a
11410 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
11411 argument type of some subprogram type. */
11412
11413 static dw_die_ref
gen_formal_parameter_die(tree node,dw_die_ref context_die)11414 gen_formal_parameter_die (tree node, dw_die_ref context_die)
11415 {
11416 dw_die_ref parm_die
11417 = new_die (DW_TAG_formal_parameter, context_die, node);
11418 tree origin;
11419
11420 switch (TREE_CODE_CLASS (TREE_CODE (node)))
11421 {
11422 case tcc_declaration:
11423 origin = decl_ultimate_origin (node);
11424 if (origin != NULL)
11425 add_abstract_origin_attribute (parm_die, origin);
11426 else
11427 {
11428 add_name_and_src_coords_attributes (parm_die, node);
11429 add_type_attribute (parm_die, TREE_TYPE (node),
11430 TREE_READONLY (node),
11431 TREE_THIS_VOLATILE (node),
11432 context_die);
11433 if (DECL_ARTIFICIAL (node))
11434 add_AT_flag (parm_die, DW_AT_artificial, 1);
11435 }
11436
11437 equate_decl_number_to_die (node, parm_die);
11438 if (! DECL_ABSTRACT (node))
11439 add_location_or_const_value_attribute (parm_die, node, DW_AT_location);
11440
11441 break;
11442
11443 case tcc_type:
11444 /* We were called with some kind of a ..._TYPE node. */
11445 add_type_attribute (parm_die, node, 0, 0, context_die);
11446 break;
11447
11448 default:
11449 gcc_unreachable ();
11450 }
11451
11452 return parm_die;
11453 }
11454
11455 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
11456 at the end of an (ANSI prototyped) formal parameters list. */
11457
11458 static void
gen_unspecified_parameters_die(tree decl_or_type,dw_die_ref context_die)11459 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
11460 {
11461 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
11462 }
11463
11464 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
11465 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
11466 parameters as specified in some function type specification (except for
11467 those which appear as part of a function *definition*). */
11468
11469 static void
gen_formal_types_die(tree function_or_method_type,dw_die_ref context_die)11470 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
11471 {
11472 tree link;
11473 tree formal_type = NULL;
11474 tree first_parm_type;
11475 tree arg;
11476
11477 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
11478 {
11479 arg = DECL_ARGUMENTS (function_or_method_type);
11480 function_or_method_type = TREE_TYPE (function_or_method_type);
11481 }
11482 else
11483 arg = NULL_TREE;
11484
11485 first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
11486
11487 /* Make our first pass over the list of formal parameter types and output a
11488 DW_TAG_formal_parameter DIE for each one. */
11489 for (link = first_parm_type; link; )
11490 {
11491 dw_die_ref parm_die;
11492
11493 formal_type = TREE_VALUE (link);
11494 if (formal_type == void_type_node)
11495 break;
11496
11497 /* Output a (nameless) DIE to represent the formal parameter itself. */
11498 parm_die = gen_formal_parameter_die (formal_type, context_die);
11499 if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
11500 && link == first_parm_type)
11501 || (arg && DECL_ARTIFICIAL (arg)))
11502 add_AT_flag (parm_die, DW_AT_artificial, 1);
11503
11504 link = TREE_CHAIN (link);
11505 if (arg)
11506 arg = TREE_CHAIN (arg);
11507 }
11508
11509 /* If this function type has an ellipsis, add a
11510 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
11511 if (formal_type != void_type_node)
11512 gen_unspecified_parameters_die (function_or_method_type, context_die);
11513
11514 /* Make our second (and final) pass over the list of formal parameter types
11515 and output DIEs to represent those types (as necessary). */
11516 for (link = TYPE_ARG_TYPES (function_or_method_type);
11517 link && TREE_VALUE (link);
11518 link = TREE_CHAIN (link))
11519 gen_type_die (TREE_VALUE (link), context_die);
11520 }
11521
11522 /* We want to generate the DIE for TYPE so that we can generate the
11523 die for MEMBER, which has been defined; we will need to refer back
11524 to the member declaration nested within TYPE. If we're trying to
11525 generate minimal debug info for TYPE, processing TYPE won't do the
11526 trick; we need to attach the member declaration by hand. */
11527
11528 static void
gen_type_die_for_member(tree type,tree member,dw_die_ref context_die)11529 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
11530 {
11531 gen_type_die (type, context_die);
11532
11533 /* If we're trying to avoid duplicate debug info, we may not have
11534 emitted the member decl for this function. Emit it now. */
11535 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
11536 && ! lookup_decl_die (member))
11537 {
11538 dw_die_ref type_die;
11539 gcc_assert (!decl_ultimate_origin (member));
11540
11541 push_decl_scope (type);
11542 type_die = lookup_type_die (type);
11543 if (TREE_CODE (member) == FUNCTION_DECL)
11544 gen_subprogram_die (member, type_die);
11545 else if (TREE_CODE (member) == FIELD_DECL)
11546 {
11547 /* Ignore the nameless fields that are used to skip bits but handle
11548 C++ anonymous unions and structs. */
11549 if (DECL_NAME (member) != NULL_TREE
11550 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
11551 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
11552 {
11553 gen_type_die (member_declared_type (member), type_die);
11554 gen_field_die (member, type_die);
11555 }
11556 }
11557 else
11558 gen_variable_die (member, type_die);
11559
11560 pop_decl_scope ();
11561 }
11562 }
11563
11564 /* Generate the DWARF2 info for the "abstract" instance of a function which we
11565 may later generate inlined and/or out-of-line instances of. */
11566
11567 static void
dwarf2out_abstract_function(tree decl)11568 dwarf2out_abstract_function (tree decl)
11569 {
11570 dw_die_ref old_die;
11571 tree save_fn;
11572 struct function *save_cfun;
11573 tree context;
11574 int was_abstract = DECL_ABSTRACT (decl);
11575
11576 /* Make sure we have the actual abstract inline, not a clone. */
11577 decl = DECL_ORIGIN (decl);
11578
11579 old_die = lookup_decl_die (decl);
11580 if (old_die && get_AT (old_die, DW_AT_inline))
11581 /* We've already generated the abstract instance. */
11582 return;
11583
11584 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
11585 we don't get confused by DECL_ABSTRACT. */
11586 if (debug_info_level > DINFO_LEVEL_TERSE)
11587 {
11588 context = decl_class_context (decl);
11589 if (context)
11590 gen_type_die_for_member
11591 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
11592 }
11593
11594 /* Pretend we've just finished compiling this function. */
11595 save_fn = current_function_decl;
11596 save_cfun = cfun;
11597 current_function_decl = decl;
11598 cfun = DECL_STRUCT_FUNCTION (decl);
11599
11600 set_decl_abstract_flags (decl, 1);
11601 dwarf2out_decl (decl);
11602 if (! was_abstract)
11603 set_decl_abstract_flags (decl, 0);
11604
11605 current_function_decl = save_fn;
11606 cfun = save_cfun;
11607 }
11608
11609 /* Helper function of premark_used_types() which gets called through
11610 htab_traverse_resize().
11611
11612 Marks the DIE of a given type in *SLOT as perennial, so it never gets
11613 marked as unused by prune_unused_types. */
11614 static int
premark_used_types_helper(void ** slot,void * data ATTRIBUTE_UNUSED)11615 premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED)
11616 {
11617 tree type;
11618 dw_die_ref die;
11619
11620 type = *slot;
11621 die = lookup_type_die (type);
11622 if (die != NULL)
11623 die->die_perennial_p = 1;
11624 return 1;
11625 }
11626
11627 /* Mark all members of used_types_hash as perennial. */
11628 static void
premark_used_types(void)11629 premark_used_types (void)
11630 {
11631 if (cfun && cfun->used_types_hash)
11632 htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL);
11633 }
11634
11635 /* Generate a DIE to represent a declared function (either file-scope or
11636 block-local). */
11637
11638 static void
gen_subprogram_die(tree decl,dw_die_ref context_die)11639 gen_subprogram_die (tree decl, dw_die_ref context_die)
11640 {
11641 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
11642 tree origin = decl_ultimate_origin (decl);
11643 dw_die_ref subr_die;
11644 tree fn_arg_types;
11645 tree outer_scope;
11646 dw_die_ref old_die = lookup_decl_die (decl);
11647 int declaration = (current_function_decl != decl
11648 || class_or_namespace_scope_p (context_die));
11649
11650 premark_used_types ();
11651
11652 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
11653 started to generate the abstract instance of an inline, decided to output
11654 its containing class, and proceeded to emit the declaration of the inline
11655 from the member list for the class. If so, DECLARATION takes priority;
11656 we'll get back to the abstract instance when done with the class. */
11657
11658 /* The class-scope declaration DIE must be the primary DIE. */
11659 if (origin && declaration && class_or_namespace_scope_p (context_die))
11660 {
11661 origin = NULL;
11662 gcc_assert (!old_die);
11663 }
11664
11665 /* Now that the C++ front end lazily declares artificial member fns, we
11666 might need to retrofit the declaration into its class. */
11667 if (!declaration && !origin && !old_die
11668 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
11669 && !class_or_namespace_scope_p (context_die)
11670 && debug_info_level > DINFO_LEVEL_TERSE)
11671 old_die = force_decl_die (decl);
11672
11673 if (origin != NULL)
11674 {
11675 gcc_assert (!declaration || local_scope_p (context_die));
11676
11677 /* Fixup die_parent for the abstract instance of a nested
11678 inline function. */
11679 if (old_die && old_die->die_parent == NULL)
11680 add_child_die (context_die, old_die);
11681
11682 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11683 add_abstract_origin_attribute (subr_die, origin);
11684 }
11685 else if (old_die)
11686 {
11687 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
11688 struct dwarf_file_data * file_index = lookup_filename (s.file);
11689
11690 if (!get_AT_flag (old_die, DW_AT_declaration)
11691 /* We can have a normal definition following an inline one in the
11692 case of redefinition of GNU C extern inlines.
11693 It seems reasonable to use AT_specification in this case. */
11694 && !get_AT (old_die, DW_AT_inline))
11695 {
11696 /* Detect and ignore this case, where we are trying to output
11697 something we have already output. */
11698 return;
11699 }
11700
11701 /* If the definition comes from the same place as the declaration,
11702 maybe use the old DIE. We always want the DIE for this function
11703 that has the *_pc attributes to be under comp_unit_die so the
11704 debugger can find it. We also need to do this for abstract
11705 instances of inlines, since the spec requires the out-of-line copy
11706 to have the same parent. For local class methods, this doesn't
11707 apply; we just use the old DIE. */
11708 if ((old_die->die_parent == comp_unit_die || context_die == NULL)
11709 && (DECL_ARTIFICIAL (decl)
11710 || (get_AT_file (old_die, DW_AT_decl_file) == file_index
11711 && (get_AT_unsigned (old_die, DW_AT_decl_line)
11712 == (unsigned) s.line))))
11713 {
11714 subr_die = old_die;
11715
11716 /* Clear out the declaration attribute and the formal parameters.
11717 Do not remove all children, because it is possible that this
11718 declaration die was forced using force_decl_die(). In such
11719 cases die that forced declaration die (e.g. TAG_imported_module)
11720 is one of the children that we do not want to remove. */
11721 remove_AT (subr_die, DW_AT_declaration);
11722 remove_child_TAG (subr_die, DW_TAG_formal_parameter);
11723 }
11724 else
11725 {
11726 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11727 add_AT_specification (subr_die, old_die);
11728 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
11729 add_AT_file (subr_die, DW_AT_decl_file, file_index);
11730 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
11731 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
11732 }
11733 }
11734 else
11735 {
11736 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11737
11738 if (TREE_PUBLIC (decl))
11739 add_AT_flag (subr_die, DW_AT_external, 1);
11740
11741 add_name_and_src_coords_attributes (subr_die, decl);
11742 if (debug_info_level > DINFO_LEVEL_TERSE)
11743 {
11744 add_prototyped_attribute (subr_die, TREE_TYPE (decl));
11745 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
11746 0, 0, context_die);
11747 }
11748
11749 add_pure_or_virtual_attribute (subr_die, decl);
11750 if (DECL_ARTIFICIAL (decl))
11751 add_AT_flag (subr_die, DW_AT_artificial, 1);
11752
11753 if (TREE_PROTECTED (decl))
11754 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
11755 else if (TREE_PRIVATE (decl))
11756 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
11757 }
11758
11759 if (declaration)
11760 {
11761 if (!old_die || !get_AT (old_die, DW_AT_inline))
11762 {
11763 add_AT_flag (subr_die, DW_AT_declaration, 1);
11764
11765 /* The first time we see a member function, it is in the context of
11766 the class to which it belongs. We make sure of this by emitting
11767 the class first. The next time is the definition, which is
11768 handled above. The two may come from the same source text.
11769
11770 Note that force_decl_die() forces function declaration die. It is
11771 later reused to represent definition. */
11772 equate_decl_number_to_die (decl, subr_die);
11773 }
11774 }
11775 else if (DECL_ABSTRACT (decl))
11776 {
11777 if (DECL_DECLARED_INLINE_P (decl))
11778 {
11779 if (cgraph_function_possibly_inlined_p (decl))
11780 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
11781 else
11782 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
11783 }
11784 else
11785 {
11786 if (cgraph_function_possibly_inlined_p (decl))
11787 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
11788 else
11789 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
11790 }
11791
11792 equate_decl_number_to_die (decl, subr_die);
11793 }
11794 else if (!DECL_EXTERNAL (decl))
11795 {
11796 HOST_WIDE_INT cfa_fb_offset;
11797
11798 if (!old_die || !get_AT (old_die, DW_AT_inline))
11799 equate_decl_number_to_die (decl, subr_die);
11800
11801 if (!flag_reorder_blocks_and_partition)
11802 {
11803 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
11804 current_function_funcdef_no);
11805 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
11806 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
11807 current_function_funcdef_no);
11808 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
11809
11810 add_pubname (decl, subr_die);
11811 add_arange (decl, subr_die);
11812 }
11813 else
11814 { /* Do nothing for now; maybe need to duplicate die, one for
11815 hot section and ond for cold section, then use the hot/cold
11816 section begin/end labels to generate the aranges... */
11817 /*
11818 add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
11819 add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
11820 add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
11821 add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
11822
11823 add_pubname (decl, subr_die);
11824 add_arange (decl, subr_die);
11825 add_arange (decl, subr_die);
11826 */
11827 }
11828
11829 #ifdef MIPS_DEBUGGING_INFO
11830 /* Add a reference to the FDE for this routine. */
11831 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
11832 #endif
11833
11834 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
11835
11836 /* We define the "frame base" as the function's CFA. This is more
11837 convenient for several reasons: (1) It's stable across the prologue
11838 and epilogue, which makes it better than just a frame pointer,
11839 (2) With dwarf3, there exists a one-byte encoding that allows us
11840 to reference the .debug_frame data by proxy, but failing that,
11841 (3) We can at least reuse the code inspection and interpretation
11842 code that determines the CFA position at various points in the
11843 function. */
11844 /* ??? Use some command-line or configury switch to enable the use
11845 of dwarf3 DW_OP_call_frame_cfa. At present there are no dwarf
11846 consumers that understand it; fall back to "pure" dwarf2 and
11847 convert the CFA data into a location list. */
11848 {
11849 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
11850 if (list->dw_loc_next)
11851 add_AT_loc_list (subr_die, DW_AT_frame_base, list);
11852 else
11853 add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
11854 }
11855
11856 /* Compute a displacement from the "steady-state frame pointer" to
11857 the CFA. The former is what all stack slots and argument slots
11858 will reference in the rtl; the later is what we've told the
11859 debugger about. We'll need to adjust all frame_base references
11860 by this displacement. */
11861 compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
11862
11863 if (cfun->static_chain_decl)
11864 add_AT_location_description (subr_die, DW_AT_static_link,
11865 loc_descriptor_from_tree (cfun->static_chain_decl));
11866 }
11867
11868 /* Now output descriptions of the arguments for this function. This gets
11869 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
11870 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
11871 `...' at the end of the formal parameter list. In order to find out if
11872 there was a trailing ellipsis or not, we must instead look at the type
11873 associated with the FUNCTION_DECL. This will be a node of type
11874 FUNCTION_TYPE. If the chain of type nodes hanging off of this
11875 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
11876 an ellipsis at the end. */
11877
11878 /* In the case where we are describing a mere function declaration, all we
11879 need to do here (and all we *can* do here) is to describe the *types* of
11880 its formal parameters. */
11881 if (debug_info_level <= DINFO_LEVEL_TERSE)
11882 ;
11883 else if (declaration)
11884 gen_formal_types_die (decl, subr_die);
11885 else
11886 {
11887 /* Generate DIEs to represent all known formal parameters. */
11888 tree arg_decls = DECL_ARGUMENTS (decl);
11889 tree parm;
11890
11891 /* When generating DIEs, generate the unspecified_parameters DIE
11892 instead if we come across the arg "__builtin_va_alist" */
11893 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
11894 if (TREE_CODE (parm) == PARM_DECL)
11895 {
11896 if (DECL_NAME (parm)
11897 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
11898 "__builtin_va_alist"))
11899 gen_unspecified_parameters_die (parm, subr_die);
11900 else
11901 gen_decl_die (parm, subr_die);
11902 }
11903
11904 /* Decide whether we need an unspecified_parameters DIE at the end.
11905 There are 2 more cases to do this for: 1) the ansi ... declaration -
11906 this is detectable when the end of the arg list is not a
11907 void_type_node 2) an unprototyped function declaration (not a
11908 definition). This just means that we have no info about the
11909 parameters at all. */
11910 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
11911 if (fn_arg_types != NULL)
11912 {
11913 /* This is the prototyped case, check for.... */
11914 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
11915 gen_unspecified_parameters_die (decl, subr_die);
11916 }
11917 else if (DECL_INITIAL (decl) == NULL_TREE)
11918 gen_unspecified_parameters_die (decl, subr_die);
11919 }
11920
11921 /* Output Dwarf info for all of the stuff within the body of the function
11922 (if it has one - it may be just a declaration). */
11923 outer_scope = DECL_INITIAL (decl);
11924
11925 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
11926 a function. This BLOCK actually represents the outermost binding contour
11927 for the function, i.e. the contour in which the function's formal
11928 parameters and labels get declared. Curiously, it appears that the front
11929 end doesn't actually put the PARM_DECL nodes for the current function onto
11930 the BLOCK_VARS list for this outer scope, but are strung off of the
11931 DECL_ARGUMENTS list for the function instead.
11932
11933 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
11934 the LABEL_DECL nodes for the function however, and we output DWARF info
11935 for those in decls_for_scope. Just within the `outer_scope' there will be
11936 a BLOCK node representing the function's outermost pair of curly braces,
11937 and any blocks used for the base and member initializers of a C++
11938 constructor function. */
11939 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
11940 {
11941 /* Emit a DW_TAG_variable DIE for a named return value. */
11942 if (DECL_NAME (DECL_RESULT (decl)))
11943 gen_decl_die (DECL_RESULT (decl), subr_die);
11944
11945 current_function_has_inlines = 0;
11946 decls_for_scope (outer_scope, subr_die, 0);
11947
11948 #if 0 && defined (MIPS_DEBUGGING_INFO)
11949 if (current_function_has_inlines)
11950 {
11951 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
11952 if (! comp_unit_has_inlines)
11953 {
11954 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
11955 comp_unit_has_inlines = 1;
11956 }
11957 }
11958 #endif
11959 }
11960 /* Add the calling convention attribute if requested. */
11961 add_calling_convention_attribute (subr_die, TREE_TYPE (decl));
11962
11963 #ifdef TARGET_SAVE_ARGS
11964 if (TARGET_SAVE_ARGS)
11965 add_AT_flag (subr_die, DW_AT_SUN_amd64_parmdump, 1);
11966 #endif
11967 }
11968
11969 /* Generate a DIE to represent a declared data object. */
11970
11971 static void
gen_variable_die(tree decl,dw_die_ref context_die)11972 gen_variable_die (tree decl, dw_die_ref context_die)
11973 {
11974 tree origin = decl_ultimate_origin (decl);
11975 dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl);
11976
11977 dw_die_ref old_die = lookup_decl_die (decl);
11978 int declaration = (DECL_EXTERNAL (decl)
11979 /* If DECL is COMDAT and has not actually been
11980 emitted, we cannot take its address; there
11981 might end up being no definition anywhere in
11982 the program. For example, consider the C++
11983 test case:
11984
11985 template <class T>
11986 struct S { static const int i = 7; };
11987
11988 template <class T>
11989 const int S<T>::i;
11990
11991 int f() { return S<int>::i; }
11992
11993 Here, S<int>::i is not DECL_EXTERNAL, but no
11994 definition is required, so the compiler will
11995 not emit a definition. */
11996 || (TREE_CODE (decl) == VAR_DECL
11997 && DECL_COMDAT (decl) && !TREE_ASM_WRITTEN (decl))
11998 || class_or_namespace_scope_p (context_die));
11999
12000 if (origin != NULL)
12001 add_abstract_origin_attribute (var_die, origin);
12002
12003 /* Loop unrolling can create multiple blocks that refer to the same
12004 static variable, so we must test for the DW_AT_declaration flag.
12005
12006 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
12007 copy decls and set the DECL_ABSTRACT flag on them instead of
12008 sharing them.
12009
12010 ??? Duplicated blocks have been rewritten to use .debug_ranges.
12011
12012 ??? The declare_in_namespace support causes us to get two DIEs for one
12013 variable, both of which are declarations. We want to avoid considering
12014 one to be a specification, so we must test that this DIE is not a
12015 declaration. */
12016 else if (old_die && TREE_STATIC (decl) && ! declaration
12017 && get_AT_flag (old_die, DW_AT_declaration) == 1)
12018 {
12019 /* This is a definition of a C++ class level static. */
12020 add_AT_specification (var_die, old_die);
12021 if (DECL_NAME (decl))
12022 {
12023 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
12024 struct dwarf_file_data * file_index = lookup_filename (s.file);
12025
12026 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
12027 add_AT_file (var_die, DW_AT_decl_file, file_index);
12028
12029 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
12030
12031 add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
12032 }
12033 }
12034 else
12035 {
12036 add_name_and_src_coords_attributes (var_die, decl);
12037 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
12038 TREE_THIS_VOLATILE (decl), context_die);
12039
12040 if (TREE_PUBLIC (decl))
12041 add_AT_flag (var_die, DW_AT_external, 1);
12042
12043 if (DECL_ARTIFICIAL (decl))
12044 add_AT_flag (var_die, DW_AT_artificial, 1);
12045
12046 if (TREE_PROTECTED (decl))
12047 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
12048 else if (TREE_PRIVATE (decl))
12049 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
12050 }
12051
12052 if (declaration)
12053 add_AT_flag (var_die, DW_AT_declaration, 1);
12054
12055 if (DECL_ABSTRACT (decl) || declaration)
12056 equate_decl_number_to_die (decl, var_die);
12057
12058 if (! declaration && ! DECL_ABSTRACT (decl))
12059 {
12060 add_location_or_const_value_attribute (var_die, decl, DW_AT_location);
12061 add_pubname (decl, var_die);
12062 }
12063 else
12064 tree_add_const_value_attribute (var_die, decl);
12065 }
12066
12067 /* Generate a DIE to represent a label identifier. */
12068
12069 static void
gen_label_die(tree decl,dw_die_ref context_die)12070 gen_label_die (tree decl, dw_die_ref context_die)
12071 {
12072 tree origin = decl_ultimate_origin (decl);
12073 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
12074 rtx insn;
12075 char label[MAX_ARTIFICIAL_LABEL_BYTES];
12076
12077 if (origin != NULL)
12078 add_abstract_origin_attribute (lbl_die, origin);
12079 else
12080 add_name_and_src_coords_attributes (lbl_die, decl);
12081
12082 if (DECL_ABSTRACT (decl))
12083 equate_decl_number_to_die (decl, lbl_die);
12084 else
12085 {
12086 insn = DECL_RTL_IF_SET (decl);
12087
12088 /* Deleted labels are programmer specified labels which have been
12089 eliminated because of various optimizations. We still emit them
12090 here so that it is possible to put breakpoints on them. */
12091 if (insn
12092 && (LABEL_P (insn)
12093 || ((NOTE_P (insn)
12094 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL))))
12095 {
12096 /* When optimization is enabled (via -O) some parts of the compiler
12097 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
12098 represent source-level labels which were explicitly declared by
12099 the user. This really shouldn't be happening though, so catch
12100 it if it ever does happen. */
12101 gcc_assert (!INSN_DELETED_P (insn));
12102
12103 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
12104 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
12105 }
12106 }
12107 }
12108
12109 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
12110 attributes to the DIE for a block STMT, to describe where the inlined
12111 function was called from. This is similar to add_src_coords_attributes. */
12112
12113 static inline void
add_call_src_coords_attributes(tree stmt,dw_die_ref die)12114 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
12115 {
12116 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
12117
12118 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
12119 add_AT_unsigned (die, DW_AT_call_line, s.line);
12120 }
12121
12122 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
12123 Add low_pc and high_pc attributes to the DIE for a block STMT. */
12124
12125 static inline void
add_high_low_attributes(tree stmt,dw_die_ref die)12126 add_high_low_attributes (tree stmt, dw_die_ref die)
12127 {
12128 char label[MAX_ARTIFICIAL_LABEL_BYTES];
12129
12130 if (BLOCK_FRAGMENT_CHAIN (stmt))
12131 {
12132 tree chain;
12133
12134 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
12135
12136 chain = BLOCK_FRAGMENT_CHAIN (stmt);
12137 do
12138 {
12139 add_ranges (chain);
12140 chain = BLOCK_FRAGMENT_CHAIN (chain);
12141 }
12142 while (chain);
12143 add_ranges (NULL);
12144 }
12145 else
12146 {
12147 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
12148 BLOCK_NUMBER (stmt));
12149 add_AT_lbl_id (die, DW_AT_low_pc, label);
12150 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
12151 BLOCK_NUMBER (stmt));
12152 add_AT_lbl_id (die, DW_AT_high_pc, label);
12153 }
12154 }
12155
12156 /* Generate a DIE for a lexical block. */
12157
12158 static void
gen_lexical_block_die(tree stmt,dw_die_ref context_die,int depth)12159 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
12160 {
12161 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
12162
12163 if (! BLOCK_ABSTRACT (stmt))
12164 add_high_low_attributes (stmt, stmt_die);
12165
12166 decls_for_scope (stmt, stmt_die, depth);
12167 }
12168
12169 /* Generate a DIE for an inlined subprogram. */
12170
12171 static void
gen_inlined_subroutine_die(tree stmt,dw_die_ref context_die,int depth)12172 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
12173 {
12174 tree decl = block_ultimate_origin (stmt);
12175
12176 /* Emit info for the abstract instance first, if we haven't yet. We
12177 must emit this even if the block is abstract, otherwise when we
12178 emit the block below (or elsewhere), we may end up trying to emit
12179 a die whose origin die hasn't been emitted, and crashing. */
12180 dwarf2out_abstract_function (decl);
12181
12182 if (! BLOCK_ABSTRACT (stmt))
12183 {
12184 dw_die_ref subr_die
12185 = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
12186
12187 add_abstract_origin_attribute (subr_die, decl);
12188 add_high_low_attributes (stmt, subr_die);
12189 add_call_src_coords_attributes (stmt, subr_die);
12190
12191 decls_for_scope (stmt, subr_die, depth);
12192 current_function_has_inlines = 1;
12193 }
12194 else
12195 /* We may get here if we're the outer block of function A that was
12196 inlined into function B that was inlined into function C. When
12197 generating debugging info for C, dwarf2out_abstract_function(B)
12198 would mark all inlined blocks as abstract, including this one.
12199 So, we wouldn't (and shouldn't) expect labels to be generated
12200 for this one. Instead, just emit debugging info for
12201 declarations within the block. This is particularly important
12202 in the case of initializers of arguments passed from B to us:
12203 if they're statement expressions containing declarations, we
12204 wouldn't generate dies for their abstract variables, and then,
12205 when generating dies for the real variables, we'd die (pun
12206 intended :-) */
12207 gen_lexical_block_die (stmt, context_die, depth);
12208 }
12209
12210 /* Generate a DIE for a field in a record, or structure. */
12211
12212 static void
gen_field_die(tree decl,dw_die_ref context_die)12213 gen_field_die (tree decl, dw_die_ref context_die)
12214 {
12215 dw_die_ref decl_die;
12216
12217 if (TREE_TYPE (decl) == error_mark_node)
12218 return;
12219
12220 decl_die = new_die (DW_TAG_member, context_die, decl);
12221 add_name_and_src_coords_attributes (decl_die, decl);
12222 add_type_attribute (decl_die, member_declared_type (decl),
12223 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
12224 context_die);
12225
12226 if (DECL_BIT_FIELD_TYPE (decl))
12227 {
12228 add_byte_size_attribute (decl_die, decl);
12229 add_bit_size_attribute (decl_die, decl);
12230 add_bit_offset_attribute (decl_die, decl);
12231 }
12232
12233 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
12234 add_data_member_location_attribute (decl_die, decl);
12235
12236 if (DECL_ARTIFICIAL (decl))
12237 add_AT_flag (decl_die, DW_AT_artificial, 1);
12238
12239 if (TREE_PROTECTED (decl))
12240 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
12241 else if (TREE_PRIVATE (decl))
12242 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
12243
12244 /* Equate decl number to die, so that we can look up this decl later on. */
12245 equate_decl_number_to_die (decl, decl_die);
12246 }
12247
12248 #if 0
12249 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
12250 Use modified_type_die instead.
12251 We keep this code here just in case these types of DIEs may be needed to
12252 represent certain things in other languages (e.g. Pascal) someday. */
12253
12254 static void
12255 gen_pointer_type_die (tree type, dw_die_ref context_die)
12256 {
12257 dw_die_ref ptr_die
12258 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
12259
12260 equate_type_number_to_die (type, ptr_die);
12261 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12262 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12263 }
12264
12265 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
12266 Use modified_type_die instead.
12267 We keep this code here just in case these types of DIEs may be needed to
12268 represent certain things in other languages (e.g. Pascal) someday. */
12269
12270 static void
12271 gen_reference_type_die (tree type, dw_die_ref context_die)
12272 {
12273 dw_die_ref ref_die
12274 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
12275
12276 equate_type_number_to_die (type, ref_die);
12277 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
12278 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12279 }
12280 #endif
12281
12282 /* Generate a DIE for a pointer to a member type. */
12283
12284 static void
gen_ptr_to_mbr_type_die(tree type,dw_die_ref context_die)12285 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
12286 {
12287 dw_die_ref ptr_die
12288 = new_die (DW_TAG_ptr_to_member_type,
12289 scope_die_for (type, context_die), type);
12290
12291 equate_type_number_to_die (type, ptr_die);
12292 add_AT_die_ref (ptr_die, DW_AT_containing_type,
12293 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
12294 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12295 }
12296
12297 /* Generate the DIE for the compilation unit. */
12298
12299 static dw_die_ref
gen_compile_unit_die(const char * filename)12300 gen_compile_unit_die (const char *filename)
12301 {
12302 dw_die_ref die;
12303 char producer[250];
12304 const char *language_string = lang_hooks.name;
12305 int language;
12306
12307 die = new_die (DW_TAG_compile_unit, NULL, NULL);
12308
12309 if (filename)
12310 {
12311 add_name_attribute (die, filename);
12312 /* Don't add cwd for <built-in>. */
12313 if (filename[0] != DIR_SEPARATOR && filename[0] != '<')
12314 add_comp_dir_attribute (die);
12315 }
12316
12317 sprintf (producer, "%s %s", language_string, version_string);
12318
12319 #ifdef MIPS_DEBUGGING_INFO
12320 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
12321 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
12322 not appear in the producer string, the debugger reaches the conclusion
12323 that the object file is stripped and has no debugging information.
12324 To get the MIPS/SGI debugger to believe that there is debugging
12325 information in the object file, we add a -g to the producer string. */
12326 if (debug_info_level > DINFO_LEVEL_TERSE)
12327 strcat (producer, " -g");
12328 #endif
12329
12330 add_AT_string (die, DW_AT_producer, producer);
12331
12332 if (strcmp (language_string, "GNU C++") == 0)
12333 language = DW_LANG_C_plus_plus;
12334 else if (strcmp (language_string, "GNU Ada") == 0)
12335 language = DW_LANG_Ada95;
12336 else if (strcmp (language_string, "GNU F77") == 0)
12337 language = DW_LANG_Fortran77;
12338 else if (strcmp (language_string, "GNU F95") == 0)
12339 language = DW_LANG_Fortran95;
12340 else if (strcmp (language_string, "GNU Pascal") == 0)
12341 language = DW_LANG_Pascal83;
12342 else if (strcmp (language_string, "GNU Java") == 0)
12343 language = DW_LANG_Java;
12344 else if (strcmp (language_string, "GNU Objective-C") == 0)
12345 language = DW_LANG_ObjC;
12346 else if (strcmp (language_string, "GNU Objective-C++") == 0)
12347 language = DW_LANG_ObjC_plus_plus;
12348 else
12349 language = DW_LANG_C89;
12350
12351 add_AT_unsigned (die, DW_AT_language, language);
12352 return die;
12353 }
12354
12355 /* Generate the DIE for a base class. */
12356
12357 static void
gen_inheritance_die(tree binfo,tree access,dw_die_ref context_die)12358 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
12359 {
12360 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
12361
12362 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
12363 add_data_member_location_attribute (die, binfo);
12364
12365 if (BINFO_VIRTUAL_P (binfo))
12366 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
12367
12368 if (access == access_public_node)
12369 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
12370 else if (access == access_protected_node)
12371 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
12372 }
12373
12374 /* Generate a DIE for a class member. */
12375
12376 static void
gen_member_die(tree type,dw_die_ref context_die)12377 gen_member_die (tree type, dw_die_ref context_die)
12378 {
12379 tree member;
12380 tree binfo = TYPE_BINFO (type);
12381 dw_die_ref child;
12382
12383 /* If this is not an incomplete type, output descriptions of each of its
12384 members. Note that as we output the DIEs necessary to represent the
12385 members of this record or union type, we will also be trying to output
12386 DIEs to represent the *types* of those members. However the `type'
12387 function (above) will specifically avoid generating type DIEs for member
12388 types *within* the list of member DIEs for this (containing) type except
12389 for those types (of members) which are explicitly marked as also being
12390 members of this (containing) type themselves. The g++ front- end can
12391 force any given type to be treated as a member of some other (containing)
12392 type by setting the TYPE_CONTEXT of the given (member) type to point to
12393 the TREE node representing the appropriate (containing) type. */
12394
12395 /* First output info about the base classes. */
12396 if (binfo)
12397 {
12398 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
12399 int i;
12400 tree base;
12401
12402 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
12403 gen_inheritance_die (base,
12404 (accesses ? VEC_index (tree, accesses, i)
12405 : access_public_node), context_die);
12406 }
12407
12408 /* Now output info about the data members and type members. */
12409 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
12410 {
12411 /* If we thought we were generating minimal debug info for TYPE
12412 and then changed our minds, some of the member declarations
12413 may have already been defined. Don't define them again, but
12414 do put them in the right order. */
12415
12416 child = lookup_decl_die (member);
12417 if (child)
12418 splice_child_die (context_die, child);
12419 else
12420 gen_decl_die (member, context_die);
12421 }
12422
12423 /* Now output info about the function members (if any). */
12424 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
12425 {
12426 /* Don't include clones in the member list. */
12427 if (DECL_ABSTRACT_ORIGIN (member))
12428 continue;
12429
12430 child = lookup_decl_die (member);
12431 if (child)
12432 splice_child_die (context_die, child);
12433 else
12434 gen_decl_die (member, context_die);
12435 }
12436 }
12437
12438 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
12439 is set, we pretend that the type was never defined, so we only get the
12440 member DIEs needed by later specification DIEs. */
12441
12442 static void
gen_struct_or_union_type_die(tree type,dw_die_ref context_die)12443 gen_struct_or_union_type_die (tree type, dw_die_ref context_die)
12444 {
12445 dw_die_ref type_die = lookup_type_die (type);
12446 dw_die_ref scope_die = 0;
12447 int nested = 0;
12448 int complete = (TYPE_SIZE (type)
12449 && (! TYPE_STUB_DECL (type)
12450 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
12451 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
12452
12453 if (type_die && ! complete)
12454 return;
12455
12456 if (TYPE_CONTEXT (type) != NULL_TREE
12457 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12458 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
12459 nested = 1;
12460
12461 scope_die = scope_die_for (type, context_die);
12462
12463 if (! type_die || (nested && scope_die == comp_unit_die))
12464 /* First occurrence of type or toplevel definition of nested class. */
12465 {
12466 dw_die_ref old_die = type_die;
12467
12468 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
12469 ? DW_TAG_structure_type : DW_TAG_union_type,
12470 scope_die, type);
12471 equate_type_number_to_die (type, type_die);
12472 if (old_die)
12473 add_AT_specification (type_die, old_die);
12474 else
12475 add_name_attribute (type_die, type_tag (type));
12476 }
12477 else
12478 remove_AT (type_die, DW_AT_declaration);
12479
12480 /* If this type has been completed, then give it a byte_size attribute and
12481 then give a list of members. */
12482 if (complete && !ns_decl)
12483 {
12484 /* Prevent infinite recursion in cases where the type of some member of
12485 this type is expressed in terms of this type itself. */
12486 TREE_ASM_WRITTEN (type) = 1;
12487 add_byte_size_attribute (type_die, type);
12488 if (TYPE_STUB_DECL (type) != NULL_TREE)
12489 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
12490
12491 /* If the first reference to this type was as the return type of an
12492 inline function, then it may not have a parent. Fix this now. */
12493 if (type_die->die_parent == NULL)
12494 add_child_die (scope_die, type_die);
12495
12496 push_decl_scope (type);
12497 gen_member_die (type, type_die);
12498 pop_decl_scope ();
12499
12500 /* GNU extension: Record what type our vtable lives in. */
12501 if (TYPE_VFIELD (type))
12502 {
12503 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
12504
12505 gen_type_die (vtype, context_die);
12506 add_AT_die_ref (type_die, DW_AT_containing_type,
12507 lookup_type_die (vtype));
12508 }
12509 }
12510 else
12511 {
12512 add_AT_flag (type_die, DW_AT_declaration, 1);
12513
12514 /* We don't need to do this for function-local types. */
12515 if (TYPE_STUB_DECL (type)
12516 && ! decl_function_context (TYPE_STUB_DECL (type)))
12517 VEC_safe_push (tree, gc, incomplete_types, type);
12518 }
12519 }
12520
12521 /* Generate a DIE for a subroutine _type_. */
12522
12523 static void
gen_subroutine_type_die(tree type,dw_die_ref context_die)12524 gen_subroutine_type_die (tree type, dw_die_ref context_die)
12525 {
12526 tree return_type = TREE_TYPE (type);
12527 dw_die_ref subr_die
12528 = new_die (DW_TAG_subroutine_type,
12529 scope_die_for (type, context_die), type);
12530
12531 equate_type_number_to_die (type, subr_die);
12532 add_prototyped_attribute (subr_die, type);
12533 add_type_attribute (subr_die, return_type, 0, 0, context_die);
12534 gen_formal_types_die (type, subr_die);
12535 }
12536
12537 /* Generate a DIE for a type definition. */
12538
12539 static void
gen_typedef_die(tree decl,dw_die_ref context_die)12540 gen_typedef_die (tree decl, dw_die_ref context_die)
12541 {
12542 dw_die_ref type_die;
12543 tree origin;
12544
12545 if (TREE_ASM_WRITTEN (decl))
12546 return;
12547
12548 TREE_ASM_WRITTEN (decl) = 1;
12549 type_die = new_die (DW_TAG_typedef, context_die, decl);
12550 origin = decl_ultimate_origin (decl);
12551 if (origin != NULL)
12552 add_abstract_origin_attribute (type_die, origin);
12553 else
12554 {
12555 tree type;
12556
12557 add_name_and_src_coords_attributes (type_die, decl);
12558 if (DECL_ORIGINAL_TYPE (decl))
12559 {
12560 type = DECL_ORIGINAL_TYPE (decl);
12561
12562 gcc_assert (type != TREE_TYPE (decl));
12563 equate_type_number_to_die (TREE_TYPE (decl), type_die);
12564 }
12565 else
12566 type = TREE_TYPE (decl);
12567
12568 add_type_attribute (type_die, type, TREE_READONLY (decl),
12569 TREE_THIS_VOLATILE (decl), context_die);
12570 }
12571
12572 if (DECL_ABSTRACT (decl))
12573 equate_decl_number_to_die (decl, type_die);
12574 }
12575
12576 /* Generate a type description DIE. */
12577
12578 static void
gen_type_die(tree type,dw_die_ref context_die)12579 gen_type_die (tree type, dw_die_ref context_die)
12580 {
12581 int need_pop;
12582
12583 if (type == NULL_TREE || type == error_mark_node)
12584 return;
12585
12586 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12587 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
12588 {
12589 if (TREE_ASM_WRITTEN (type))
12590 return;
12591
12592 /* Prevent broken recursion; we can't hand off to the same type. */
12593 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
12594
12595 TREE_ASM_WRITTEN (type) = 1;
12596 gen_decl_die (TYPE_NAME (type), context_die);
12597 return;
12598 }
12599
12600 /* We are going to output a DIE to represent the unqualified version
12601 of this type (i.e. without any const or volatile qualifiers) so
12602 get the main variant (i.e. the unqualified version) of this type
12603 now. (Vectors are special because the debugging info is in the
12604 cloned type itself). */
12605 if (TREE_CODE (type) != VECTOR_TYPE)
12606 type = type_main_variant (type);
12607
12608 if (TREE_ASM_WRITTEN (type))
12609 return;
12610
12611 switch (TREE_CODE (type))
12612 {
12613 case ERROR_MARK:
12614 break;
12615
12616 case POINTER_TYPE:
12617 case REFERENCE_TYPE:
12618 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
12619 ensures that the gen_type_die recursion will terminate even if the
12620 type is recursive. Recursive types are possible in Ada. */
12621 /* ??? We could perhaps do this for all types before the switch
12622 statement. */
12623 TREE_ASM_WRITTEN (type) = 1;
12624
12625 /* For these types, all that is required is that we output a DIE (or a
12626 set of DIEs) to represent the "basis" type. */
12627 gen_type_die (TREE_TYPE (type), context_die);
12628 break;
12629
12630 case OFFSET_TYPE:
12631 /* This code is used for C++ pointer-to-data-member types.
12632 Output a description of the relevant class type. */
12633 gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
12634
12635 /* Output a description of the type of the object pointed to. */
12636 gen_type_die (TREE_TYPE (type), context_die);
12637
12638 /* Now output a DIE to represent this pointer-to-data-member type
12639 itself. */
12640 gen_ptr_to_mbr_type_die (type, context_die);
12641 break;
12642
12643 case FUNCTION_TYPE:
12644 /* Force out return type (in case it wasn't forced out already). */
12645 gen_type_die (TREE_TYPE (type), context_die);
12646 gen_subroutine_type_die (type, context_die);
12647 break;
12648
12649 case METHOD_TYPE:
12650 /* Force out return type (in case it wasn't forced out already). */
12651 gen_type_die (TREE_TYPE (type), context_die);
12652 gen_subroutine_type_die (type, context_die);
12653 break;
12654
12655 case ARRAY_TYPE:
12656 gen_array_type_die (type, context_die);
12657 break;
12658
12659 case VECTOR_TYPE:
12660 gen_array_type_die (type, context_die);
12661 break;
12662
12663 case ENUMERAL_TYPE:
12664 case RECORD_TYPE:
12665 case UNION_TYPE:
12666 case QUAL_UNION_TYPE:
12667 /* If this is a nested type whose containing class hasn't been written
12668 out yet, writing it out will cover this one, too. This does not apply
12669 to instantiations of member class templates; they need to be added to
12670 the containing class as they are generated. FIXME: This hurts the
12671 idea of combining type decls from multiple TUs, since we can't predict
12672 what set of template instantiations we'll get. */
12673 if (TYPE_CONTEXT (type)
12674 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12675 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
12676 {
12677 gen_type_die (TYPE_CONTEXT (type), context_die);
12678
12679 if (TREE_ASM_WRITTEN (type))
12680 return;
12681
12682 /* If that failed, attach ourselves to the stub. */
12683 push_decl_scope (TYPE_CONTEXT (type));
12684 context_die = lookup_type_die (TYPE_CONTEXT (type));
12685 need_pop = 1;
12686 }
12687 else
12688 {
12689 declare_in_namespace (type, context_die);
12690 need_pop = 0;
12691 }
12692
12693 if (TREE_CODE (type) == ENUMERAL_TYPE)
12694 {
12695 /* This might have been written out by the call to
12696 declare_in_namespace. */
12697 if (!TREE_ASM_WRITTEN (type))
12698 gen_enumeration_type_die (type, context_die);
12699 }
12700 else
12701 gen_struct_or_union_type_die (type, context_die);
12702
12703 if (need_pop)
12704 pop_decl_scope ();
12705
12706 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
12707 it up if it is ever completed. gen_*_type_die will set it for us
12708 when appropriate. */
12709 return;
12710
12711 case VOID_TYPE:
12712 case INTEGER_TYPE:
12713 case REAL_TYPE:
12714 case COMPLEX_TYPE:
12715 case BOOLEAN_TYPE:
12716 /* No DIEs needed for fundamental types. */
12717 break;
12718
12719 case LANG_TYPE:
12720 /* No Dwarf representation currently defined. */
12721 break;
12722
12723 default:
12724 gcc_unreachable ();
12725 }
12726
12727 TREE_ASM_WRITTEN (type) = 1;
12728 }
12729
12730 /* Generate a DIE for a tagged type instantiation. */
12731
12732 static void
gen_tagged_type_instantiation_die(tree type,dw_die_ref context_die)12733 gen_tagged_type_instantiation_die (tree type, dw_die_ref context_die)
12734 {
12735 if (type == NULL_TREE || type == error_mark_node)
12736 return;
12737
12738 /* We are going to output a DIE to represent the unqualified version of
12739 this type (i.e. without any const or volatile qualifiers) so make sure
12740 that we have the main variant (i.e. the unqualified version) of this
12741 type now. */
12742 gcc_assert (type == type_main_variant (type));
12743
12744 /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
12745 an instance of an unresolved type. */
12746
12747 switch (TREE_CODE (type))
12748 {
12749 case ERROR_MARK:
12750 break;
12751
12752 case ENUMERAL_TYPE:
12753 gen_inlined_enumeration_type_die (type, context_die);
12754 break;
12755
12756 case RECORD_TYPE:
12757 gen_inlined_structure_type_die (type, context_die);
12758 break;
12759
12760 case UNION_TYPE:
12761 case QUAL_UNION_TYPE:
12762 gen_inlined_union_type_die (type, context_die);
12763 break;
12764
12765 default:
12766 gcc_unreachable ();
12767 }
12768 }
12769
12770 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
12771 things which are local to the given block. */
12772
12773 static void
gen_block_die(tree stmt,dw_die_ref context_die,int depth)12774 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
12775 {
12776 int must_output_die = 0;
12777 tree origin;
12778 tree decl;
12779 enum tree_code origin_code;
12780
12781 /* Ignore blocks that are NULL. */
12782 if (stmt == NULL_TREE)
12783 return;
12784
12785 /* If the block is one fragment of a non-contiguous block, do not
12786 process the variables, since they will have been done by the
12787 origin block. Do process subblocks. */
12788 if (BLOCK_FRAGMENT_ORIGIN (stmt))
12789 {
12790 tree sub;
12791
12792 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
12793 gen_block_die (sub, context_die, depth + 1);
12794
12795 return;
12796 }
12797
12798 /* Determine the "ultimate origin" of this block. This block may be an
12799 inlined instance of an inlined instance of inline function, so we have
12800 to trace all of the way back through the origin chain to find out what
12801 sort of node actually served as the original seed for the creation of
12802 the current block. */
12803 origin = block_ultimate_origin (stmt);
12804 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
12805
12806 /* Determine if we need to output any Dwarf DIEs at all to represent this
12807 block. */
12808 if (origin_code == FUNCTION_DECL)
12809 /* The outer scopes for inlinings *must* always be represented. We
12810 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
12811 must_output_die = 1;
12812 else
12813 {
12814 /* In the case where the current block represents an inlining of the
12815 "body block" of an inline function, we must *NOT* output any DIE for
12816 this block because we have already output a DIE to represent the whole
12817 inlined function scope and the "body block" of any function doesn't
12818 really represent a different scope according to ANSI C rules. So we
12819 check here to make sure that this block does not represent a "body
12820 block inlining" before trying to set the MUST_OUTPUT_DIE flag. */
12821 if (! is_body_block (origin ? origin : stmt))
12822 {
12823 /* Determine if this block directly contains any "significant"
12824 local declarations which we will need to output DIEs for. */
12825 if (debug_info_level > DINFO_LEVEL_TERSE)
12826 /* We are not in terse mode so *any* local declaration counts
12827 as being a "significant" one. */
12828 must_output_die = (BLOCK_VARS (stmt) != NULL
12829 && (TREE_USED (stmt)
12830 || TREE_ASM_WRITTEN (stmt)
12831 || BLOCK_ABSTRACT (stmt)));
12832 else
12833 /* We are in terse mode, so only local (nested) function
12834 definitions count as "significant" local declarations. */
12835 for (decl = BLOCK_VARS (stmt);
12836 decl != NULL; decl = TREE_CHAIN (decl))
12837 if (TREE_CODE (decl) == FUNCTION_DECL
12838 && DECL_INITIAL (decl))
12839 {
12840 must_output_die = 1;
12841 break;
12842 }
12843 }
12844 }
12845
12846 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
12847 DIE for any block which contains no significant local declarations at
12848 all. Rather, in such cases we just call `decls_for_scope' so that any
12849 needed Dwarf info for any sub-blocks will get properly generated. Note
12850 that in terse mode, our definition of what constitutes a "significant"
12851 local declaration gets restricted to include only inlined function
12852 instances and local (nested) function definitions. */
12853 if (must_output_die)
12854 {
12855 if (origin_code == FUNCTION_DECL)
12856 gen_inlined_subroutine_die (stmt, context_die, depth);
12857 else
12858 gen_lexical_block_die (stmt, context_die, depth);
12859 }
12860 else
12861 decls_for_scope (stmt, context_die, depth);
12862 }
12863
12864 /* Generate all of the decls declared within a given scope and (recursively)
12865 all of its sub-blocks. */
12866
12867 static void
decls_for_scope(tree stmt,dw_die_ref context_die,int depth)12868 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
12869 {
12870 tree decl;
12871 tree subblocks;
12872
12873 /* Ignore NULL blocks. */
12874 if (stmt == NULL_TREE)
12875 return;
12876
12877 if (TREE_USED (stmt))
12878 {
12879 /* Output the DIEs to represent all of the data objects and typedefs
12880 declared directly within this block but not within any nested
12881 sub-blocks. Also, nested function and tag DIEs have been
12882 generated with a parent of NULL; fix that up now. */
12883 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
12884 {
12885 dw_die_ref die;
12886
12887 if (TREE_CODE (decl) == FUNCTION_DECL)
12888 die = lookup_decl_die (decl);
12889 else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
12890 die = lookup_type_die (TREE_TYPE (decl));
12891 else
12892 die = NULL;
12893
12894 if (die != NULL && die->die_parent == NULL)
12895 add_child_die (context_die, die);
12896 /* Do not produce debug information for static variables since
12897 these might be optimized out. We are called for these later
12898 in cgraph_varpool_analyze_pending_decls. */
12899 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
12900 ;
12901 else
12902 gen_decl_die (decl, context_die);
12903 }
12904 }
12905
12906 /* If we're at -g1, we're not interested in subblocks. */
12907 if (debug_info_level <= DINFO_LEVEL_TERSE)
12908 return;
12909
12910 /* Output the DIEs to represent all sub-blocks (and the items declared
12911 therein) of this block. */
12912 for (subblocks = BLOCK_SUBBLOCKS (stmt);
12913 subblocks != NULL;
12914 subblocks = BLOCK_CHAIN (subblocks))
12915 gen_block_die (subblocks, context_die, depth + 1);
12916 }
12917
12918 /* Is this a typedef we can avoid emitting? */
12919
12920 static inline int
is_redundant_typedef(tree decl)12921 is_redundant_typedef (tree decl)
12922 {
12923 if (TYPE_DECL_IS_STUB (decl))
12924 return 1;
12925
12926 if (DECL_ARTIFICIAL (decl)
12927 && DECL_CONTEXT (decl)
12928 && is_tagged_type (DECL_CONTEXT (decl))
12929 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
12930 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
12931 /* Also ignore the artificial member typedef for the class name. */
12932 return 1;
12933
12934 return 0;
12935 }
12936
12937 /* Returns the DIE for decl. A DIE will always be returned. */
12938
12939 static dw_die_ref
force_decl_die(tree decl)12940 force_decl_die (tree decl)
12941 {
12942 dw_die_ref decl_die;
12943 unsigned saved_external_flag;
12944 tree save_fn = NULL_TREE;
12945 decl_die = lookup_decl_die (decl);
12946 if (!decl_die)
12947 {
12948 dw_die_ref context_die;
12949 tree decl_context = DECL_CONTEXT (decl);
12950 if (decl_context)
12951 {
12952 /* Find die that represents this context. */
12953 if (TYPE_P (decl_context))
12954 context_die = force_type_die (decl_context);
12955 else
12956 context_die = force_decl_die (decl_context);
12957 }
12958 else
12959 context_die = comp_unit_die;
12960
12961 decl_die = lookup_decl_die (decl);
12962 if (decl_die)
12963 return decl_die;
12964
12965 switch (TREE_CODE (decl))
12966 {
12967 case FUNCTION_DECL:
12968 /* Clear current_function_decl, so that gen_subprogram_die thinks
12969 that this is a declaration. At this point, we just want to force
12970 declaration die. */
12971 save_fn = current_function_decl;
12972 current_function_decl = NULL_TREE;
12973 gen_subprogram_die (decl, context_die);
12974 current_function_decl = save_fn;
12975 break;
12976
12977 case VAR_DECL:
12978 /* Set external flag to force declaration die. Restore it after
12979 gen_decl_die() call. */
12980 saved_external_flag = DECL_EXTERNAL (decl);
12981 DECL_EXTERNAL (decl) = 1;
12982 gen_decl_die (decl, context_die);
12983 DECL_EXTERNAL (decl) = saved_external_flag;
12984 break;
12985
12986 case NAMESPACE_DECL:
12987 dwarf2out_decl (decl);
12988 break;
12989
12990 default:
12991 gcc_unreachable ();
12992 }
12993
12994 /* We should be able to find the DIE now. */
12995 if (!decl_die)
12996 decl_die = lookup_decl_die (decl);
12997 gcc_assert (decl_die);
12998 }
12999
13000 return decl_die;
13001 }
13002
13003 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
13004 always returned. */
13005
13006 static dw_die_ref
force_type_die(tree type)13007 force_type_die (tree type)
13008 {
13009 dw_die_ref type_die;
13010
13011 type_die = lookup_type_die (type);
13012 if (!type_die)
13013 {
13014 dw_die_ref context_die;
13015 if (TYPE_CONTEXT (type))
13016 {
13017 if (TYPE_P (TYPE_CONTEXT (type)))
13018 context_die = force_type_die (TYPE_CONTEXT (type));
13019 else
13020 context_die = force_decl_die (TYPE_CONTEXT (type));
13021 }
13022 else
13023 context_die = comp_unit_die;
13024
13025 type_die = lookup_type_die (type);
13026 if (type_die)
13027 return type_die;
13028 gen_type_die (type, context_die);
13029 type_die = lookup_type_die (type);
13030 gcc_assert (type_die);
13031 }
13032 return type_die;
13033 }
13034
13035 /* Force out any required namespaces to be able to output DECL,
13036 and return the new context_die for it, if it's changed. */
13037
13038 static dw_die_ref
setup_namespace_context(tree thing,dw_die_ref context_die)13039 setup_namespace_context (tree thing, dw_die_ref context_die)
13040 {
13041 tree context = (DECL_P (thing)
13042 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
13043 if (context && TREE_CODE (context) == NAMESPACE_DECL)
13044 /* Force out the namespace. */
13045 context_die = force_decl_die (context);
13046
13047 return context_die;
13048 }
13049
13050 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
13051 type) within its namespace, if appropriate.
13052
13053 For compatibility with older debuggers, namespace DIEs only contain
13054 declarations; all definitions are emitted at CU scope. */
13055
13056 static void
declare_in_namespace(tree thing,dw_die_ref context_die)13057 declare_in_namespace (tree thing, dw_die_ref context_die)
13058 {
13059 dw_die_ref ns_context;
13060
13061 if (debug_info_level <= DINFO_LEVEL_TERSE)
13062 return;
13063
13064 /* If this decl is from an inlined function, then don't try to emit it in its
13065 namespace, as we will get confused. It would have already been emitted
13066 when the abstract instance of the inline function was emitted anyways. */
13067 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
13068 return;
13069
13070 ns_context = setup_namespace_context (thing, context_die);
13071
13072 if (ns_context != context_die)
13073 {
13074 if (DECL_P (thing))
13075 gen_decl_die (thing, ns_context);
13076 else
13077 gen_type_die (thing, ns_context);
13078 }
13079 }
13080
13081 /* Generate a DIE for a namespace or namespace alias. */
13082
13083 static void
gen_namespace_die(tree decl)13084 gen_namespace_die (tree decl)
13085 {
13086 dw_die_ref context_die = setup_namespace_context (decl, comp_unit_die);
13087
13088 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
13089 they are an alias of. */
13090 if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
13091 {
13092 /* Output a real namespace. */
13093 dw_die_ref namespace_die
13094 = new_die (DW_TAG_namespace, context_die, decl);
13095 add_name_and_src_coords_attributes (namespace_die, decl);
13096 equate_decl_number_to_die (decl, namespace_die);
13097 }
13098 else
13099 {
13100 /* Output a namespace alias. */
13101
13102 /* Force out the namespace we are an alias of, if necessary. */
13103 dw_die_ref origin_die
13104 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
13105
13106 /* Now create the namespace alias DIE. */
13107 dw_die_ref namespace_die
13108 = new_die (DW_TAG_imported_declaration, context_die, decl);
13109 add_name_and_src_coords_attributes (namespace_die, decl);
13110 add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
13111 equate_decl_number_to_die (decl, namespace_die);
13112 }
13113 }
13114
13115 /* Generate Dwarf debug information for a decl described by DECL. */
13116
13117 static void
gen_decl_die(tree decl,dw_die_ref context_die)13118 gen_decl_die (tree decl, dw_die_ref context_die)
13119 {
13120 tree origin;
13121
13122 if (DECL_P (decl) && DECL_IGNORED_P (decl))
13123 return;
13124
13125 switch (TREE_CODE (decl))
13126 {
13127 case ERROR_MARK:
13128 break;
13129
13130 case CONST_DECL:
13131 /* The individual enumerators of an enum type get output when we output
13132 the Dwarf representation of the relevant enum type itself. */
13133 break;
13134
13135 case FUNCTION_DECL:
13136 /* Don't output any DIEs to represent mere function declarations,
13137 unless they are class members or explicit block externs. */
13138 if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
13139 && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl)))
13140 break;
13141
13142 #if 0
13143 /* FIXME */
13144 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
13145 on local redeclarations of global functions. That seems broken. */
13146 if (current_function_decl != decl)
13147 /* This is only a declaration. */;
13148 #endif
13149
13150 /* If we're emitting a clone, emit info for the abstract instance. */
13151 if (DECL_ORIGIN (decl) != decl)
13152 dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl));
13153
13154 /* If we're emitting an out-of-line copy of an inline function,
13155 emit info for the abstract instance and set up to refer to it. */
13156 else if (cgraph_function_possibly_inlined_p (decl)
13157 && ! DECL_ABSTRACT (decl)
13158 && ! class_or_namespace_scope_p (context_die)
13159 /* dwarf2out_abstract_function won't emit a die if this is just
13160 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
13161 that case, because that works only if we have a die. */
13162 && DECL_INITIAL (decl) != NULL_TREE)
13163 {
13164 dwarf2out_abstract_function (decl);
13165 set_decl_origin_self (decl);
13166 }
13167
13168 /* Otherwise we're emitting the primary DIE for this decl. */
13169 else if (debug_info_level > DINFO_LEVEL_TERSE)
13170 {
13171 /* Before we describe the FUNCTION_DECL itself, make sure that we
13172 have described its return type. */
13173 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
13174
13175 /* And its virtual context. */
13176 if (DECL_VINDEX (decl) != NULL_TREE)
13177 gen_type_die (DECL_CONTEXT (decl), context_die);
13178
13179 /* And its containing type. */
13180 origin = decl_class_context (decl);
13181 if (origin != NULL_TREE)
13182 gen_type_die_for_member (origin, decl, context_die);
13183
13184 /* And its containing namespace. */
13185 declare_in_namespace (decl, context_die);
13186 }
13187
13188 /* Now output a DIE to represent the function itself. */
13189 gen_subprogram_die (decl, context_die);
13190 break;
13191
13192 case TYPE_DECL:
13193 /* If we are in terse mode, don't generate any DIEs to represent any
13194 actual typedefs. */
13195 if (debug_info_level <= DINFO_LEVEL_TERSE)
13196 break;
13197
13198 /* In the special case of a TYPE_DECL node representing the declaration
13199 of some type tag, if the given TYPE_DECL is marked as having been
13200 instantiated from some other (original) TYPE_DECL node (e.g. one which
13201 was generated within the original definition of an inline function) we
13202 have to generate a special (abbreviated) DW_TAG_structure_type,
13203 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. */
13204 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
13205 {
13206 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
13207 break;
13208 }
13209
13210 if (is_redundant_typedef (decl))
13211 gen_type_die (TREE_TYPE (decl), context_die);
13212 else
13213 /* Output a DIE to represent the typedef itself. */
13214 gen_typedef_die (decl, context_die);
13215 break;
13216
13217 case LABEL_DECL:
13218 if (debug_info_level >= DINFO_LEVEL_NORMAL)
13219 gen_label_die (decl, context_die);
13220 break;
13221
13222 case VAR_DECL:
13223 case RESULT_DECL:
13224 /* If we are in terse mode, don't generate any DIEs to represent any
13225 variable declarations or definitions. */
13226 if (debug_info_level <= DINFO_LEVEL_TERSE)
13227 break;
13228
13229 /* Output any DIEs that are needed to specify the type of this data
13230 object. */
13231 gen_type_die (TREE_TYPE (decl), context_die);
13232
13233 /* And its containing type. */
13234 origin = decl_class_context (decl);
13235 if (origin != NULL_TREE)
13236 gen_type_die_for_member (origin, decl, context_die);
13237
13238 /* And its containing namespace. */
13239 declare_in_namespace (decl, context_die);
13240
13241 /* Now output the DIE to represent the data object itself. This gets
13242 complicated because of the possibility that the VAR_DECL really
13243 represents an inlined instance of a formal parameter for an inline
13244 function. */
13245 origin = decl_ultimate_origin (decl);
13246 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
13247 gen_formal_parameter_die (decl, context_die);
13248 else
13249 gen_variable_die (decl, context_die);
13250 break;
13251
13252 case FIELD_DECL:
13253 /* Ignore the nameless fields that are used to skip bits but handle C++
13254 anonymous unions and structs. */
13255 if (DECL_NAME (decl) != NULL_TREE
13256 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
13257 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
13258 {
13259 gen_type_die (member_declared_type (decl), context_die);
13260 gen_field_die (decl, context_die);
13261 }
13262 break;
13263
13264 case PARM_DECL:
13265 gen_type_die (TREE_TYPE (decl), context_die);
13266 gen_formal_parameter_die (decl, context_die);
13267 break;
13268
13269 case NAMESPACE_DECL:
13270 gen_namespace_die (decl);
13271 break;
13272
13273 default:
13274 /* Probably some frontend-internal decl. Assume we don't care. */
13275 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
13276 break;
13277 }
13278 }
13279
13280 /* Output debug information for global decl DECL. Called from toplev.c after
13281 compilation proper has finished. */
13282
13283 static void
dwarf2out_global_decl(tree decl)13284 dwarf2out_global_decl (tree decl)
13285 {
13286 /* Output DWARF2 information for file-scope tentative data object
13287 declarations, file-scope (extern) function declarations (which had no
13288 corresponding body) and file-scope tagged type declarations and
13289 definitions which have not yet been forced out. */
13290 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
13291 dwarf2out_decl (decl);
13292 }
13293
13294 /* Output debug information for type decl DECL. Called from toplev.c
13295 and from language front ends (to record built-in types). */
13296 static void
dwarf2out_type_decl(tree decl,int local)13297 dwarf2out_type_decl (tree decl, int local)
13298 {
13299 if (!local)
13300 dwarf2out_decl (decl);
13301 }
13302
13303 /* Output debug information for imported module or decl. */
13304
13305 static void
dwarf2out_imported_module_or_decl(tree decl,tree context)13306 dwarf2out_imported_module_or_decl (tree decl, tree context)
13307 {
13308 dw_die_ref imported_die, at_import_die;
13309 dw_die_ref scope_die;
13310 expanded_location xloc;
13311
13312 if (debug_info_level <= DINFO_LEVEL_TERSE)
13313 return;
13314
13315 gcc_assert (decl);
13316
13317 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
13318 We need decl DIE for reference and scope die. First, get DIE for the decl
13319 itself. */
13320
13321 /* Get the scope die for decl context. Use comp_unit_die for global module
13322 or decl. If die is not found for non globals, force new die. */
13323 if (!context)
13324 scope_die = comp_unit_die;
13325 else if (TYPE_P (context))
13326 scope_die = force_type_die (context);
13327 else
13328 scope_die = force_decl_die (context);
13329
13330 /* For TYPE_DECL or CONST_DECL, lookup TREE_TYPE. */
13331 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
13332 {
13333 if (is_base_type (TREE_TYPE (decl)))
13334 at_import_die = base_type_die (TREE_TYPE (decl));
13335 else
13336 at_import_die = force_type_die (TREE_TYPE (decl));
13337 }
13338 else
13339 {
13340 at_import_die = lookup_decl_die (decl);
13341 if (!at_import_die)
13342 {
13343 /* If we're trying to avoid duplicate debug info, we may not have
13344 emitted the member decl for this field. Emit it now. */
13345 if (TREE_CODE (decl) == FIELD_DECL)
13346 {
13347 tree type = DECL_CONTEXT (decl);
13348 dw_die_ref type_context_die;
13349
13350 if (TYPE_CONTEXT (type))
13351 if (TYPE_P (TYPE_CONTEXT (type)))
13352 type_context_die = force_type_die (TYPE_CONTEXT (type));
13353 else
13354 type_context_die = force_decl_die (TYPE_CONTEXT (type));
13355 else
13356 type_context_die = comp_unit_die;
13357 gen_type_die_for_member (type, decl, type_context_die);
13358 }
13359 at_import_die = force_decl_die (decl);
13360 }
13361 }
13362
13363 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
13364 if (TREE_CODE (decl) == NAMESPACE_DECL)
13365 imported_die = new_die (DW_TAG_imported_module, scope_die, context);
13366 else
13367 imported_die = new_die (DW_TAG_imported_declaration, scope_die, context);
13368
13369 xloc = expand_location (input_location);
13370 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
13371 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
13372 add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
13373 }
13374
13375 /* Write the debugging output for DECL. */
13376
13377 void
dwarf2out_decl(tree decl)13378 dwarf2out_decl (tree decl)
13379 {
13380 dw_die_ref context_die = comp_unit_die;
13381
13382 switch (TREE_CODE (decl))
13383 {
13384 case ERROR_MARK:
13385 return;
13386
13387 case FUNCTION_DECL:
13388 /* What we would really like to do here is to filter out all mere
13389 file-scope declarations of file-scope functions which are never
13390 referenced later within this translation unit (and keep all of ones
13391 that *are* referenced later on) but we aren't clairvoyant, so we have
13392 no idea which functions will be referenced in the future (i.e. later
13393 on within the current translation unit). So here we just ignore all
13394 file-scope function declarations which are not also definitions. If
13395 and when the debugger needs to know something about these functions,
13396 it will have to hunt around and find the DWARF information associated
13397 with the definition of the function.
13398
13399 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
13400 nodes represent definitions and which ones represent mere
13401 declarations. We have to check DECL_INITIAL instead. That's because
13402 the C front-end supports some weird semantics for "extern inline"
13403 function definitions. These can get inlined within the current
13404 translation unit (and thus, we need to generate Dwarf info for their
13405 abstract instances so that the Dwarf info for the concrete inlined
13406 instances can have something to refer to) but the compiler never
13407 generates any out-of-lines instances of such things (despite the fact
13408 that they *are* definitions).
13409
13410 The important point is that the C front-end marks these "extern
13411 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
13412 them anyway. Note that the C++ front-end also plays some similar games
13413 for inline function definitions appearing within include files which
13414 also contain `#pragma interface' pragmas. */
13415 if (DECL_INITIAL (decl) == NULL_TREE)
13416 return;
13417
13418 /* If we're a nested function, initially use a parent of NULL; if we're
13419 a plain function, this will be fixed up in decls_for_scope. If
13420 we're a method, it will be ignored, since we already have a DIE. */
13421 if (decl_function_context (decl)
13422 /* But if we're in terse mode, we don't care about scope. */
13423 && debug_info_level > DINFO_LEVEL_TERSE)
13424 context_die = NULL;
13425 break;
13426
13427 case VAR_DECL:
13428 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
13429 declaration and if the declaration was never even referenced from
13430 within this entire compilation unit. We suppress these DIEs in
13431 order to save space in the .debug section (by eliminating entries
13432 which are probably useless). Note that we must not suppress
13433 block-local extern declarations (whether used or not) because that
13434 would screw-up the debugger's name lookup mechanism and cause it to
13435 miss things which really ought to be in scope at a given point. */
13436 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
13437 return;
13438
13439 /* For local statics lookup proper context die. */
13440 if (TREE_STATIC (decl) && decl_function_context (decl))
13441 context_die = lookup_decl_die (DECL_CONTEXT (decl));
13442
13443 /* If we are in terse mode, don't generate any DIEs to represent any
13444 variable declarations or definitions. */
13445 if (debug_info_level <= DINFO_LEVEL_TERSE)
13446 return;
13447 break;
13448
13449 case NAMESPACE_DECL:
13450 if (debug_info_level <= DINFO_LEVEL_TERSE)
13451 return;
13452 if (lookup_decl_die (decl) != NULL)
13453 return;
13454 break;
13455
13456 case TYPE_DECL:
13457 /* Don't emit stubs for types unless they are needed by other DIEs. */
13458 if (TYPE_DECL_SUPPRESS_DEBUG (decl))
13459 return;
13460
13461 /* Don't bother trying to generate any DIEs to represent any of the
13462 normal built-in types for the language we are compiling. */
13463 if (DECL_IS_BUILTIN (decl))
13464 {
13465 /* OK, we need to generate one for `bool' so GDB knows what type
13466 comparisons have. */
13467 if (is_cxx ()
13468 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
13469 && ! DECL_IGNORED_P (decl))
13470 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
13471
13472 return;
13473 }
13474
13475 /* If we are in terse mode, don't generate any DIEs for types. */
13476 if (debug_info_level <= DINFO_LEVEL_TERSE)
13477 return;
13478
13479 /* If we're a function-scope tag, initially use a parent of NULL;
13480 this will be fixed up in decls_for_scope. */
13481 if (decl_function_context (decl))
13482 context_die = NULL;
13483
13484 break;
13485
13486 default:
13487 return;
13488 }
13489
13490 gen_decl_die (decl, context_die);
13491 }
13492
13493 /* Output a marker (i.e. a label) for the beginning of the generated code for
13494 a lexical block. */
13495
13496 static void
dwarf2out_begin_block(unsigned int line ATTRIBUTE_UNUSED,unsigned int blocknum)13497 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
13498 unsigned int blocknum)
13499 {
13500 switch_to_section (current_function_section ());
13501 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
13502 }
13503
13504 /* Output a marker (i.e. a label) for the end of the generated code for a
13505 lexical block. */
13506
13507 static void
dwarf2out_end_block(unsigned int line ATTRIBUTE_UNUSED,unsigned int blocknum)13508 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
13509 {
13510 switch_to_section (current_function_section ());
13511 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
13512 }
13513
13514 /* Returns nonzero if it is appropriate not to emit any debugging
13515 information for BLOCK, because it doesn't contain any instructions.
13516
13517 Don't allow this for blocks with nested functions or local classes
13518 as we would end up with orphans, and in the presence of scheduling
13519 we may end up calling them anyway. */
13520
13521 static bool
dwarf2out_ignore_block(tree block)13522 dwarf2out_ignore_block (tree block)
13523 {
13524 tree decl;
13525
13526 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
13527 if (TREE_CODE (decl) == FUNCTION_DECL
13528 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
13529 return 0;
13530
13531 return 1;
13532 }
13533
13534 /* Hash table routines for file_hash. */
13535
13536 static int
file_table_eq(const void * p1_p,const void * p2_p)13537 file_table_eq (const void *p1_p, const void *p2_p)
13538 {
13539 const struct dwarf_file_data * p1 = p1_p;
13540 const char * p2 = p2_p;
13541 return strcmp (p1->filename, p2) == 0;
13542 }
13543
13544 static hashval_t
file_table_hash(const void * p_p)13545 file_table_hash (const void *p_p)
13546 {
13547 const struct dwarf_file_data * p = p_p;
13548 return htab_hash_string (p->filename);
13549 }
13550
13551 /* Lookup FILE_NAME (in the list of filenames that we know about here in
13552 dwarf2out.c) and return its "index". The index of each (known) filename is
13553 just a unique number which is associated with only that one filename. We
13554 need such numbers for the sake of generating labels (in the .debug_sfnames
13555 section) and references to those files numbers (in the .debug_srcinfo
13556 and.debug_macinfo sections). If the filename given as an argument is not
13557 found in our current list, add it to the list and assign it the next
13558 available unique index number. In order to speed up searches, we remember
13559 the index of the filename was looked up last. This handles the majority of
13560 all searches. */
13561
13562 static struct dwarf_file_data *
lookup_filename(const char * file_name)13563 lookup_filename (const char *file_name)
13564 {
13565 void ** slot;
13566 struct dwarf_file_data * created;
13567
13568 /* Check to see if the file name that was searched on the previous
13569 call matches this file name. If so, return the index. */
13570 if (file_table_last_lookup
13571 && (file_name == file_table_last_lookup->filename
13572 || strcmp (file_table_last_lookup->filename, file_name) == 0))
13573 return file_table_last_lookup;
13574
13575 /* Didn't match the previous lookup, search the table. */
13576 slot = htab_find_slot_with_hash (file_table, file_name,
13577 htab_hash_string (file_name), INSERT);
13578 if (*slot)
13579 return *slot;
13580
13581 created = ggc_alloc (sizeof (struct dwarf_file_data));
13582 created->filename = file_name;
13583 created->emitted_number = 0;
13584 *slot = created;
13585 return created;
13586 }
13587
13588 /* If the assembler will construct the file table, then translate the compiler
13589 internal file table number into the assembler file table number, and emit
13590 a .file directive if we haven't already emitted one yet. The file table
13591 numbers are different because we prune debug info for unused variables and
13592 types, which may include filenames. */
13593
13594 static int
maybe_emit_file(struct dwarf_file_data * fd)13595 maybe_emit_file (struct dwarf_file_data * fd)
13596 {
13597 if (! fd->emitted_number)
13598 {
13599 if (last_emitted_file)
13600 fd->emitted_number = last_emitted_file->emitted_number + 1;
13601 else
13602 fd->emitted_number = 1;
13603 last_emitted_file = fd;
13604
13605 if (DWARF2_ASM_LINE_DEBUG_INFO)
13606 {
13607 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
13608 output_quoted_string (asm_out_file, fd->filename);
13609 fputc ('\n', asm_out_file);
13610 }
13611 }
13612
13613 return fd->emitted_number;
13614 }
13615
13616 /* Called by the final INSN scan whenever we see a var location. We
13617 use it to drop labels in the right places, and throw the location in
13618 our lookup table. */
13619
13620 static void
dwarf2out_var_location(rtx loc_note)13621 dwarf2out_var_location (rtx loc_note)
13622 {
13623 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
13624 struct var_loc_node *newloc;
13625 rtx prev_insn;
13626 static rtx last_insn;
13627 static const char *last_label;
13628 tree decl;
13629
13630 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
13631 return;
13632 prev_insn = PREV_INSN (loc_note);
13633
13634 newloc = ggc_alloc_cleared (sizeof (struct var_loc_node));
13635 /* If the insn we processed last time is the previous insn
13636 and it is also a var location note, use the label we emitted
13637 last time. */
13638 if (last_insn != NULL_RTX
13639 && last_insn == prev_insn
13640 && NOTE_P (prev_insn)
13641 && NOTE_LINE_NUMBER (prev_insn) == NOTE_INSN_VAR_LOCATION)
13642 {
13643 newloc->label = last_label;
13644 }
13645 else
13646 {
13647 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
13648 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
13649 loclabel_num++;
13650 newloc->label = ggc_strdup (loclabel);
13651 }
13652 newloc->var_loc_note = loc_note;
13653 newloc->next = NULL;
13654
13655 if (cfun && in_cold_section_p)
13656 newloc->section_label = cfun->cold_section_label;
13657 else
13658 newloc->section_label = text_section_label;
13659
13660 last_insn = loc_note;
13661 last_label = newloc->label;
13662 decl = NOTE_VAR_LOCATION_DECL (loc_note);
13663 add_var_loc_to_decl (decl, newloc);
13664 }
13665
13666 /* We need to reset the locations at the beginning of each
13667 function. We can't do this in the end_function hook, because the
13668 declarations that use the locations won't have been output when
13669 that hook is called. Also compute have_multiple_function_sections here. */
13670
13671 static void
dwarf2out_begin_function(tree fun)13672 dwarf2out_begin_function (tree fun)
13673 {
13674 htab_empty (decl_loc_table);
13675
13676 if (function_section (fun) != text_section)
13677 have_multiple_function_sections = true;
13678 }
13679
13680 /* Output a label to mark the beginning of a source code line entry
13681 and record information relating to this source line, in
13682 'line_info_table' for later output of the .debug_line section. */
13683
13684 static void
dwarf2out_source_line(unsigned int line,const char * filename)13685 dwarf2out_source_line (unsigned int line, const char *filename)
13686 {
13687 if (debug_info_level >= DINFO_LEVEL_NORMAL
13688 && line != 0)
13689 {
13690 int file_num = maybe_emit_file (lookup_filename (filename));
13691
13692 switch_to_section (current_function_section ());
13693
13694 /* If requested, emit something human-readable. */
13695 if (flag_debug_asm)
13696 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
13697 filename, line);
13698
13699 if (DWARF2_ASM_LINE_DEBUG_INFO)
13700 {
13701 /* Emit the .loc directive understood by GNU as. */
13702 fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line);
13703
13704 /* Indicate that line number info exists. */
13705 line_info_table_in_use++;
13706 }
13707 else if (function_section (current_function_decl) != text_section)
13708 {
13709 dw_separate_line_info_ref line_info;
13710 targetm.asm_out.internal_label (asm_out_file,
13711 SEPARATE_LINE_CODE_LABEL,
13712 separate_line_info_table_in_use);
13713
13714 /* Expand the line info table if necessary. */
13715 if (separate_line_info_table_in_use
13716 == separate_line_info_table_allocated)
13717 {
13718 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13719 separate_line_info_table
13720 = ggc_realloc (separate_line_info_table,
13721 separate_line_info_table_allocated
13722 * sizeof (dw_separate_line_info_entry));
13723 memset (separate_line_info_table
13724 + separate_line_info_table_in_use,
13725 0,
13726 (LINE_INFO_TABLE_INCREMENT
13727 * sizeof (dw_separate_line_info_entry)));
13728 }
13729
13730 /* Add the new entry at the end of the line_info_table. */
13731 line_info
13732 = &separate_line_info_table[separate_line_info_table_in_use++];
13733 line_info->dw_file_num = file_num;
13734 line_info->dw_line_num = line;
13735 line_info->function = current_function_funcdef_no;
13736 }
13737 else
13738 {
13739 dw_line_info_ref line_info;
13740
13741 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
13742 line_info_table_in_use);
13743
13744 /* Expand the line info table if necessary. */
13745 if (line_info_table_in_use == line_info_table_allocated)
13746 {
13747 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13748 line_info_table
13749 = ggc_realloc (line_info_table,
13750 (line_info_table_allocated
13751 * sizeof (dw_line_info_entry)));
13752 memset (line_info_table + line_info_table_in_use, 0,
13753 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
13754 }
13755
13756 /* Add the new entry at the end of the line_info_table. */
13757 line_info = &line_info_table[line_info_table_in_use++];
13758 line_info->dw_file_num = file_num;
13759 line_info->dw_line_num = line;
13760 }
13761 }
13762 }
13763
13764 /* Record the beginning of a new source file. */
13765
13766 static void
dwarf2out_start_source_file(unsigned int lineno,const char * filename)13767 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
13768 {
13769 if (flag_eliminate_dwarf2_dups)
13770 {
13771 /* Record the beginning of the file for break_out_includes. */
13772 dw_die_ref bincl_die;
13773
13774 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
13775 add_AT_string (bincl_die, DW_AT_name, filename);
13776 }
13777
13778 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13779 {
13780 int file_num = maybe_emit_file (lookup_filename (filename));
13781
13782 switch_to_section (debug_macinfo_section);
13783 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
13784 dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
13785 lineno);
13786
13787 dw2_asm_output_data_uleb128 (file_num, "file %s", filename);
13788 }
13789 }
13790
13791 /* Record the end of a source file. */
13792
13793 static void
dwarf2out_end_source_file(unsigned int lineno ATTRIBUTE_UNUSED)13794 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
13795 {
13796 if (flag_eliminate_dwarf2_dups)
13797 /* Record the end of the file for break_out_includes. */
13798 new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
13799
13800 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13801 {
13802 switch_to_section (debug_macinfo_section);
13803 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
13804 }
13805 }
13806
13807 /* Called from debug_define in toplev.c. The `buffer' parameter contains
13808 the tail part of the directive line, i.e. the part which is past the
13809 initial whitespace, #, whitespace, directive-name, whitespace part. */
13810
13811 static void
dwarf2out_define(unsigned int lineno ATTRIBUTE_UNUSED,const char * buffer ATTRIBUTE_UNUSED)13812 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
13813 const char *buffer ATTRIBUTE_UNUSED)
13814 {
13815 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13816 {
13817 switch_to_section (debug_macinfo_section);
13818 dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
13819 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13820 dw2_asm_output_nstring (buffer, -1, "The macro");
13821 }
13822 }
13823
13824 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
13825 the tail part of the directive line, i.e. the part which is past the
13826 initial whitespace, #, whitespace, directive-name, whitespace part. */
13827
13828 static void
dwarf2out_undef(unsigned int lineno ATTRIBUTE_UNUSED,const char * buffer ATTRIBUTE_UNUSED)13829 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
13830 const char *buffer ATTRIBUTE_UNUSED)
13831 {
13832 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13833 {
13834 switch_to_section (debug_macinfo_section);
13835 dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
13836 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13837 dw2_asm_output_nstring (buffer, -1, "The macro");
13838 }
13839 }
13840
13841 /* Set up for Dwarf output at the start of compilation. */
13842
13843 static void
dwarf2out_init(const char * filename ATTRIBUTE_UNUSED)13844 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
13845 {
13846 /* Allocate the file_table. */
13847 file_table = htab_create_ggc (50, file_table_hash,
13848 file_table_eq, NULL);
13849
13850 /* Allocate the decl_die_table. */
13851 decl_die_table = htab_create_ggc (10, decl_die_table_hash,
13852 decl_die_table_eq, NULL);
13853
13854 /* Allocate the decl_loc_table. */
13855 decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
13856 decl_loc_table_eq, NULL);
13857
13858 /* Allocate the initial hunk of the decl_scope_table. */
13859 decl_scope_table = VEC_alloc (tree, gc, 256);
13860
13861 /* Allocate the initial hunk of the abbrev_die_table. */
13862 abbrev_die_table = ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT
13863 * sizeof (dw_die_ref));
13864 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
13865 /* Zero-th entry is allocated, but unused. */
13866 abbrev_die_table_in_use = 1;
13867
13868 /* Allocate the initial hunk of the line_info_table. */
13869 line_info_table = ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT
13870 * sizeof (dw_line_info_entry));
13871 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
13872
13873 /* Zero-th entry is allocated, but unused. */
13874 line_info_table_in_use = 1;
13875
13876 /* Generate the initial DIE for the .debug section. Note that the (string)
13877 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
13878 will (typically) be a relative pathname and that this pathname should be
13879 taken as being relative to the directory from which the compiler was
13880 invoked when the given (base) source file was compiled. We will fill
13881 in this value in dwarf2out_finish. */
13882 comp_unit_die = gen_compile_unit_die (NULL);
13883
13884 incomplete_types = VEC_alloc (tree, gc, 64);
13885
13886 used_rtx_array = VEC_alloc (rtx, gc, 32);
13887
13888 debug_info_section = get_section (DEBUG_INFO_SECTION,
13889 SECTION_DEBUG, NULL);
13890 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
13891 SECTION_DEBUG, NULL);
13892 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
13893 SECTION_DEBUG, NULL);
13894 debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
13895 SECTION_DEBUG, NULL);
13896 debug_line_section = get_section (DEBUG_LINE_SECTION,
13897 SECTION_DEBUG, NULL);
13898 debug_loc_section = get_section (DEBUG_LOC_SECTION,
13899 SECTION_DEBUG, NULL);
13900 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
13901 SECTION_DEBUG, NULL);
13902 debug_str_section = get_section (DEBUG_STR_SECTION,
13903 DEBUG_STR_SECTION_FLAGS, NULL);
13904 debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
13905 SECTION_DEBUG, NULL);
13906 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
13907 SECTION_DEBUG, NULL);
13908
13909 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
13910 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
13911 DEBUG_ABBREV_SECTION_LABEL, 0);
13912 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
13913 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
13914 COLD_TEXT_SECTION_LABEL, 0);
13915 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
13916
13917 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
13918 DEBUG_INFO_SECTION_LABEL, 0);
13919 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
13920 DEBUG_LINE_SECTION_LABEL, 0);
13921 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
13922 DEBUG_RANGES_SECTION_LABEL, 0);
13923 switch_to_section (debug_abbrev_section);
13924 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
13925 switch_to_section (debug_info_section);
13926 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
13927 switch_to_section (debug_line_section);
13928 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
13929
13930 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13931 {
13932 switch_to_section (debug_macinfo_section);
13933 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
13934 DEBUG_MACINFO_SECTION_LABEL, 0);
13935 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
13936 }
13937
13938 switch_to_section (text_section);
13939 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
13940 if (flag_reorder_blocks_and_partition)
13941 {
13942 switch_to_section (unlikely_text_section ());
13943 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
13944 }
13945 }
13946
13947 /* A helper function for dwarf2out_finish called through
13948 ht_forall. Emit one queued .debug_str string. */
13949
13950 static int
output_indirect_string(void ** h,void * v ATTRIBUTE_UNUSED)13951 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
13952 {
13953 struct indirect_string_node *node = (struct indirect_string_node *) *h;
13954
13955 if (node->form == DW_FORM_strp)
13956 {
13957 switch_to_section (debug_str_section);
13958 ASM_OUTPUT_LABEL (asm_out_file, node->label);
13959 assemble_string (node->str, strlen (node->str) + 1);
13960 }
13961
13962 return 1;
13963 }
13964
13965 #if ENABLE_ASSERT_CHECKING
13966 /* Verify that all marks are clear. */
13967
13968 static void
verify_marks_clear(dw_die_ref die)13969 verify_marks_clear (dw_die_ref die)
13970 {
13971 dw_die_ref c;
13972
13973 gcc_assert (! die->die_mark);
13974 FOR_EACH_CHILD (die, c, verify_marks_clear (c));
13975 }
13976 #endif /* ENABLE_ASSERT_CHECKING */
13977
13978 /* Clear the marks for a die and its children.
13979 Be cool if the mark isn't set. */
13980
13981 static void
prune_unmark_dies(dw_die_ref die)13982 prune_unmark_dies (dw_die_ref die)
13983 {
13984 dw_die_ref c;
13985
13986 if (die->die_mark)
13987 die->die_mark = 0;
13988 FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
13989 }
13990
13991 /* Given DIE that we're marking as used, find any other dies
13992 it references as attributes and mark them as used. */
13993
13994 static void
prune_unused_types_walk_attribs(dw_die_ref die)13995 prune_unused_types_walk_attribs (dw_die_ref die)
13996 {
13997 dw_attr_ref a;
13998 unsigned ix;
13999
14000 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
14001 {
14002 if (a->dw_attr_val.val_class == dw_val_class_die_ref)
14003 {
14004 /* A reference to another DIE.
14005 Make sure that it will get emitted. */
14006 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
14007 }
14008 /* Set the string's refcount to 0 so that prune_unused_types_mark
14009 accounts properly for it. */
14010 if (AT_class (a) == dw_val_class_str)
14011 a->dw_attr_val.v.val_str->refcount = 0;
14012 }
14013 }
14014
14015
14016 /* Mark DIE as being used. If DOKIDS is true, then walk down
14017 to DIE's children. */
14018
14019 static void
prune_unused_types_mark(dw_die_ref die,int dokids)14020 prune_unused_types_mark (dw_die_ref die, int dokids)
14021 {
14022 dw_die_ref c;
14023
14024 if (die->die_mark == 0)
14025 {
14026 /* We haven't done this node yet. Mark it as used. */
14027 die->die_mark = 1;
14028
14029 /* We also have to mark its parents as used.
14030 (But we don't want to mark our parents' kids due to this.) */
14031 if (die->die_parent)
14032 prune_unused_types_mark (die->die_parent, 0);
14033
14034 /* Mark any referenced nodes. */
14035 prune_unused_types_walk_attribs (die);
14036
14037 /* If this node is a specification,
14038 also mark the definition, if it exists. */
14039 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
14040 prune_unused_types_mark (die->die_definition, 1);
14041 }
14042
14043 if (dokids && die->die_mark != 2)
14044 {
14045 /* We need to walk the children, but haven't done so yet.
14046 Remember that we've walked the kids. */
14047 die->die_mark = 2;
14048
14049 /* If this is an array type, we need to make sure our
14050 kids get marked, even if they're types. */
14051 if (die->die_tag == DW_TAG_array_type)
14052 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
14053 else
14054 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
14055 }
14056 }
14057
14058
14059 /* Walk the tree DIE and mark types that we actually use. */
14060
14061 static void
prune_unused_types_walk(dw_die_ref die)14062 prune_unused_types_walk (dw_die_ref die)
14063 {
14064 dw_die_ref c;
14065
14066 /* Don't do anything if this node is already marked. */
14067 if (die->die_mark)
14068 return;
14069
14070 switch (die->die_tag) {
14071 case DW_TAG_const_type:
14072 case DW_TAG_packed_type:
14073 case DW_TAG_pointer_type:
14074 case DW_TAG_reference_type:
14075 case DW_TAG_volatile_type:
14076 case DW_TAG_typedef:
14077 case DW_TAG_array_type:
14078 case DW_TAG_structure_type:
14079 case DW_TAG_union_type:
14080 case DW_TAG_class_type:
14081 case DW_TAG_friend:
14082 case DW_TAG_variant_part:
14083 case DW_TAG_enumeration_type:
14084 case DW_TAG_subroutine_type:
14085 case DW_TAG_string_type:
14086 case DW_TAG_set_type:
14087 case DW_TAG_subrange_type:
14088 case DW_TAG_ptr_to_member_type:
14089 case DW_TAG_file_type:
14090 if (die->die_perennial_p)
14091 break;
14092
14093 /* It's a type node --- don't mark it. */
14094 return;
14095
14096 default:
14097 /* Mark everything else. */
14098 break;
14099 }
14100
14101 die->die_mark = 1;
14102
14103 /* Now, mark any dies referenced from here. */
14104 prune_unused_types_walk_attribs (die);
14105
14106 /* Mark children. */
14107 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
14108 }
14109
14110 /* Increment the string counts on strings referred to from DIE's
14111 attributes. */
14112
14113 static void
prune_unused_types_update_strings(dw_die_ref die)14114 prune_unused_types_update_strings (dw_die_ref die)
14115 {
14116 dw_attr_ref a;
14117 unsigned ix;
14118
14119 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
14120 if (AT_class (a) == dw_val_class_str)
14121 {
14122 struct indirect_string_node *s = a->dw_attr_val.v.val_str;
14123 s->refcount++;
14124 /* Avoid unnecessarily putting strings that are used less than
14125 twice in the hash table. */
14126 if (s->refcount
14127 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
14128 {
14129 void ** slot;
14130 slot = htab_find_slot_with_hash (debug_str_hash, s->str,
14131 htab_hash_string (s->str),
14132 INSERT);
14133 gcc_assert (*slot == NULL);
14134 *slot = s;
14135 }
14136 }
14137 }
14138
14139 /* Remove from the tree DIE any dies that aren't marked. */
14140
14141 static void
prune_unused_types_prune(dw_die_ref die)14142 prune_unused_types_prune (dw_die_ref die)
14143 {
14144 dw_die_ref c;
14145
14146 gcc_assert (die->die_mark);
14147 prune_unused_types_update_strings (die);
14148
14149 if (! die->die_child)
14150 return;
14151
14152 c = die->die_child;
14153 do {
14154 dw_die_ref prev = c;
14155 for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
14156 if (c == die->die_child)
14157 {
14158 /* No marked children between 'prev' and the end of the list. */
14159 if (prev == c)
14160 /* No marked children at all. */
14161 die->die_child = NULL;
14162 else
14163 {
14164 prev->die_sib = c->die_sib;
14165 die->die_child = prev;
14166 }
14167 return;
14168 }
14169
14170 if (c != prev->die_sib)
14171 prev->die_sib = c;
14172 prune_unused_types_prune (c);
14173 } while (c != die->die_child);
14174 }
14175
14176
14177 /* Remove dies representing declarations that we never use. */
14178
14179 static void
prune_unused_types(void)14180 prune_unused_types (void)
14181 {
14182 unsigned int i;
14183 limbo_die_node *node;
14184
14185 #if ENABLE_ASSERT_CHECKING
14186 /* All the marks should already be clear. */
14187 verify_marks_clear (comp_unit_die);
14188 for (node = limbo_die_list; node; node = node->next)
14189 verify_marks_clear (node->die);
14190 #endif /* ENABLE_ASSERT_CHECKING */
14191
14192 /* Set the mark on nodes that are actually used. */
14193 prune_unused_types_walk (comp_unit_die);
14194 for (node = limbo_die_list; node; node = node->next)
14195 prune_unused_types_walk (node->die);
14196
14197 /* Also set the mark on nodes referenced from the
14198 pubname_table or arange_table. */
14199 for (i = 0; i < pubname_table_in_use; i++)
14200 prune_unused_types_mark (pubname_table[i].die, 1);
14201 for (i = 0; i < arange_table_in_use; i++)
14202 prune_unused_types_mark (arange_table[i], 1);
14203
14204 /* Get rid of nodes that aren't marked; and update the string counts. */
14205 if (debug_str_hash)
14206 htab_empty (debug_str_hash);
14207 prune_unused_types_prune (comp_unit_die);
14208 for (node = limbo_die_list; node; node = node->next)
14209 prune_unused_types_prune (node->die);
14210
14211 /* Leave the marks clear. */
14212 prune_unmark_dies (comp_unit_die);
14213 for (node = limbo_die_list; node; node = node->next)
14214 prune_unmark_dies (node->die);
14215 }
14216
14217 /* Set the parameter to true if there are any relative pathnames in
14218 the file table. */
14219 static int
file_table_relative_p(void ** slot,void * param)14220 file_table_relative_p (void ** slot, void *param)
14221 {
14222 bool *p = param;
14223 struct dwarf_file_data *d = *slot;
14224 if (d->emitted_number && d->filename[0] != DIR_SEPARATOR)
14225 {
14226 *p = true;
14227 return 0;
14228 }
14229 return 1;
14230 }
14231
14232 /* Output stuff that dwarf requires at the end of every file,
14233 and generate the DWARF-2 debugging info. */
14234
14235 static void
dwarf2out_finish(const char * filename)14236 dwarf2out_finish (const char *filename)
14237 {
14238 limbo_die_node *node, *next_node;
14239 dw_die_ref die = 0;
14240
14241 /* Add the name for the main input file now. We delayed this from
14242 dwarf2out_init to avoid complications with PCH. */
14243 add_name_attribute (comp_unit_die, filename);
14244 if (filename[0] != DIR_SEPARATOR)
14245 add_comp_dir_attribute (comp_unit_die);
14246 else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
14247 {
14248 bool p = false;
14249 htab_traverse (file_table, file_table_relative_p, &p);
14250 if (p)
14251 add_comp_dir_attribute (comp_unit_die);
14252 }
14253
14254 /* Traverse the limbo die list, and add parent/child links. The only
14255 dies without parents that should be here are concrete instances of
14256 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
14257 For concrete instances, we can get the parent die from the abstract
14258 instance. */
14259 for (node = limbo_die_list; node; node = next_node)
14260 {
14261 next_node = node->next;
14262 die = node->die;
14263
14264 if (die->die_parent == NULL)
14265 {
14266 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
14267
14268 if (origin)
14269 add_child_die (origin->die_parent, die);
14270 else if (die == comp_unit_die)
14271 ;
14272 else if (errorcount > 0 || sorrycount > 0)
14273 /* It's OK to be confused by errors in the input. */
14274 add_child_die (comp_unit_die, die);
14275 else
14276 {
14277 /* In certain situations, the lexical block containing a
14278 nested function can be optimized away, which results
14279 in the nested function die being orphaned. Likewise
14280 with the return type of that nested function. Force
14281 this to be a child of the containing function.
14282
14283 It may happen that even the containing function got fully
14284 inlined and optimized out. In that case we are lost and
14285 assign the empty child. This should not be big issue as
14286 the function is likely unreachable too. */
14287 tree context = NULL_TREE;
14288
14289 gcc_assert (node->created_for);
14290
14291 if (DECL_P (node->created_for))
14292 context = DECL_CONTEXT (node->created_for);
14293 else if (TYPE_P (node->created_for))
14294 context = TYPE_CONTEXT (node->created_for);
14295
14296 gcc_assert (context
14297 && (TREE_CODE (context) == FUNCTION_DECL
14298 || TREE_CODE (context) == NAMESPACE_DECL));
14299
14300 origin = lookup_decl_die (context);
14301 if (origin)
14302 add_child_die (origin, die);
14303 else
14304 add_child_die (comp_unit_die, die);
14305 }
14306 }
14307 }
14308
14309 limbo_die_list = NULL;
14310
14311 /* Walk through the list of incomplete types again, trying once more to
14312 emit full debugging info for them. */
14313 retry_incomplete_types ();
14314
14315 if (flag_eliminate_unused_debug_types)
14316 prune_unused_types ();
14317
14318 /* Generate separate CUs for each of the include files we've seen.
14319 They will go into limbo_die_list. */
14320 if (flag_eliminate_dwarf2_dups)
14321 break_out_includes (comp_unit_die);
14322
14323 /* Traverse the DIE's and add add sibling attributes to those DIE's
14324 that have children. */
14325 add_sibling_attributes (comp_unit_die);
14326 for (node = limbo_die_list; node; node = node->next)
14327 add_sibling_attributes (node->die);
14328
14329 /* Output a terminator label for the .text section. */
14330 switch_to_section (text_section);
14331 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
14332 if (flag_reorder_blocks_and_partition)
14333 {
14334 switch_to_section (unlikely_text_section ());
14335 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
14336 }
14337
14338 /* We can only use the low/high_pc attributes if all of the code was
14339 in .text. */
14340 if (!have_multiple_function_sections)
14341 {
14342 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
14343 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
14344 }
14345
14346 /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate
14347 "base address". Use zero so that these addresses become absolute. */
14348 else if (have_location_lists || ranges_table_in_use)
14349 add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
14350
14351 /* Output location list section if necessary. */
14352 if (have_location_lists)
14353 {
14354 /* Output the location lists info. */
14355 switch_to_section (debug_loc_section);
14356 ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
14357 DEBUG_LOC_SECTION_LABEL, 0);
14358 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
14359 output_location_lists (die);
14360 }
14361
14362 if (debug_info_level >= DINFO_LEVEL_NORMAL)
14363 add_AT_lineptr (comp_unit_die, DW_AT_stmt_list,
14364 debug_line_section_label);
14365
14366 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14367 add_AT_macptr (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
14368
14369 /* Output all of the compilation units. We put the main one last so that
14370 the offsets are available to output_pubnames. */
14371 for (node = limbo_die_list; node; node = node->next)
14372 output_comp_unit (node->die, 0);
14373
14374 output_comp_unit (comp_unit_die, 0);
14375
14376 /* Output the abbreviation table. */
14377 switch_to_section (debug_abbrev_section);
14378 output_abbrev_section ();
14379
14380 /* Output public names table if necessary. */
14381 if (pubname_table_in_use)
14382 {
14383 switch_to_section (debug_pubnames_section);
14384 output_pubnames ();
14385 }
14386
14387 /* Output the address range information. We only put functions in the arange
14388 table, so don't write it out if we don't have any. */
14389 if (fde_table_in_use)
14390 {
14391 switch_to_section (debug_aranges_section);
14392 output_aranges ();
14393 }
14394
14395 /* Output ranges section if necessary. */
14396 if (ranges_table_in_use)
14397 {
14398 switch_to_section (debug_ranges_section);
14399 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
14400 output_ranges ();
14401 }
14402
14403 /* Output the source line correspondence table. We must do this
14404 even if there is no line information. Otherwise, on an empty
14405 translation unit, we will generate a present, but empty,
14406 .debug_info section. IRIX 6.5 `nm' will then complain when
14407 examining the file. This is done late so that any filenames
14408 used by the debug_info section are marked as 'used'. */
14409 if (! DWARF2_ASM_LINE_DEBUG_INFO)
14410 {
14411 switch_to_section (debug_line_section);
14412 output_line_info ();
14413 }
14414
14415 /* Have to end the macro section. */
14416 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14417 {
14418 switch_to_section (debug_macinfo_section);
14419 dw2_asm_output_data (1, 0, "End compilation unit");
14420 }
14421
14422 /* If we emitted any DW_FORM_strp form attribute, output the string
14423 table too. */
14424 if (debug_str_hash)
14425 htab_traverse (debug_str_hash, output_indirect_string, NULL);
14426 }
14427 #else
14428
14429 /* This should never be used, but its address is needed for comparisons. */
14430 const struct gcc_debug_hooks dwarf2_debug_hooks;
14431
14432 #endif /* DWARF2_DEBUGGING_INFO */
14433
14434 #include "gt-dwarf2out.h"
14435