dwarf2out.c revision 259268
1/* Output Dwarf2 format symbol table information from GCC. 2 Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 3 2003, 2004, 2005, 2006 Free Software Foundation, Inc. 4 Contributed by Gary Funck (gary@intrepid.com). 5 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com). 6 Extensively modified by Jason Merrill (jason@cygnus.com). 7 8This file is part of GCC. 9 10GCC is free software; you can redistribute it and/or modify it under 11the terms of the GNU General Public License as published by the Free 12Software Foundation; either version 2, or (at your option) any later 13version. 14 15GCC is distributed in the hope that it will be useful, but WITHOUT ANY 16WARRANTY; without even the implied warranty of MERCHANTABILITY or 17FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 18for more details. 19 20You should have received a copy of the GNU General Public License 21along with GCC; see the file COPYING. If not, write to the Free 22Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 2302110-1301, USA. */ 24 25/* TODO: Emit .debug_line header even when there are no functions, since 26 the file numbers are used by .debug_info. Alternately, leave 27 out locations for types and decls. 28 Avoid talking about ctors and op= for PODs. 29 Factor out common prologue sequences into multiple CIEs. */ 30 31/* The first part of this file deals with the DWARF 2 frame unwind 32 information, which is also used by the GCC efficient exception handling 33 mechanism. The second part, controlled only by an #ifdef 34 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging 35 information. */ 36 37#include "config.h" 38#include "system.h" 39#include "coretypes.h" 40#include "tm.h" 41#include "tree.h" 42#include "version.h" 43#include "flags.h" 44#include "real.h" 45#include "rtl.h" 46#include "hard-reg-set.h" 47#include "regs.h" 48#include "insn-config.h" 49#include "reload.h" 50#include "function.h" 51#include "output.h" 52#include "expr.h" 53#include "libfuncs.h" 54#include "except.h" 55#include "dwarf2.h" 56#include "dwarf2out.h" 57#include "dwarf2asm.h" 58#include "toplev.h" 59#include "varray.h" 60#include "ggc.h" 61#include "md5.h" 62#include "tm_p.h" 63#include "diagnostic.h" 64#include "debug.h" 65#include "target.h" 66#include "langhooks.h" 67#include "hashtab.h" 68#include "cgraph.h" 69#include "input.h" 70 71#ifdef DWARF2_DEBUGGING_INFO 72static void dwarf2out_source_line (unsigned int, const char *); 73#endif 74 75/* DWARF2 Abbreviation Glossary: 76 CFA = Canonical Frame Address 77 a fixed address on the stack which identifies a call frame. 78 We define it to be the value of SP just before the call insn. 79 The CFA register and offset, which may change during the course 80 of the function, are used to calculate its value at runtime. 81 CFI = Call Frame Instruction 82 an instruction for the DWARF2 abstract machine 83 CIE = Common Information Entry 84 information describing information common to one or more FDEs 85 DIE = Debugging Information Entry 86 FDE = Frame Description Entry 87 information describing the stack call frame, in particular, 88 how to restore registers 89 90 DW_CFA_... = DWARF2 CFA call frame instruction 91 DW_TAG_... = DWARF2 DIE tag */ 92 93#ifndef DWARF2_FRAME_INFO 94# ifdef DWARF2_DEBUGGING_INFO 95# define DWARF2_FRAME_INFO \ 96 (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG) 97# else 98# define DWARF2_FRAME_INFO 0 99# endif 100#endif 101 102/* Map register numbers held in the call frame info that gcc has 103 collected using DWARF_FRAME_REGNUM to those that should be output in 104 .debug_frame and .eh_frame. */ 105#ifndef DWARF2_FRAME_REG_OUT 106#define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO) 107#endif 108 109/* Decide whether we want to emit frame unwind information for the current 110 translation unit. */ 111 112int 113dwarf2out_do_frame (void) 114{ 115 /* We want to emit correct CFA location expressions or lists, so we 116 have to return true if we're going to output debug info, even if 117 we're not going to output frame or unwind info. */ 118 return (write_symbols == DWARF2_DEBUG 119 || write_symbols == VMS_AND_DWARF2_DEBUG 120 || DWARF2_FRAME_INFO 121#ifdef DWARF2_UNWIND_INFO 122 || (DWARF2_UNWIND_INFO 123 && (flag_unwind_tables 124 || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS))) 125#endif 126 ); 127} 128 129/* The size of the target's pointer type. */ 130#ifndef PTR_SIZE 131#define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT) 132#endif 133 134/* Array of RTXes referenced by the debugging information, which therefore 135 must be kept around forever. */ 136static GTY(()) VEC(rtx,gc) *used_rtx_array; 137 138/* A pointer to the base of a list of incomplete types which might be 139 completed at some later time. incomplete_types_list needs to be a 140 VEC(tree,gc) because we want to tell the garbage collector about 141 it. */ 142static GTY(()) VEC(tree,gc) *incomplete_types; 143 144/* A pointer to the base of a table of references to declaration 145 scopes. This table is a display which tracks the nesting 146 of declaration scopes at the current scope and containing 147 scopes. This table is used to find the proper place to 148 define type declaration DIE's. */ 149static GTY(()) VEC(tree,gc) *decl_scope_table; 150 151/* Pointers to various DWARF2 sections. */ 152static GTY(()) section *debug_info_section; 153static GTY(()) section *debug_abbrev_section; 154static GTY(()) section *debug_aranges_section; 155static GTY(()) section *debug_macinfo_section; 156static GTY(()) section *debug_line_section; 157static GTY(()) section *debug_loc_section; 158static GTY(()) section *debug_pubnames_section; 159static GTY(()) section *debug_str_section; 160static GTY(()) section *debug_ranges_section; 161static GTY(()) section *debug_frame_section; 162 163/* How to start an assembler comment. */ 164#ifndef ASM_COMMENT_START 165#define ASM_COMMENT_START ";#" 166#endif 167 168typedef struct dw_cfi_struct *dw_cfi_ref; 169typedef struct dw_fde_struct *dw_fde_ref; 170typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref; 171 172/* Call frames are described using a sequence of Call Frame 173 Information instructions. The register number, offset 174 and address fields are provided as possible operands; 175 their use is selected by the opcode field. */ 176 177enum dw_cfi_oprnd_type { 178 dw_cfi_oprnd_unused, 179 dw_cfi_oprnd_reg_num, 180 dw_cfi_oprnd_offset, 181 dw_cfi_oprnd_addr, 182 dw_cfi_oprnd_loc 183}; 184 185typedef union dw_cfi_oprnd_struct GTY(()) 186{ 187 unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num; 188 HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset; 189 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr; 190 struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc; 191} 192dw_cfi_oprnd; 193 194typedef struct dw_cfi_struct GTY(()) 195{ 196 dw_cfi_ref dw_cfi_next; 197 enum dwarf_call_frame_info dw_cfi_opc; 198 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)"))) 199 dw_cfi_oprnd1; 200 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)"))) 201 dw_cfi_oprnd2; 202} 203dw_cfi_node; 204 205/* This is how we define the location of the CFA. We use to handle it 206 as REG + OFFSET all the time, but now it can be more complex. 207 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET. 208 Instead of passing around REG and OFFSET, we pass a copy 209 of this structure. */ 210typedef struct cfa_loc GTY(()) 211{ 212 HOST_WIDE_INT offset; 213 HOST_WIDE_INT base_offset; 214 unsigned int reg; 215 int indirect; /* 1 if CFA is accessed via a dereference. */ 216} dw_cfa_location; 217 218/* All call frame descriptions (FDE's) in the GCC generated DWARF 219 refer to a single Common Information Entry (CIE), defined at 220 the beginning of the .debug_frame section. This use of a single 221 CIE obviates the need to keep track of multiple CIE's 222 in the DWARF generation routines below. */ 223 224typedef struct dw_fde_struct GTY(()) 225{ 226 tree decl; 227 const char *dw_fde_begin; 228 const char *dw_fde_current_label; 229 const char *dw_fde_end; 230 const char *dw_fde_hot_section_label; 231 const char *dw_fde_hot_section_end_label; 232 const char *dw_fde_unlikely_section_label; 233 const char *dw_fde_unlikely_section_end_label; 234 bool dw_fde_switched_sections; 235 dw_cfi_ref dw_fde_cfi; 236 unsigned funcdef_number; 237 unsigned all_throwers_are_sibcalls : 1; 238 unsigned nothrow : 1; 239 unsigned uses_eh_lsda : 1; 240} 241dw_fde_node; 242 243/* Maximum size (in bytes) of an artificially generated label. */ 244#define MAX_ARTIFICIAL_LABEL_BYTES 30 245 246/* The size of addresses as they appear in the Dwarf 2 data. 247 Some architectures use word addresses to refer to code locations, 248 but Dwarf 2 info always uses byte addresses. On such machines, 249 Dwarf 2 addresses need to be larger than the architecture's 250 pointers. */ 251#ifndef DWARF2_ADDR_SIZE 252#define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT) 253#endif 254 255/* The size in bytes of a DWARF field indicating an offset or length 256 relative to a debug info section, specified to be 4 bytes in the 257 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same 258 as PTR_SIZE. */ 259 260#ifndef DWARF_OFFSET_SIZE 261#define DWARF_OFFSET_SIZE 4 262#endif 263 264/* According to the (draft) DWARF 3 specification, the initial length 265 should either be 4 or 12 bytes. When it's 12 bytes, the first 4 266 bytes are 0xffffffff, followed by the length stored in the next 8 267 bytes. 268 269 However, the SGI/MIPS ABI uses an initial length which is equal to 270 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */ 271 272#ifndef DWARF_INITIAL_LENGTH_SIZE 273#define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12) 274#endif 275 276#define DWARF_VERSION 2 277 278/* Round SIZE up to the nearest BOUNDARY. */ 279#define DWARF_ROUND(SIZE,BOUNDARY) \ 280 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY)) 281 282/* Offsets recorded in opcodes are a multiple of this alignment factor. */ 283#ifndef DWARF_CIE_DATA_ALIGNMENT 284#ifdef STACK_GROWS_DOWNWARD 285#define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD)) 286#else 287#define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD) 288#endif 289#endif 290 291/* CIE identifier. */ 292#if HOST_BITS_PER_WIDE_INT >= 64 293#define DWARF_CIE_ID \ 294 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID) 295#else 296#define DWARF_CIE_ID DW_CIE_ID 297#endif 298 299/* A pointer to the base of a table that contains frame description 300 information for each routine. */ 301static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table; 302 303/* Number of elements currently allocated for fde_table. */ 304static GTY(()) unsigned fde_table_allocated; 305 306/* Number of elements in fde_table currently in use. */ 307static GTY(()) unsigned fde_table_in_use; 308 309/* Size (in elements) of increments by which we may expand the 310 fde_table. */ 311#define FDE_TABLE_INCREMENT 256 312 313/* A list of call frame insns for the CIE. */ 314static GTY(()) dw_cfi_ref cie_cfi_head; 315 316#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 317/* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram 318 attribute that accelerates the lookup of the FDE associated 319 with the subprogram. This variable holds the table index of the FDE 320 associated with the current function (body) definition. */ 321static unsigned current_funcdef_fde; 322#endif 323 324struct indirect_string_node GTY(()) 325{ 326 const char *str; 327 unsigned int refcount; 328 unsigned int form; 329 char *label; 330}; 331 332static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash; 333 334static GTY(()) int dw2_string_counter; 335static GTY(()) unsigned long dwarf2out_cfi_label_num; 336 337#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 338 339/* Forward declarations for functions defined in this file. */ 340 341static char *stripattributes (const char *); 342static const char *dwarf_cfi_name (unsigned); 343static dw_cfi_ref new_cfi (void); 344static void add_cfi (dw_cfi_ref *, dw_cfi_ref); 345static void add_fde_cfi (const char *, dw_cfi_ref); 346static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *); 347static void lookup_cfa (dw_cfa_location *); 348static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT); 349static void initial_return_save (rtx); 350static HOST_WIDE_INT stack_adjust_offset (rtx); 351static void output_cfi (dw_cfi_ref, dw_fde_ref, int); 352static void output_call_frame_info (int); 353static void dwarf2out_stack_adjust (rtx, bool); 354static void flush_queued_reg_saves (void); 355static bool clobbers_queued_reg_save (rtx); 356static void dwarf2out_frame_debug_expr (rtx, const char *); 357 358/* Support for complex CFA locations. */ 359static void output_cfa_loc (dw_cfi_ref); 360static void get_cfa_from_loc_descr (dw_cfa_location *, 361 struct dw_loc_descr_struct *); 362static struct dw_loc_descr_struct *build_cfa_loc 363 (dw_cfa_location *, HOST_WIDE_INT); 364static void def_cfa_1 (const char *, dw_cfa_location *); 365 366/* How to start an assembler comment. */ 367#ifndef ASM_COMMENT_START 368#define ASM_COMMENT_START ";#" 369#endif 370 371/* Data and reference forms for relocatable data. */ 372#define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4) 373#define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4) 374 375#ifndef DEBUG_FRAME_SECTION 376#define DEBUG_FRAME_SECTION ".debug_frame" 377#endif 378 379#ifndef FUNC_BEGIN_LABEL 380#define FUNC_BEGIN_LABEL "LFB" 381#endif 382 383#ifndef FUNC_END_LABEL 384#define FUNC_END_LABEL "LFE" 385#endif 386 387#ifndef FRAME_BEGIN_LABEL 388#define FRAME_BEGIN_LABEL "Lframe" 389#endif 390#define CIE_AFTER_SIZE_LABEL "LSCIE" 391#define CIE_END_LABEL "LECIE" 392#define FDE_LABEL "LSFDE" 393#define FDE_AFTER_SIZE_LABEL "LASFDE" 394#define FDE_END_LABEL "LEFDE" 395#define LINE_NUMBER_BEGIN_LABEL "LSLT" 396#define LINE_NUMBER_END_LABEL "LELT" 397#define LN_PROLOG_AS_LABEL "LASLTP" 398#define LN_PROLOG_END_LABEL "LELTP" 399#define DIE_LABEL_PREFIX "DW" 400 401/* The DWARF 2 CFA column which tracks the return address. Normally this 402 is the column for PC, or the first column after all of the hard 403 registers. */ 404#ifndef DWARF_FRAME_RETURN_COLUMN 405#ifdef PC_REGNUM 406#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM) 407#else 408#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS 409#endif 410#endif 411 412/* The mapping from gcc register number to DWARF 2 CFA column number. By 413 default, we just provide columns for all registers. */ 414#ifndef DWARF_FRAME_REGNUM 415#define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG) 416#endif 417 418/* Hook used by __throw. */ 419 420rtx 421expand_builtin_dwarf_sp_column (void) 422{ 423 unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM); 424 return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1)); 425} 426 427/* Return a pointer to a copy of the section string name S with all 428 attributes stripped off, and an asterisk prepended (for assemble_name). */ 429 430static inline char * 431stripattributes (const char *s) 432{ 433 char *stripped = XNEWVEC (char, strlen (s) + 2); 434 char *p = stripped; 435 436 *p++ = '*'; 437 438 while (*s && *s != ',') 439 *p++ = *s++; 440 441 *p = '\0'; 442 return stripped; 443} 444 445/* Generate code to initialize the register size table. */ 446 447void 448expand_builtin_init_dwarf_reg_sizes (tree address) 449{ 450 unsigned int i; 451 enum machine_mode mode = TYPE_MODE (char_type_node); 452 rtx addr = expand_normal (address); 453 rtx mem = gen_rtx_MEM (BLKmode, addr); 454 bool wrote_return_column = false; 455 456 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) 457 { 458 int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1); 459 460 if (rnum < DWARF_FRAME_REGISTERS) 461 { 462 HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode); 463 enum machine_mode save_mode = reg_raw_mode[i]; 464 HOST_WIDE_INT size; 465 466 if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode)) 467 save_mode = choose_hard_reg_mode (i, 1, true); 468 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN) 469 { 470 if (save_mode == VOIDmode) 471 continue; 472 wrote_return_column = true; 473 } 474 size = GET_MODE_SIZE (save_mode); 475 if (offset < 0) 476 continue; 477 478 emit_move_insn (adjust_address (mem, mode, offset), 479 gen_int_mode (size, mode)); 480 } 481 } 482 483#ifdef DWARF_ALT_FRAME_RETURN_COLUMN 484 gcc_assert (wrote_return_column); 485 i = DWARF_ALT_FRAME_RETURN_COLUMN; 486 wrote_return_column = false; 487#else 488 i = DWARF_FRAME_RETURN_COLUMN; 489#endif 490 491 if (! wrote_return_column) 492 { 493 enum machine_mode save_mode = Pmode; 494 HOST_WIDE_INT offset = i * GET_MODE_SIZE (mode); 495 HOST_WIDE_INT size = GET_MODE_SIZE (save_mode); 496 emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size)); 497 } 498} 499 500/* Convert a DWARF call frame info. operation to its string name */ 501 502static const char * 503dwarf_cfi_name (unsigned int cfi_opc) 504{ 505 switch (cfi_opc) 506 { 507 case DW_CFA_advance_loc: 508 return "DW_CFA_advance_loc"; 509 case DW_CFA_offset: 510 return "DW_CFA_offset"; 511 case DW_CFA_restore: 512 return "DW_CFA_restore"; 513 case DW_CFA_nop: 514 return "DW_CFA_nop"; 515 case DW_CFA_set_loc: 516 return "DW_CFA_set_loc"; 517 case DW_CFA_advance_loc1: 518 return "DW_CFA_advance_loc1"; 519 case DW_CFA_advance_loc2: 520 return "DW_CFA_advance_loc2"; 521 case DW_CFA_advance_loc4: 522 return "DW_CFA_advance_loc4"; 523 case DW_CFA_offset_extended: 524 return "DW_CFA_offset_extended"; 525 case DW_CFA_restore_extended: 526 return "DW_CFA_restore_extended"; 527 case DW_CFA_undefined: 528 return "DW_CFA_undefined"; 529 case DW_CFA_same_value: 530 return "DW_CFA_same_value"; 531 case DW_CFA_register: 532 return "DW_CFA_register"; 533 case DW_CFA_remember_state: 534 return "DW_CFA_remember_state"; 535 case DW_CFA_restore_state: 536 return "DW_CFA_restore_state"; 537 case DW_CFA_def_cfa: 538 return "DW_CFA_def_cfa"; 539 case DW_CFA_def_cfa_register: 540 return "DW_CFA_def_cfa_register"; 541 case DW_CFA_def_cfa_offset: 542 return "DW_CFA_def_cfa_offset"; 543 544 /* DWARF 3 */ 545 case DW_CFA_def_cfa_expression: 546 return "DW_CFA_def_cfa_expression"; 547 case DW_CFA_expression: 548 return "DW_CFA_expression"; 549 case DW_CFA_offset_extended_sf: 550 return "DW_CFA_offset_extended_sf"; 551 case DW_CFA_def_cfa_sf: 552 return "DW_CFA_def_cfa_sf"; 553 case DW_CFA_def_cfa_offset_sf: 554 return "DW_CFA_def_cfa_offset_sf"; 555 556 /* SGI/MIPS specific */ 557 case DW_CFA_MIPS_advance_loc8: 558 return "DW_CFA_MIPS_advance_loc8"; 559 560 /* GNU extensions */ 561 case DW_CFA_GNU_window_save: 562 return "DW_CFA_GNU_window_save"; 563 case DW_CFA_GNU_args_size: 564 return "DW_CFA_GNU_args_size"; 565 case DW_CFA_GNU_negative_offset_extended: 566 return "DW_CFA_GNU_negative_offset_extended"; 567 568 default: 569 return "DW_CFA_<unknown>"; 570 } 571} 572 573/* Return a pointer to a newly allocated Call Frame Instruction. */ 574 575static inline dw_cfi_ref 576new_cfi (void) 577{ 578 dw_cfi_ref cfi = ggc_alloc (sizeof (dw_cfi_node)); 579 580 cfi->dw_cfi_next = NULL; 581 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0; 582 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0; 583 584 return cfi; 585} 586 587/* Add a Call Frame Instruction to list of instructions. */ 588 589static inline void 590add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi) 591{ 592 dw_cfi_ref *p; 593 594 /* Find the end of the chain. */ 595 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next) 596 ; 597 598 *p = cfi; 599} 600 601/* Generate a new label for the CFI info to refer to. */ 602 603char * 604dwarf2out_cfi_label (void) 605{ 606 static char label[20]; 607 608 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++); 609 ASM_OUTPUT_LABEL (asm_out_file, label); 610 return label; 611} 612 613/* Add CFI to the current fde at the PC value indicated by LABEL if specified, 614 or to the CIE if LABEL is NULL. */ 615 616static void 617add_fde_cfi (const char *label, dw_cfi_ref cfi) 618{ 619 if (label) 620 { 621 dw_fde_ref fde = &fde_table[fde_table_in_use - 1]; 622 623 if (*label == 0) 624 label = dwarf2out_cfi_label (); 625 626 if (fde->dw_fde_current_label == NULL 627 || strcmp (label, fde->dw_fde_current_label) != 0) 628 { 629 dw_cfi_ref xcfi; 630 631 label = xstrdup (label); 632 633 /* Set the location counter to the new label. */ 634 xcfi = new_cfi (); 635 /* If we have a current label, advance from there, otherwise 636 set the location directly using set_loc. */ 637 xcfi->dw_cfi_opc = fde->dw_fde_current_label 638 ? DW_CFA_advance_loc4 639 : DW_CFA_set_loc; 640 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label; 641 add_cfi (&fde->dw_fde_cfi, xcfi); 642 643 fde->dw_fde_current_label = label; 644 } 645 646 add_cfi (&fde->dw_fde_cfi, cfi); 647 } 648 649 else 650 add_cfi (&cie_cfi_head, cfi); 651} 652 653/* Subroutine of lookup_cfa. */ 654 655static void 656lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc) 657{ 658 switch (cfi->dw_cfi_opc) 659 { 660 case DW_CFA_def_cfa_offset: 661 loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset; 662 break; 663 case DW_CFA_def_cfa_offset_sf: 664 loc->offset 665 = cfi->dw_cfi_oprnd1.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT; 666 break; 667 case DW_CFA_def_cfa_register: 668 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num; 669 break; 670 case DW_CFA_def_cfa: 671 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num; 672 loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset; 673 break; 674 case DW_CFA_def_cfa_sf: 675 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num; 676 loc->offset 677 = cfi->dw_cfi_oprnd2.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT; 678 break; 679 case DW_CFA_def_cfa_expression: 680 get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc); 681 break; 682 default: 683 break; 684 } 685} 686 687/* Find the previous value for the CFA. */ 688 689static void 690lookup_cfa (dw_cfa_location *loc) 691{ 692 dw_cfi_ref cfi; 693 694 loc->reg = INVALID_REGNUM; 695 loc->offset = 0; 696 loc->indirect = 0; 697 loc->base_offset = 0; 698 699 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next) 700 lookup_cfa_1 (cfi, loc); 701 702 if (fde_table_in_use) 703 { 704 dw_fde_ref fde = &fde_table[fde_table_in_use - 1]; 705 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next) 706 lookup_cfa_1 (cfi, loc); 707 } 708} 709 710/* The current rule for calculating the DWARF2 canonical frame address. */ 711static dw_cfa_location cfa; 712 713/* The register used for saving registers to the stack, and its offset 714 from the CFA. */ 715static dw_cfa_location cfa_store; 716 717/* The running total of the size of arguments pushed onto the stack. */ 718static HOST_WIDE_INT args_size; 719 720/* The last args_size we actually output. */ 721static HOST_WIDE_INT old_args_size; 722 723/* Entry point to update the canonical frame address (CFA). 724 LABEL is passed to add_fde_cfi. The value of CFA is now to be 725 calculated from REG+OFFSET. */ 726 727void 728dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset) 729{ 730 dw_cfa_location loc; 731 loc.indirect = 0; 732 loc.base_offset = 0; 733 loc.reg = reg; 734 loc.offset = offset; 735 def_cfa_1 (label, &loc); 736} 737 738/* Determine if two dw_cfa_location structures define the same data. */ 739 740static bool 741cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2) 742{ 743 return (loc1->reg == loc2->reg 744 && loc1->offset == loc2->offset 745 && loc1->indirect == loc2->indirect 746 && (loc1->indirect == 0 747 || loc1->base_offset == loc2->base_offset)); 748} 749 750/* This routine does the actual work. The CFA is now calculated from 751 the dw_cfa_location structure. */ 752 753static void 754def_cfa_1 (const char *label, dw_cfa_location *loc_p) 755{ 756 dw_cfi_ref cfi; 757 dw_cfa_location old_cfa, loc; 758 759 cfa = *loc_p; 760 loc = *loc_p; 761 762 if (cfa_store.reg == loc.reg && loc.indirect == 0) 763 cfa_store.offset = loc.offset; 764 765 loc.reg = DWARF_FRAME_REGNUM (loc.reg); 766 lookup_cfa (&old_cfa); 767 768 /* If nothing changed, no need to issue any call frame instructions. */ 769 if (cfa_equal_p (&loc, &old_cfa)) 770 return; 771 772 cfi = new_cfi (); 773 774 if (loc.reg == old_cfa.reg && !loc.indirect) 775 { 776 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating 777 the CFA register did not change but the offset did. */ 778 if (loc.offset < 0) 779 { 780 HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT; 781 gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset); 782 783 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf; 784 cfi->dw_cfi_oprnd1.dw_cfi_offset = f_offset; 785 } 786 else 787 { 788 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset; 789 cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset; 790 } 791 } 792 793#ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */ 794 else if (loc.offset == old_cfa.offset 795 && old_cfa.reg != INVALID_REGNUM 796 && !loc.indirect) 797 { 798 /* Construct a "DW_CFA_def_cfa_register <register>" instruction, 799 indicating the CFA register has changed to <register> but the 800 offset has not changed. */ 801 cfi->dw_cfi_opc = DW_CFA_def_cfa_register; 802 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg; 803 } 804#endif 805 806 else if (loc.indirect == 0) 807 { 808 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction, 809 indicating the CFA register has changed to <register> with 810 the specified offset. */ 811 if (loc.offset < 0) 812 { 813 HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT; 814 gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset); 815 816 cfi->dw_cfi_opc = DW_CFA_def_cfa_sf; 817 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg; 818 cfi->dw_cfi_oprnd2.dw_cfi_offset = f_offset; 819 } 820 else 821 { 822 cfi->dw_cfi_opc = DW_CFA_def_cfa; 823 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg; 824 cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset; 825 } 826 } 827 else 828 { 829 /* Construct a DW_CFA_def_cfa_expression instruction to 830 calculate the CFA using a full location expression since no 831 register-offset pair is available. */ 832 struct dw_loc_descr_struct *loc_list; 833 834 cfi->dw_cfi_opc = DW_CFA_def_cfa_expression; 835 loc_list = build_cfa_loc (&loc, 0); 836 cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list; 837 } 838 839 add_fde_cfi (label, cfi); 840} 841 842/* Add the CFI for saving a register. REG is the CFA column number. 843 LABEL is passed to add_fde_cfi. 844 If SREG is -1, the register is saved at OFFSET from the CFA; 845 otherwise it is saved in SREG. */ 846 847static void 848reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset) 849{ 850 dw_cfi_ref cfi = new_cfi (); 851 852 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg; 853 854 if (sreg == INVALID_REGNUM) 855 { 856 if (reg & ~0x3f) 857 /* The register number won't fit in 6 bits, so we have to use 858 the long form. */ 859 cfi->dw_cfi_opc = DW_CFA_offset_extended; 860 else 861 cfi->dw_cfi_opc = DW_CFA_offset; 862 863#ifdef ENABLE_CHECKING 864 { 865 /* If we get an offset that is not a multiple of 866 DWARF_CIE_DATA_ALIGNMENT, there is either a bug in the 867 definition of DWARF_CIE_DATA_ALIGNMENT, or a bug in the machine 868 description. */ 869 HOST_WIDE_INT check_offset = offset / DWARF_CIE_DATA_ALIGNMENT; 870 871 gcc_assert (check_offset * DWARF_CIE_DATA_ALIGNMENT == offset); 872 } 873#endif 874 offset /= DWARF_CIE_DATA_ALIGNMENT; 875 if (offset < 0) 876 cfi->dw_cfi_opc = DW_CFA_offset_extended_sf; 877 878 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset; 879 } 880 else if (sreg == reg) 881 cfi->dw_cfi_opc = DW_CFA_same_value; 882 else 883 { 884 cfi->dw_cfi_opc = DW_CFA_register; 885 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg; 886 } 887 888 add_fde_cfi (label, cfi); 889} 890 891/* Add the CFI for saving a register window. LABEL is passed to reg_save. 892 This CFI tells the unwinder that it needs to restore the window registers 893 from the previous frame's window save area. 894 895 ??? Perhaps we should note in the CIE where windows are saved (instead of 896 assuming 0(cfa)) and what registers are in the window. */ 897 898void 899dwarf2out_window_save (const char *label) 900{ 901 dw_cfi_ref cfi = new_cfi (); 902 903 cfi->dw_cfi_opc = DW_CFA_GNU_window_save; 904 add_fde_cfi (label, cfi); 905} 906 907/* Add a CFI to update the running total of the size of arguments 908 pushed onto the stack. */ 909 910void 911dwarf2out_args_size (const char *label, HOST_WIDE_INT size) 912{ 913 dw_cfi_ref cfi; 914 915 if (size == old_args_size) 916 return; 917 918 old_args_size = size; 919 920 cfi = new_cfi (); 921 cfi->dw_cfi_opc = DW_CFA_GNU_args_size; 922 cfi->dw_cfi_oprnd1.dw_cfi_offset = size; 923 add_fde_cfi (label, cfi); 924} 925 926/* Entry point for saving a register to the stack. REG is the GCC register 927 number. LABEL and OFFSET are passed to reg_save. */ 928 929void 930dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset) 931{ 932 reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset); 933} 934 935/* Entry point for saving the return address in the stack. 936 LABEL and OFFSET are passed to reg_save. */ 937 938void 939dwarf2out_return_save (const char *label, HOST_WIDE_INT offset) 940{ 941 reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset); 942} 943 944/* Entry point for saving the return address in a register. 945 LABEL and SREG are passed to reg_save. */ 946 947void 948dwarf2out_return_reg (const char *label, unsigned int sreg) 949{ 950 reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0); 951} 952 953/* Record the initial position of the return address. RTL is 954 INCOMING_RETURN_ADDR_RTX. */ 955 956static void 957initial_return_save (rtx rtl) 958{ 959 unsigned int reg = INVALID_REGNUM; 960 HOST_WIDE_INT offset = 0; 961 962 switch (GET_CODE (rtl)) 963 { 964 case REG: 965 /* RA is in a register. */ 966 reg = DWARF_FRAME_REGNUM (REGNO (rtl)); 967 break; 968 969 case MEM: 970 /* RA is on the stack. */ 971 rtl = XEXP (rtl, 0); 972 switch (GET_CODE (rtl)) 973 { 974 case REG: 975 gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM); 976 offset = 0; 977 break; 978 979 case PLUS: 980 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM); 981 offset = INTVAL (XEXP (rtl, 1)); 982 break; 983 984 case MINUS: 985 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM); 986 offset = -INTVAL (XEXP (rtl, 1)); 987 break; 988 989 default: 990 gcc_unreachable (); 991 } 992 993 break; 994 995 case PLUS: 996 /* The return address is at some offset from any value we can 997 actually load. For instance, on the SPARC it is in %i7+8. Just 998 ignore the offset for now; it doesn't matter for unwinding frames. */ 999 gcc_assert (GET_CODE (XEXP (rtl, 1)) == CONST_INT); 1000 initial_return_save (XEXP (rtl, 0)); 1001 return; 1002 1003 default: 1004 gcc_unreachable (); 1005 } 1006 1007 if (reg != DWARF_FRAME_RETURN_COLUMN) 1008 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset); 1009} 1010 1011/* Given a SET, calculate the amount of stack adjustment it 1012 contains. */ 1013 1014static HOST_WIDE_INT 1015stack_adjust_offset (rtx pattern) 1016{ 1017 rtx src = SET_SRC (pattern); 1018 rtx dest = SET_DEST (pattern); 1019 HOST_WIDE_INT offset = 0; 1020 enum rtx_code code; 1021 1022 if (dest == stack_pointer_rtx) 1023 { 1024 /* (set (reg sp) (plus (reg sp) (const_int))) */ 1025 code = GET_CODE (src); 1026 if (! (code == PLUS || code == MINUS) 1027 || XEXP (src, 0) != stack_pointer_rtx 1028 || GET_CODE (XEXP (src, 1)) != CONST_INT) 1029 return 0; 1030 1031 offset = INTVAL (XEXP (src, 1)); 1032 if (code == PLUS) 1033 offset = -offset; 1034 } 1035 else if (MEM_P (dest)) 1036 { 1037 /* (set (mem (pre_dec (reg sp))) (foo)) */ 1038 src = XEXP (dest, 0); 1039 code = GET_CODE (src); 1040 1041 switch (code) 1042 { 1043 case PRE_MODIFY: 1044 case POST_MODIFY: 1045 if (XEXP (src, 0) == stack_pointer_rtx) 1046 { 1047 rtx val = XEXP (XEXP (src, 1), 1); 1048 /* We handle only adjustments by constant amount. */ 1049 gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS 1050 && GET_CODE (val) == CONST_INT); 1051 offset = -INTVAL (val); 1052 break; 1053 } 1054 return 0; 1055 1056 case PRE_DEC: 1057 case POST_DEC: 1058 if (XEXP (src, 0) == stack_pointer_rtx) 1059 { 1060 offset = GET_MODE_SIZE (GET_MODE (dest)); 1061 break; 1062 } 1063 return 0; 1064 1065 case PRE_INC: 1066 case POST_INC: 1067 if (XEXP (src, 0) == stack_pointer_rtx) 1068 { 1069 offset = -GET_MODE_SIZE (GET_MODE (dest)); 1070 break; 1071 } 1072 return 0; 1073 1074 default: 1075 return 0; 1076 } 1077 } 1078 else 1079 return 0; 1080 1081 return offset; 1082} 1083 1084/* Check INSN to see if it looks like a push or a stack adjustment, and 1085 make a note of it if it does. EH uses this information to find out how 1086 much extra space it needs to pop off the stack. */ 1087 1088static void 1089dwarf2out_stack_adjust (rtx insn, bool after_p) 1090{ 1091 HOST_WIDE_INT offset; 1092 const char *label; 1093 int i; 1094 1095 /* Don't handle epilogues at all. Certainly it would be wrong to do so 1096 with this function. Proper support would require all frame-related 1097 insns to be marked, and to be able to handle saving state around 1098 epilogues textually in the middle of the function. */ 1099 if (prologue_epilogue_contains (insn) || sibcall_epilogue_contains (insn)) 1100 return; 1101 1102 /* If only calls can throw, and we have a frame pointer, 1103 save up adjustments until we see the CALL_INSN. */ 1104 if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM) 1105 { 1106 if (CALL_P (insn) && !after_p) 1107 { 1108 /* Extract the size of the args from the CALL rtx itself. */ 1109 insn = PATTERN (insn); 1110 if (GET_CODE (insn) == PARALLEL) 1111 insn = XVECEXP (insn, 0, 0); 1112 if (GET_CODE (insn) == SET) 1113 insn = SET_SRC (insn); 1114 gcc_assert (GET_CODE (insn) == CALL); 1115 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1))); 1116 } 1117 return; 1118 } 1119 1120 if (CALL_P (insn) && !after_p) 1121 { 1122 if (!flag_asynchronous_unwind_tables) 1123 dwarf2out_args_size ("", args_size); 1124 return; 1125 } 1126 else if (BARRIER_P (insn)) 1127 { 1128 /* When we see a BARRIER, we know to reset args_size to 0. Usually 1129 the compiler will have already emitted a stack adjustment, but 1130 doesn't bother for calls to noreturn functions. */ 1131#ifdef STACK_GROWS_DOWNWARD 1132 offset = -args_size; 1133#else 1134 offset = args_size; 1135#endif 1136 } 1137 else if (GET_CODE (PATTERN (insn)) == SET) 1138 offset = stack_adjust_offset (PATTERN (insn)); 1139 else if (GET_CODE (PATTERN (insn)) == PARALLEL 1140 || GET_CODE (PATTERN (insn)) == SEQUENCE) 1141 { 1142 /* There may be stack adjustments inside compound insns. Search 1143 for them. */ 1144 for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--) 1145 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET) 1146 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i)); 1147 } 1148 else 1149 return; 1150 1151 if (offset == 0) 1152 return; 1153 1154 if (cfa.reg == STACK_POINTER_REGNUM) 1155 cfa.offset += offset; 1156 1157#ifndef STACK_GROWS_DOWNWARD 1158 offset = -offset; 1159#endif 1160 1161 args_size += offset; 1162 if (args_size < 0) 1163 args_size = 0; 1164 1165 label = dwarf2out_cfi_label (); 1166 def_cfa_1 (label, &cfa); 1167 if (flag_asynchronous_unwind_tables) 1168 dwarf2out_args_size (label, args_size); 1169} 1170 1171#endif 1172 1173/* We delay emitting a register save until either (a) we reach the end 1174 of the prologue or (b) the register is clobbered. This clusters 1175 register saves so that there are fewer pc advances. */ 1176 1177struct queued_reg_save GTY(()) 1178{ 1179 struct queued_reg_save *next; 1180 rtx reg; 1181 HOST_WIDE_INT cfa_offset; 1182 rtx saved_reg; 1183}; 1184 1185static GTY(()) struct queued_reg_save *queued_reg_saves; 1186 1187/* The caller's ORIG_REG is saved in SAVED_IN_REG. */ 1188struct reg_saved_in_data GTY(()) { 1189 rtx orig_reg; 1190 rtx saved_in_reg; 1191}; 1192 1193/* A list of registers saved in other registers. 1194 The list intentionally has a small maximum capacity of 4; if your 1195 port needs more than that, you might consider implementing a 1196 more efficient data structure. */ 1197static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4]; 1198static GTY(()) size_t num_regs_saved_in_regs; 1199 1200#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 1201static const char *last_reg_save_label; 1202 1203/* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at 1204 SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */ 1205 1206static void 1207queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset) 1208{ 1209 struct queued_reg_save *q; 1210 1211 /* Duplicates waste space, but it's also necessary to remove them 1212 for correctness, since the queue gets output in reverse 1213 order. */ 1214 for (q = queued_reg_saves; q != NULL; q = q->next) 1215 if (REGNO (q->reg) == REGNO (reg)) 1216 break; 1217 1218 if (q == NULL) 1219 { 1220 q = ggc_alloc (sizeof (*q)); 1221 q->next = queued_reg_saves; 1222 queued_reg_saves = q; 1223 } 1224 1225 q->reg = reg; 1226 q->cfa_offset = offset; 1227 q->saved_reg = sreg; 1228 1229 last_reg_save_label = label; 1230} 1231 1232/* Output all the entries in QUEUED_REG_SAVES. */ 1233 1234static void 1235flush_queued_reg_saves (void) 1236{ 1237 struct queued_reg_save *q; 1238 1239 for (q = queued_reg_saves; q; q = q->next) 1240 { 1241 size_t i; 1242 unsigned int reg, sreg; 1243 1244 for (i = 0; i < num_regs_saved_in_regs; i++) 1245 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg)) 1246 break; 1247 if (q->saved_reg && i == num_regs_saved_in_regs) 1248 { 1249 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs)); 1250 num_regs_saved_in_regs++; 1251 } 1252 if (i != num_regs_saved_in_regs) 1253 { 1254 regs_saved_in_regs[i].orig_reg = q->reg; 1255 regs_saved_in_regs[i].saved_in_reg = q->saved_reg; 1256 } 1257 1258 reg = DWARF_FRAME_REGNUM (REGNO (q->reg)); 1259 if (q->saved_reg) 1260 sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg)); 1261 else 1262 sreg = INVALID_REGNUM; 1263 reg_save (last_reg_save_label, reg, sreg, q->cfa_offset); 1264 } 1265 1266 queued_reg_saves = NULL; 1267 last_reg_save_label = NULL; 1268} 1269 1270/* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved 1271 location for? Or, does it clobber a register which we've previously 1272 said that some other register is saved in, and for which we now 1273 have a new location for? */ 1274 1275static bool 1276clobbers_queued_reg_save (rtx insn) 1277{ 1278 struct queued_reg_save *q; 1279 1280 for (q = queued_reg_saves; q; q = q->next) 1281 { 1282 size_t i; 1283 if (modified_in_p (q->reg, insn)) 1284 return true; 1285 for (i = 0; i < num_regs_saved_in_regs; i++) 1286 if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg) 1287 && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn)) 1288 return true; 1289 } 1290 1291 return false; 1292} 1293 1294/* Entry point for saving the first register into the second. */ 1295 1296void 1297dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg) 1298{ 1299 size_t i; 1300 unsigned int regno, sregno; 1301 1302 for (i = 0; i < num_regs_saved_in_regs; i++) 1303 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg)) 1304 break; 1305 if (i == num_regs_saved_in_regs) 1306 { 1307 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs)); 1308 num_regs_saved_in_regs++; 1309 } 1310 regs_saved_in_regs[i].orig_reg = reg; 1311 regs_saved_in_regs[i].saved_in_reg = sreg; 1312 1313 regno = DWARF_FRAME_REGNUM (REGNO (reg)); 1314 sregno = DWARF_FRAME_REGNUM (REGNO (sreg)); 1315 reg_save (label, regno, sregno, 0); 1316} 1317 1318/* What register, if any, is currently saved in REG? */ 1319 1320static rtx 1321reg_saved_in (rtx reg) 1322{ 1323 unsigned int regn = REGNO (reg); 1324 size_t i; 1325 struct queued_reg_save *q; 1326 1327 for (q = queued_reg_saves; q; q = q->next) 1328 if (q->saved_reg && regn == REGNO (q->saved_reg)) 1329 return q->reg; 1330 1331 for (i = 0; i < num_regs_saved_in_regs; i++) 1332 if (regs_saved_in_regs[i].saved_in_reg 1333 && regn == REGNO (regs_saved_in_regs[i].saved_in_reg)) 1334 return regs_saved_in_regs[i].orig_reg; 1335 1336 return NULL_RTX; 1337} 1338 1339 1340/* A temporary register holding an integral value used in adjusting SP 1341 or setting up the store_reg. The "offset" field holds the integer 1342 value, not an offset. */ 1343static dw_cfa_location cfa_temp; 1344 1345/* Record call frame debugging information for an expression EXPR, 1346 which either sets SP or FP (adjusting how we calculate the frame 1347 address) or saves a register to the stack or another register. 1348 LABEL indicates the address of EXPR. 1349 1350 This function encodes a state machine mapping rtxes to actions on 1351 cfa, cfa_store, and cfa_temp.reg. We describe these rules so 1352 users need not read the source code. 1353 1354 The High-Level Picture 1355 1356 Changes in the register we use to calculate the CFA: Currently we 1357 assume that if you copy the CFA register into another register, we 1358 should take the other one as the new CFA register; this seems to 1359 work pretty well. If it's wrong for some target, it's simple 1360 enough not to set RTX_FRAME_RELATED_P on the insn in question. 1361 1362 Changes in the register we use for saving registers to the stack: 1363 This is usually SP, but not always. Again, we deduce that if you 1364 copy SP into another register (and SP is not the CFA register), 1365 then the new register is the one we will be using for register 1366 saves. This also seems to work. 1367 1368 Register saves: There's not much guesswork about this one; if 1369 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a 1370 register save, and the register used to calculate the destination 1371 had better be the one we think we're using for this purpose. 1372 It's also assumed that a copy from a call-saved register to another 1373 register is saving that register if RTX_FRAME_RELATED_P is set on 1374 that instruction. If the copy is from a call-saved register to 1375 the *same* register, that means that the register is now the same 1376 value as in the caller. 1377 1378 Except: If the register being saved is the CFA register, and the 1379 offset is nonzero, we are saving the CFA, so we assume we have to 1380 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that 1381 the intent is to save the value of SP from the previous frame. 1382 1383 In addition, if a register has previously been saved to a different 1384 register, 1385 1386 Invariants / Summaries of Rules 1387 1388 cfa current rule for calculating the CFA. It usually 1389 consists of a register and an offset. 1390 cfa_store register used by prologue code to save things to the stack 1391 cfa_store.offset is the offset from the value of 1392 cfa_store.reg to the actual CFA 1393 cfa_temp register holding an integral value. cfa_temp.offset 1394 stores the value, which will be used to adjust the 1395 stack pointer. cfa_temp is also used like cfa_store, 1396 to track stores to the stack via fp or a temp reg. 1397 1398 Rules 1- 4: Setting a register's value to cfa.reg or an expression 1399 with cfa.reg as the first operand changes the cfa.reg and its 1400 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and 1401 cfa_temp.offset. 1402 1403 Rules 6- 9: Set a non-cfa.reg register value to a constant or an 1404 expression yielding a constant. This sets cfa_temp.reg 1405 and cfa_temp.offset. 1406 1407 Rule 5: Create a new register cfa_store used to save items to the 1408 stack. 1409 1410 Rules 10-14: Save a register to the stack. Define offset as the 1411 difference of the original location and cfa_store's 1412 location (or cfa_temp's location if cfa_temp is used). 1413 1414 The Rules 1415 1416 "{a,b}" indicates a choice of a xor b. 1417 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg. 1418 1419 Rule 1: 1420 (set <reg1> <reg2>:cfa.reg) 1421 effects: cfa.reg = <reg1> 1422 cfa.offset unchanged 1423 cfa_temp.reg = <reg1> 1424 cfa_temp.offset = cfa.offset 1425 1426 Rule 2: 1427 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg 1428 {<const_int>,<reg>:cfa_temp.reg})) 1429 effects: cfa.reg = sp if fp used 1430 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp 1431 cfa_store.offset += {+/- <const_int>, cfa_temp.offset} 1432 if cfa_store.reg==sp 1433 1434 Rule 3: 1435 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>)) 1436 effects: cfa.reg = fp 1437 cfa_offset += +/- <const_int> 1438 1439 Rule 4: 1440 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>)) 1441 constraints: <reg1> != fp 1442 <reg1> != sp 1443 effects: cfa.reg = <reg1> 1444 cfa_temp.reg = <reg1> 1445 cfa_temp.offset = cfa.offset 1446 1447 Rule 5: 1448 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg)) 1449 constraints: <reg1> != fp 1450 <reg1> != sp 1451 effects: cfa_store.reg = <reg1> 1452 cfa_store.offset = cfa.offset - cfa_temp.offset 1453 1454 Rule 6: 1455 (set <reg> <const_int>) 1456 effects: cfa_temp.reg = <reg> 1457 cfa_temp.offset = <const_int> 1458 1459 Rule 7: 1460 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>)) 1461 effects: cfa_temp.reg = <reg1> 1462 cfa_temp.offset |= <const_int> 1463 1464 Rule 8: 1465 (set <reg> (high <exp>)) 1466 effects: none 1467 1468 Rule 9: 1469 (set <reg> (lo_sum <exp> <const_int>)) 1470 effects: cfa_temp.reg = <reg> 1471 cfa_temp.offset = <const_int> 1472 1473 Rule 10: 1474 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>) 1475 effects: cfa_store.offset -= <const_int> 1476 cfa.offset = cfa_store.offset if cfa.reg == sp 1477 cfa.reg = sp 1478 cfa.base_offset = -cfa_store.offset 1479 1480 Rule 11: 1481 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>) 1482 effects: cfa_store.offset += -/+ mode_size(mem) 1483 cfa.offset = cfa_store.offset if cfa.reg == sp 1484 cfa.reg = sp 1485 cfa.base_offset = -cfa_store.offset 1486 1487 Rule 12: 1488 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>)) 1489 1490 <reg2>) 1491 effects: cfa.reg = <reg1> 1492 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset 1493 1494 Rule 13: 1495 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>) 1496 effects: cfa.reg = <reg1> 1497 cfa.base_offset = -{cfa_store,cfa_temp}.offset 1498 1499 Rule 14: 1500 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>) 1501 effects: cfa.reg = <reg1> 1502 cfa.base_offset = -cfa_temp.offset 1503 cfa_temp.offset -= mode_size(mem) 1504 1505 Rule 15: 1506 (set <reg> {unspec, unspec_volatile}) 1507 effects: target-dependent */ 1508 1509static void 1510dwarf2out_frame_debug_expr (rtx expr, const char *label) 1511{ 1512 rtx src, dest; 1513 HOST_WIDE_INT offset; 1514 1515 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of 1516 the PARALLEL independently. The first element is always processed if 1517 it is a SET. This is for backward compatibility. Other elements 1518 are processed only if they are SETs and the RTX_FRAME_RELATED_P 1519 flag is set in them. */ 1520 if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE) 1521 { 1522 int par_index; 1523 int limit = XVECLEN (expr, 0); 1524 1525 for (par_index = 0; par_index < limit; par_index++) 1526 if (GET_CODE (XVECEXP (expr, 0, par_index)) == SET 1527 && (RTX_FRAME_RELATED_P (XVECEXP (expr, 0, par_index)) 1528 || par_index == 0)) 1529 dwarf2out_frame_debug_expr (XVECEXP (expr, 0, par_index), label); 1530 1531 return; 1532 } 1533 1534 gcc_assert (GET_CODE (expr) == SET); 1535 1536 src = SET_SRC (expr); 1537 dest = SET_DEST (expr); 1538 1539 if (REG_P (src)) 1540 { 1541 rtx rsi = reg_saved_in (src); 1542 if (rsi) 1543 src = rsi; 1544 } 1545 1546 switch (GET_CODE (dest)) 1547 { 1548 case REG: 1549 switch (GET_CODE (src)) 1550 { 1551 /* Setting FP from SP. */ 1552 case REG: 1553 if (cfa.reg == (unsigned) REGNO (src)) 1554 { 1555 /* Rule 1 */ 1556 /* Update the CFA rule wrt SP or FP. Make sure src is 1557 relative to the current CFA register. 1558 1559 We used to require that dest be either SP or FP, but the 1560 ARM copies SP to a temporary register, and from there to 1561 FP. So we just rely on the backends to only set 1562 RTX_FRAME_RELATED_P on appropriate insns. */ 1563 cfa.reg = REGNO (dest); 1564 cfa_temp.reg = cfa.reg; 1565 cfa_temp.offset = cfa.offset; 1566 } 1567 else 1568 { 1569 /* Saving a register in a register. */ 1570 gcc_assert (!fixed_regs [REGNO (dest)] 1571 /* For the SPARC and its register window. */ 1572 || (DWARF_FRAME_REGNUM (REGNO (src)) 1573 == DWARF_FRAME_RETURN_COLUMN)); 1574 queue_reg_save (label, src, dest, 0); 1575 } 1576 break; 1577 1578 case PLUS: 1579 case MINUS: 1580 case LO_SUM: 1581 if (dest == stack_pointer_rtx) 1582 { 1583 /* Rule 2 */ 1584 /* Adjusting SP. */ 1585 switch (GET_CODE (XEXP (src, 1))) 1586 { 1587 case CONST_INT: 1588 offset = INTVAL (XEXP (src, 1)); 1589 break; 1590 case REG: 1591 gcc_assert ((unsigned) REGNO (XEXP (src, 1)) 1592 == cfa_temp.reg); 1593 offset = cfa_temp.offset; 1594 break; 1595 default: 1596 gcc_unreachable (); 1597 } 1598 1599 if (XEXP (src, 0) == hard_frame_pointer_rtx) 1600 { 1601 /* Restoring SP from FP in the epilogue. */ 1602 gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM); 1603 cfa.reg = STACK_POINTER_REGNUM; 1604 } 1605 else if (GET_CODE (src) == LO_SUM) 1606 /* Assume we've set the source reg of the LO_SUM from sp. */ 1607 ; 1608 else 1609 gcc_assert (XEXP (src, 0) == stack_pointer_rtx); 1610 1611 if (GET_CODE (src) != MINUS) 1612 offset = -offset; 1613 if (cfa.reg == STACK_POINTER_REGNUM) 1614 cfa.offset += offset; 1615 if (cfa_store.reg == STACK_POINTER_REGNUM) 1616 cfa_store.offset += offset; 1617 } 1618 else if (dest == hard_frame_pointer_rtx) 1619 { 1620 /* Rule 3 */ 1621 /* Either setting the FP from an offset of the SP, 1622 or adjusting the FP */ 1623 gcc_assert (frame_pointer_needed); 1624 1625 gcc_assert (REG_P (XEXP (src, 0)) 1626 && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg 1627 && GET_CODE (XEXP (src, 1)) == CONST_INT); 1628 offset = INTVAL (XEXP (src, 1)); 1629 if (GET_CODE (src) != MINUS) 1630 offset = -offset; 1631 cfa.offset += offset; 1632 cfa.reg = HARD_FRAME_POINTER_REGNUM; 1633 } 1634 else 1635 { 1636 gcc_assert (GET_CODE (src) != MINUS); 1637 1638 /* Rule 4 */ 1639 if (REG_P (XEXP (src, 0)) 1640 && REGNO (XEXP (src, 0)) == cfa.reg 1641 && GET_CODE (XEXP (src, 1)) == CONST_INT) 1642 { 1643 /* Setting a temporary CFA register that will be copied 1644 into the FP later on. */ 1645 offset = - INTVAL (XEXP (src, 1)); 1646 cfa.offset += offset; 1647 cfa.reg = REGNO (dest); 1648 /* Or used to save regs to the stack. */ 1649 cfa_temp.reg = cfa.reg; 1650 cfa_temp.offset = cfa.offset; 1651 } 1652 1653 /* Rule 5 */ 1654 else if (REG_P (XEXP (src, 0)) 1655 && REGNO (XEXP (src, 0)) == cfa_temp.reg 1656 && XEXP (src, 1) == stack_pointer_rtx) 1657 { 1658 /* Setting a scratch register that we will use instead 1659 of SP for saving registers to the stack. */ 1660 gcc_assert (cfa.reg == STACK_POINTER_REGNUM); 1661 cfa_store.reg = REGNO (dest); 1662 cfa_store.offset = cfa.offset - cfa_temp.offset; 1663 } 1664 1665 /* Rule 9 */ 1666 else if (GET_CODE (src) == LO_SUM 1667 && GET_CODE (XEXP (src, 1)) == CONST_INT) 1668 { 1669 cfa_temp.reg = REGNO (dest); 1670 cfa_temp.offset = INTVAL (XEXP (src, 1)); 1671 } 1672 else 1673 gcc_unreachable (); 1674 } 1675 break; 1676 1677 /* Rule 6 */ 1678 case CONST_INT: 1679 cfa_temp.reg = REGNO (dest); 1680 cfa_temp.offset = INTVAL (src); 1681 break; 1682 1683 /* Rule 7 */ 1684 case IOR: 1685 gcc_assert (REG_P (XEXP (src, 0)) 1686 && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg 1687 && GET_CODE (XEXP (src, 1)) == CONST_INT); 1688 1689 if ((unsigned) REGNO (dest) != cfa_temp.reg) 1690 cfa_temp.reg = REGNO (dest); 1691 cfa_temp.offset |= INTVAL (XEXP (src, 1)); 1692 break; 1693 1694 /* Skip over HIGH, assuming it will be followed by a LO_SUM, 1695 which will fill in all of the bits. */ 1696 /* Rule 8 */ 1697 case HIGH: 1698 break; 1699 1700 /* Rule 15 */ 1701 case UNSPEC: 1702 case UNSPEC_VOLATILE: 1703 gcc_assert (targetm.dwarf_handle_frame_unspec); 1704 targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1)); 1705 return; 1706 1707 default: 1708 gcc_unreachable (); 1709 } 1710 1711 def_cfa_1 (label, &cfa); 1712 break; 1713 1714 case MEM: 1715 gcc_assert (REG_P (src)); 1716 1717 /* Saving a register to the stack. Make sure dest is relative to the 1718 CFA register. */ 1719 switch (GET_CODE (XEXP (dest, 0))) 1720 { 1721 /* Rule 10 */ 1722 /* With a push. */ 1723 case PRE_MODIFY: 1724 /* We can't handle variable size modifications. */ 1725 gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1)) 1726 == CONST_INT); 1727 offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1)); 1728 1729 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM 1730 && cfa_store.reg == STACK_POINTER_REGNUM); 1731 1732 cfa_store.offset += offset; 1733 if (cfa.reg == STACK_POINTER_REGNUM) 1734 cfa.offset = cfa_store.offset; 1735 1736 offset = -cfa_store.offset; 1737 break; 1738 1739 /* Rule 11 */ 1740 case PRE_INC: 1741 case PRE_DEC: 1742 offset = GET_MODE_SIZE (GET_MODE (dest)); 1743 if (GET_CODE (XEXP (dest, 0)) == PRE_INC) 1744 offset = -offset; 1745 1746 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM 1747 && cfa_store.reg == STACK_POINTER_REGNUM); 1748 1749 cfa_store.offset += offset; 1750 if (cfa.reg == STACK_POINTER_REGNUM) 1751 cfa.offset = cfa_store.offset; 1752 1753 offset = -cfa_store.offset; 1754 break; 1755 1756 /* Rule 12 */ 1757 /* With an offset. */ 1758 case PLUS: 1759 case MINUS: 1760 case LO_SUM: 1761 { 1762 int regno; 1763 1764 gcc_assert (GET_CODE (XEXP (XEXP (dest, 0), 1)) == CONST_INT 1765 && REG_P (XEXP (XEXP (dest, 0), 0))); 1766 offset = INTVAL (XEXP (XEXP (dest, 0), 1)); 1767 if (GET_CODE (XEXP (dest, 0)) == MINUS) 1768 offset = -offset; 1769 1770 regno = REGNO (XEXP (XEXP (dest, 0), 0)); 1771 1772 if (cfa_store.reg == (unsigned) regno) 1773 offset -= cfa_store.offset; 1774 else 1775 { 1776 gcc_assert (cfa_temp.reg == (unsigned) regno); 1777 offset -= cfa_temp.offset; 1778 } 1779 } 1780 break; 1781 1782 /* Rule 13 */ 1783 /* Without an offset. */ 1784 case REG: 1785 { 1786 int regno = REGNO (XEXP (dest, 0)); 1787 1788 if (cfa_store.reg == (unsigned) regno) 1789 offset = -cfa_store.offset; 1790 else 1791 { 1792 gcc_assert (cfa_temp.reg == (unsigned) regno); 1793 offset = -cfa_temp.offset; 1794 } 1795 } 1796 break; 1797 1798 /* Rule 14 */ 1799 case POST_INC: 1800 gcc_assert (cfa_temp.reg 1801 == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0))); 1802 offset = -cfa_temp.offset; 1803 cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest)); 1804 break; 1805 1806 default: 1807 gcc_unreachable (); 1808 } 1809 1810 if (REGNO (src) != STACK_POINTER_REGNUM 1811 && REGNO (src) != HARD_FRAME_POINTER_REGNUM 1812 && (unsigned) REGNO (src) == cfa.reg) 1813 { 1814 /* We're storing the current CFA reg into the stack. */ 1815 1816 if (cfa.offset == 0) 1817 { 1818 /* If the source register is exactly the CFA, assume 1819 we're saving SP like any other register; this happens 1820 on the ARM. */ 1821 def_cfa_1 (label, &cfa); 1822 queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset); 1823 break; 1824 } 1825 else 1826 { 1827 /* Otherwise, we'll need to look in the stack to 1828 calculate the CFA. */ 1829 rtx x = XEXP (dest, 0); 1830 1831 if (!REG_P (x)) 1832 x = XEXP (x, 0); 1833 gcc_assert (REG_P (x)); 1834 1835 cfa.reg = REGNO (x); 1836 cfa.base_offset = offset; 1837 cfa.indirect = 1; 1838 def_cfa_1 (label, &cfa); 1839 break; 1840 } 1841 } 1842 1843 def_cfa_1 (label, &cfa); 1844 queue_reg_save (label, src, NULL_RTX, offset); 1845 break; 1846 1847 default: 1848 gcc_unreachable (); 1849 } 1850} 1851 1852/* Record call frame debugging information for INSN, which either 1853 sets SP or FP (adjusting how we calculate the frame address) or saves a 1854 register to the stack. If INSN is NULL_RTX, initialize our state. 1855 1856 If AFTER_P is false, we're being called before the insn is emitted, 1857 otherwise after. Call instructions get invoked twice. */ 1858 1859void 1860dwarf2out_frame_debug (rtx insn, bool after_p) 1861{ 1862 const char *label; 1863 rtx src; 1864 1865 if (insn == NULL_RTX) 1866 { 1867 size_t i; 1868 1869 /* Flush any queued register saves. */ 1870 flush_queued_reg_saves (); 1871 1872 /* Set up state for generating call frame debug info. */ 1873 lookup_cfa (&cfa); 1874 gcc_assert (cfa.reg 1875 == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM)); 1876 1877 cfa.reg = STACK_POINTER_REGNUM; 1878 cfa_store = cfa; 1879 cfa_temp.reg = -1; 1880 cfa_temp.offset = 0; 1881 1882 for (i = 0; i < num_regs_saved_in_regs; i++) 1883 { 1884 regs_saved_in_regs[i].orig_reg = NULL_RTX; 1885 regs_saved_in_regs[i].saved_in_reg = NULL_RTX; 1886 } 1887 num_regs_saved_in_regs = 0; 1888 return; 1889 } 1890 1891 if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn)) 1892 flush_queued_reg_saves (); 1893 1894 if (! RTX_FRAME_RELATED_P (insn)) 1895 { 1896 if (!ACCUMULATE_OUTGOING_ARGS) 1897 dwarf2out_stack_adjust (insn, after_p); 1898 return; 1899 } 1900 1901 label = dwarf2out_cfi_label (); 1902 src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX); 1903 if (src) 1904 insn = XEXP (src, 0); 1905 else 1906 insn = PATTERN (insn); 1907 1908 dwarf2out_frame_debug_expr (insn, label); 1909} 1910 1911#endif 1912 1913/* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */ 1914static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc 1915 (enum dwarf_call_frame_info cfi); 1916 1917static enum dw_cfi_oprnd_type 1918dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi) 1919{ 1920 switch (cfi) 1921 { 1922 case DW_CFA_nop: 1923 case DW_CFA_GNU_window_save: 1924 return dw_cfi_oprnd_unused; 1925 1926 case DW_CFA_set_loc: 1927 case DW_CFA_advance_loc1: 1928 case DW_CFA_advance_loc2: 1929 case DW_CFA_advance_loc4: 1930 case DW_CFA_MIPS_advance_loc8: 1931 return dw_cfi_oprnd_addr; 1932 1933 case DW_CFA_offset: 1934 case DW_CFA_offset_extended: 1935 case DW_CFA_def_cfa: 1936 case DW_CFA_offset_extended_sf: 1937 case DW_CFA_def_cfa_sf: 1938 case DW_CFA_restore_extended: 1939 case DW_CFA_undefined: 1940 case DW_CFA_same_value: 1941 case DW_CFA_def_cfa_register: 1942 case DW_CFA_register: 1943 return dw_cfi_oprnd_reg_num; 1944 1945 case DW_CFA_def_cfa_offset: 1946 case DW_CFA_GNU_args_size: 1947 case DW_CFA_def_cfa_offset_sf: 1948 return dw_cfi_oprnd_offset; 1949 1950 case DW_CFA_def_cfa_expression: 1951 case DW_CFA_expression: 1952 return dw_cfi_oprnd_loc; 1953 1954 default: 1955 gcc_unreachable (); 1956 } 1957} 1958 1959/* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */ 1960static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc 1961 (enum dwarf_call_frame_info cfi); 1962 1963static enum dw_cfi_oprnd_type 1964dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi) 1965{ 1966 switch (cfi) 1967 { 1968 case DW_CFA_def_cfa: 1969 case DW_CFA_def_cfa_sf: 1970 case DW_CFA_offset: 1971 case DW_CFA_offset_extended_sf: 1972 case DW_CFA_offset_extended: 1973 return dw_cfi_oprnd_offset; 1974 1975 case DW_CFA_register: 1976 return dw_cfi_oprnd_reg_num; 1977 1978 default: 1979 return dw_cfi_oprnd_unused; 1980 } 1981} 1982 1983#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 1984 1985/* Switch to eh_frame_section. If we don't have an eh_frame_section, 1986 switch to the data section instead, and write out a synthetic label 1987 for collect2. */ 1988 1989static void 1990switch_to_eh_frame_section (void) 1991{ 1992 tree label; 1993 1994#ifdef EH_FRAME_SECTION_NAME 1995 if (eh_frame_section == 0) 1996 { 1997 int flags; 1998 1999 if (EH_TABLES_CAN_BE_READ_ONLY) 2000 { 2001 int fde_encoding; 2002 int per_encoding; 2003 int lsda_encoding; 2004 2005 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, 2006 /*global=*/0); 2007 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, 2008 /*global=*/1); 2009 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, 2010 /*global=*/0); 2011 flags = ((! flag_pic 2012 || ((fde_encoding & 0x70) != DW_EH_PE_absptr 2013 && (fde_encoding & 0x70) != DW_EH_PE_aligned 2014 && (per_encoding & 0x70) != DW_EH_PE_absptr 2015 && (per_encoding & 0x70) != DW_EH_PE_aligned 2016 && (lsda_encoding & 0x70) != DW_EH_PE_absptr 2017 && (lsda_encoding & 0x70) != DW_EH_PE_aligned)) 2018 ? 0 : SECTION_WRITE); 2019 } 2020 else 2021 flags = SECTION_WRITE; 2022 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL); 2023 } 2024#endif 2025 2026 if (eh_frame_section) 2027 switch_to_section (eh_frame_section); 2028 else 2029 { 2030 /* We have no special eh_frame section. Put the information in 2031 the data section and emit special labels to guide collect2. */ 2032 switch_to_section (data_section); 2033 label = get_file_function_name ('F'); 2034 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE)); 2035 targetm.asm_out.globalize_label (asm_out_file, 2036 IDENTIFIER_POINTER (label)); 2037 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label)); 2038 } 2039} 2040 2041/* Output a Call Frame Information opcode and its operand(s). */ 2042 2043static void 2044output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh) 2045{ 2046 unsigned long r; 2047 if (cfi->dw_cfi_opc == DW_CFA_advance_loc) 2048 dw2_asm_output_data (1, (cfi->dw_cfi_opc 2049 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)), 2050 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX, 2051 cfi->dw_cfi_oprnd1.dw_cfi_offset); 2052 else if (cfi->dw_cfi_opc == DW_CFA_offset) 2053 { 2054 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2055 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)), 2056 "DW_CFA_offset, column 0x%lx", r); 2057 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL); 2058 } 2059 else if (cfi->dw_cfi_opc == DW_CFA_restore) 2060 { 2061 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2062 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)), 2063 "DW_CFA_restore, column 0x%lx", r); 2064 } 2065 else 2066 { 2067 dw2_asm_output_data (1, cfi->dw_cfi_opc, 2068 "%s", dwarf_cfi_name (cfi->dw_cfi_opc)); 2069 2070 switch (cfi->dw_cfi_opc) 2071 { 2072 case DW_CFA_set_loc: 2073 if (for_eh) 2074 dw2_asm_output_encoded_addr_rtx ( 2075 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0), 2076 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr), 2077 false, NULL); 2078 else 2079 dw2_asm_output_addr (DWARF2_ADDR_SIZE, 2080 cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL); 2081 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 2082 break; 2083 2084 case DW_CFA_advance_loc1: 2085 dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr, 2086 fde->dw_fde_current_label, NULL); 2087 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 2088 break; 2089 2090 case DW_CFA_advance_loc2: 2091 dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr, 2092 fde->dw_fde_current_label, NULL); 2093 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 2094 break; 2095 2096 case DW_CFA_advance_loc4: 2097 dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr, 2098 fde->dw_fde_current_label, NULL); 2099 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 2100 break; 2101 2102 case DW_CFA_MIPS_advance_loc8: 2103 dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr, 2104 fde->dw_fde_current_label, NULL); 2105 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 2106 break; 2107 2108 case DW_CFA_offset_extended: 2109 case DW_CFA_def_cfa: 2110 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2111 dw2_asm_output_data_uleb128 (r, NULL); 2112 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL); 2113 break; 2114 2115 case DW_CFA_offset_extended_sf: 2116 case DW_CFA_def_cfa_sf: 2117 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2118 dw2_asm_output_data_uleb128 (r, NULL); 2119 dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL); 2120 break; 2121 2122 case DW_CFA_restore_extended: 2123 case DW_CFA_undefined: 2124 case DW_CFA_same_value: 2125 case DW_CFA_def_cfa_register: 2126 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2127 dw2_asm_output_data_uleb128 (r, NULL); 2128 break; 2129 2130 case DW_CFA_register: 2131 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2132 dw2_asm_output_data_uleb128 (r, NULL); 2133 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh); 2134 dw2_asm_output_data_uleb128 (r, NULL); 2135 break; 2136 2137 case DW_CFA_def_cfa_offset: 2138 case DW_CFA_GNU_args_size: 2139 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL); 2140 break; 2141 2142 case DW_CFA_def_cfa_offset_sf: 2143 dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL); 2144 break; 2145 2146 case DW_CFA_GNU_window_save: 2147 break; 2148 2149 case DW_CFA_def_cfa_expression: 2150 case DW_CFA_expression: 2151 output_cfa_loc (cfi); 2152 break; 2153 2154 case DW_CFA_GNU_negative_offset_extended: 2155 /* Obsoleted by DW_CFA_offset_extended_sf. */ 2156 gcc_unreachable (); 2157 2158 default: 2159 break; 2160 } 2161 } 2162} 2163 2164/* Output the call frame information used to record information 2165 that relates to calculating the frame pointer, and records the 2166 location of saved registers. */ 2167 2168static void 2169output_call_frame_info (int for_eh) 2170{ 2171 unsigned int i; 2172 dw_fde_ref fde; 2173 dw_cfi_ref cfi; 2174 char l1[20], l2[20], section_start_label[20]; 2175 bool any_lsda_needed = false; 2176 char augmentation[6]; 2177 int augmentation_size; 2178 int fde_encoding = DW_EH_PE_absptr; 2179 int per_encoding = DW_EH_PE_absptr; 2180 int lsda_encoding = DW_EH_PE_absptr; 2181 int return_reg; 2182 2183 /* Don't emit a CIE if there won't be any FDEs. */ 2184 if (fde_table_in_use == 0) 2185 return; 2186 2187 /* If we make FDEs linkonce, we may have to emit an empty label for 2188 an FDE that wouldn't otherwise be emitted. We want to avoid 2189 having an FDE kept around when the function it refers to is 2190 discarded. Example where this matters: a primary function 2191 template in C++ requires EH information, but an explicit 2192 specialization doesn't. */ 2193 if (TARGET_USES_WEAK_UNWIND_INFO 2194 && ! flag_asynchronous_unwind_tables 2195 && for_eh) 2196 for (i = 0; i < fde_table_in_use; i++) 2197 if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls) 2198 && !fde_table[i].uses_eh_lsda 2199 && ! DECL_WEAK (fde_table[i].decl)) 2200 targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl, 2201 for_eh, /* empty */ 1); 2202 2203 /* If we don't have any functions we'll want to unwind out of, don't 2204 emit any EH unwind information. Note that if exceptions aren't 2205 enabled, we won't have collected nothrow information, and if we 2206 asked for asynchronous tables, we always want this info. */ 2207 if (for_eh) 2208 { 2209 bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables; 2210 2211 for (i = 0; i < fde_table_in_use; i++) 2212 if (fde_table[i].uses_eh_lsda) 2213 any_eh_needed = any_lsda_needed = true; 2214 else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl)) 2215 any_eh_needed = true; 2216 else if (! fde_table[i].nothrow 2217 && ! fde_table[i].all_throwers_are_sibcalls) 2218 any_eh_needed = true; 2219 2220 if (! any_eh_needed) 2221 return; 2222 } 2223 2224 /* We're going to be generating comments, so turn on app. */ 2225 if (flag_debug_asm) 2226 app_enable (); 2227 2228 if (for_eh) 2229 switch_to_eh_frame_section (); 2230 else 2231 { 2232 if (!debug_frame_section) 2233 debug_frame_section = get_section (DEBUG_FRAME_SECTION, 2234 SECTION_DEBUG, NULL); 2235 switch_to_section (debug_frame_section); 2236 } 2237 2238 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh); 2239 ASM_OUTPUT_LABEL (asm_out_file, section_start_label); 2240 2241 /* Output the CIE. */ 2242 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh); 2243 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh); 2244 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh) 2245 dw2_asm_output_data (4, 0xffffffff, 2246 "Initial length escape value indicating 64-bit DWARF extension"); 2247 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1, 2248 "Length of Common Information Entry"); 2249 ASM_OUTPUT_LABEL (asm_out_file, l1); 2250 2251 /* Now that the CIE pointer is PC-relative for EH, 2252 use 0 to identify the CIE. */ 2253 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE), 2254 (for_eh ? 0 : DWARF_CIE_ID), 2255 "CIE Identifier Tag"); 2256 2257 dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version"); 2258 2259 augmentation[0] = 0; 2260 augmentation_size = 0; 2261 if (for_eh) 2262 { 2263 char *p; 2264 2265 /* Augmentation: 2266 z Indicates that a uleb128 is present to size the 2267 augmentation section. 2268 L Indicates the encoding (and thus presence) of 2269 an LSDA pointer in the FDE augmentation. 2270 R Indicates a non-default pointer encoding for 2271 FDE code pointers. 2272 P Indicates the presence of an encoding + language 2273 personality routine in the CIE augmentation. */ 2274 2275 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0); 2276 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1); 2277 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0); 2278 2279 p = augmentation + 1; 2280 if (eh_personality_libfunc) 2281 { 2282 *p++ = 'P'; 2283 augmentation_size += 1 + size_of_encoded_value (per_encoding); 2284 } 2285 if (any_lsda_needed) 2286 { 2287 *p++ = 'L'; 2288 augmentation_size += 1; 2289 } 2290 if (fde_encoding != DW_EH_PE_absptr) 2291 { 2292 *p++ = 'R'; 2293 augmentation_size += 1; 2294 } 2295 if (p > augmentation + 1) 2296 { 2297 augmentation[0] = 'z'; 2298 *p = '\0'; 2299 } 2300 2301 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */ 2302 if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned) 2303 { 2304 int offset = ( 4 /* Length */ 2305 + 4 /* CIE Id */ 2306 + 1 /* CIE version */ 2307 + strlen (augmentation) + 1 /* Augmentation */ 2308 + size_of_uleb128 (1) /* Code alignment */ 2309 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT) 2310 + 1 /* RA column */ 2311 + 1 /* Augmentation size */ 2312 + 1 /* Personality encoding */ ); 2313 int pad = -offset & (PTR_SIZE - 1); 2314 2315 augmentation_size += pad; 2316 2317 /* Augmentations should be small, so there's scarce need to 2318 iterate for a solution. Die if we exceed one uleb128 byte. */ 2319 gcc_assert (size_of_uleb128 (augmentation_size) == 1); 2320 } 2321 } 2322 2323 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation"); 2324 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor"); 2325 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT, 2326 "CIE Data Alignment Factor"); 2327 2328 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh); 2329 if (DW_CIE_VERSION == 1) 2330 dw2_asm_output_data (1, return_reg, "CIE RA Column"); 2331 else 2332 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column"); 2333 2334 if (augmentation[0]) 2335 { 2336 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size"); 2337 if (eh_personality_libfunc) 2338 { 2339 dw2_asm_output_data (1, per_encoding, "Personality (%s)", 2340 eh_data_format_name (per_encoding)); 2341 dw2_asm_output_encoded_addr_rtx (per_encoding, 2342 eh_personality_libfunc, 2343 true, NULL); 2344 } 2345 2346 if (any_lsda_needed) 2347 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)", 2348 eh_data_format_name (lsda_encoding)); 2349 2350 if (fde_encoding != DW_EH_PE_absptr) 2351 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)", 2352 eh_data_format_name (fde_encoding)); 2353 } 2354 2355 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next) 2356 output_cfi (cfi, NULL, for_eh); 2357 2358 /* Pad the CIE out to an address sized boundary. */ 2359 ASM_OUTPUT_ALIGN (asm_out_file, 2360 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)); 2361 ASM_OUTPUT_LABEL (asm_out_file, l2); 2362 2363 /* Loop through all of the FDE's. */ 2364 for (i = 0; i < fde_table_in_use; i++) 2365 { 2366 fde = &fde_table[i]; 2367 2368 /* Don't emit EH unwind info for leaf functions that don't need it. */ 2369 if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions 2370 && (fde->nothrow || fde->all_throwers_are_sibcalls) 2371 && ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl)) 2372 && !fde->uses_eh_lsda) 2373 continue; 2374 2375 targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh, /* empty */ 0); 2376 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL, for_eh + i * 2); 2377 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2); 2378 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2); 2379 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh) 2380 dw2_asm_output_data (4, 0xffffffff, 2381 "Initial length escape value indicating 64-bit DWARF extension"); 2382 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1, 2383 "FDE Length"); 2384 ASM_OUTPUT_LABEL (asm_out_file, l1); 2385 2386 if (for_eh) 2387 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset"); 2388 else 2389 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label, 2390 debug_frame_section, "FDE CIE offset"); 2391 2392 if (for_eh) 2393 { 2394 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin); 2395 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL; 2396 dw2_asm_output_encoded_addr_rtx (fde_encoding, 2397 sym_ref, 2398 false, 2399 "FDE initial location"); 2400 if (fde->dw_fde_switched_sections) 2401 { 2402 rtx sym_ref2 = gen_rtx_SYMBOL_REF (Pmode, 2403 fde->dw_fde_unlikely_section_label); 2404 rtx sym_ref3= gen_rtx_SYMBOL_REF (Pmode, 2405 fde->dw_fde_hot_section_label); 2406 SYMBOL_REF_FLAGS (sym_ref2) |= SYMBOL_FLAG_LOCAL; 2407 SYMBOL_REF_FLAGS (sym_ref3) |= SYMBOL_FLAG_LOCAL; 2408 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref3, false, 2409 "FDE initial location"); 2410 dw2_asm_output_delta (size_of_encoded_value (fde_encoding), 2411 fde->dw_fde_hot_section_end_label, 2412 fde->dw_fde_hot_section_label, 2413 "FDE address range"); 2414 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref2, false, 2415 "FDE initial location"); 2416 dw2_asm_output_delta (size_of_encoded_value (fde_encoding), 2417 fde->dw_fde_unlikely_section_end_label, 2418 fde->dw_fde_unlikely_section_label, 2419 "FDE address range"); 2420 } 2421 else 2422 dw2_asm_output_delta (size_of_encoded_value (fde_encoding), 2423 fde->dw_fde_end, fde->dw_fde_begin, 2424 "FDE address range"); 2425 } 2426 else 2427 { 2428 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin, 2429 "FDE initial location"); 2430 if (fde->dw_fde_switched_sections) 2431 { 2432 dw2_asm_output_addr (DWARF2_ADDR_SIZE, 2433 fde->dw_fde_hot_section_label, 2434 "FDE initial location"); 2435 dw2_asm_output_delta (DWARF2_ADDR_SIZE, 2436 fde->dw_fde_hot_section_end_label, 2437 fde->dw_fde_hot_section_label, 2438 "FDE address range"); 2439 dw2_asm_output_addr (DWARF2_ADDR_SIZE, 2440 fde->dw_fde_unlikely_section_label, 2441 "FDE initial location"); 2442 dw2_asm_output_delta (DWARF2_ADDR_SIZE, 2443 fde->dw_fde_unlikely_section_end_label, 2444 fde->dw_fde_unlikely_section_label, 2445 "FDE address range"); 2446 } 2447 else 2448 dw2_asm_output_delta (DWARF2_ADDR_SIZE, 2449 fde->dw_fde_end, fde->dw_fde_begin, 2450 "FDE address range"); 2451 } 2452 2453 if (augmentation[0]) 2454 { 2455 if (any_lsda_needed) 2456 { 2457 int size = size_of_encoded_value (lsda_encoding); 2458 2459 if (lsda_encoding == DW_EH_PE_aligned) 2460 { 2461 int offset = ( 4 /* Length */ 2462 + 4 /* CIE offset */ 2463 + 2 * size_of_encoded_value (fde_encoding) 2464 + 1 /* Augmentation size */ ); 2465 int pad = -offset & (PTR_SIZE - 1); 2466 2467 size += pad; 2468 gcc_assert (size_of_uleb128 (size) == 1); 2469 } 2470 2471 dw2_asm_output_data_uleb128 (size, "Augmentation size"); 2472 2473 if (fde->uses_eh_lsda) 2474 { 2475 ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA", 2476 fde->funcdef_number); 2477 dw2_asm_output_encoded_addr_rtx ( 2478 lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1), 2479 false, "Language Specific Data Area"); 2480 } 2481 else 2482 { 2483 if (lsda_encoding == DW_EH_PE_aligned) 2484 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE)); 2485 dw2_asm_output_data 2486 (size_of_encoded_value (lsda_encoding), 0, 2487 "Language Specific Data Area (none)"); 2488 } 2489 } 2490 else 2491 dw2_asm_output_data_uleb128 (0, "Augmentation size"); 2492 } 2493 2494 /* Loop through the Call Frame Instructions associated with 2495 this FDE. */ 2496 fde->dw_fde_current_label = fde->dw_fde_begin; 2497 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next) 2498 output_cfi (cfi, fde, for_eh); 2499 2500 /* Pad the FDE out to an address sized boundary. */ 2501 ASM_OUTPUT_ALIGN (asm_out_file, 2502 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE))); 2503 ASM_OUTPUT_LABEL (asm_out_file, l2); 2504 } 2505 2506 if (for_eh && targetm.terminate_dw2_eh_frame_info) 2507 dw2_asm_output_data (4, 0, "End of Table"); 2508#ifdef MIPS_DEBUGGING_INFO 2509 /* Work around Irix 6 assembler bug whereby labels at the end of a section 2510 get a value of 0. Putting .align 0 after the label fixes it. */ 2511 ASM_OUTPUT_ALIGN (asm_out_file, 0); 2512#endif 2513 2514 /* Turn off app to make assembly quicker. */ 2515 if (flag_debug_asm) 2516 app_disable (); 2517} 2518 2519/* Output a marker (i.e. a label) for the beginning of a function, before 2520 the prologue. */ 2521 2522void 2523dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED, 2524 const char *file ATTRIBUTE_UNUSED) 2525{ 2526 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 2527 char * dup_label; 2528 dw_fde_ref fde; 2529 2530 current_function_func_begin_label = NULL; 2531 2532#ifdef TARGET_UNWIND_INFO 2533 /* ??? current_function_func_begin_label is also used by except.c 2534 for call-site information. We must emit this label if it might 2535 be used. */ 2536 if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS) 2537 && ! dwarf2out_do_frame ()) 2538 return; 2539#else 2540 if (! dwarf2out_do_frame ()) 2541 return; 2542#endif 2543 2544 switch_to_section (function_section (current_function_decl)); 2545 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL, 2546 current_function_funcdef_no); 2547 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL, 2548 current_function_funcdef_no); 2549 dup_label = xstrdup (label); 2550 current_function_func_begin_label = dup_label; 2551 2552#ifdef TARGET_UNWIND_INFO 2553 /* We can elide the fde allocation if we're not emitting debug info. */ 2554 if (! dwarf2out_do_frame ()) 2555 return; 2556#endif 2557 2558 /* Expand the fde table if necessary. */ 2559 if (fde_table_in_use == fde_table_allocated) 2560 { 2561 fde_table_allocated += FDE_TABLE_INCREMENT; 2562 fde_table = ggc_realloc (fde_table, 2563 fde_table_allocated * sizeof (dw_fde_node)); 2564 memset (fde_table + fde_table_in_use, 0, 2565 FDE_TABLE_INCREMENT * sizeof (dw_fde_node)); 2566 } 2567 2568 /* Record the FDE associated with this function. */ 2569 current_funcdef_fde = fde_table_in_use; 2570 2571 /* Add the new FDE at the end of the fde_table. */ 2572 fde = &fde_table[fde_table_in_use++]; 2573 fde->decl = current_function_decl; 2574 fde->dw_fde_begin = dup_label; 2575 fde->dw_fde_current_label = dup_label; 2576 fde->dw_fde_hot_section_label = NULL; 2577 fde->dw_fde_hot_section_end_label = NULL; 2578 fde->dw_fde_unlikely_section_label = NULL; 2579 fde->dw_fde_unlikely_section_end_label = NULL; 2580 fde->dw_fde_switched_sections = false; 2581 fde->dw_fde_end = NULL; 2582 fde->dw_fde_cfi = NULL; 2583 fde->funcdef_number = current_function_funcdef_no; 2584 fde->nothrow = TREE_NOTHROW (current_function_decl); 2585 fde->uses_eh_lsda = cfun->uses_eh_lsda; 2586 fde->all_throwers_are_sibcalls = cfun->all_throwers_are_sibcalls; 2587 2588 args_size = old_args_size = 0; 2589 2590 /* We only want to output line number information for the genuine dwarf2 2591 prologue case, not the eh frame case. */ 2592#ifdef DWARF2_DEBUGGING_INFO 2593 if (file) 2594 dwarf2out_source_line (line, file); 2595#endif 2596} 2597 2598/* Output a marker (i.e. a label) for the absolute end of the generated code 2599 for a function definition. This gets called *after* the epilogue code has 2600 been generated. */ 2601 2602void 2603dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED, 2604 const char *file ATTRIBUTE_UNUSED) 2605{ 2606 dw_fde_ref fde; 2607 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 2608 2609 /* Output a label to mark the endpoint of the code generated for this 2610 function. */ 2611 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL, 2612 current_function_funcdef_no); 2613 ASM_OUTPUT_LABEL (asm_out_file, label); 2614 fde = &fde_table[fde_table_in_use - 1]; 2615 fde->dw_fde_end = xstrdup (label); 2616} 2617 2618void 2619dwarf2out_frame_init (void) 2620{ 2621 /* Allocate the initial hunk of the fde_table. */ 2622 fde_table = ggc_alloc_cleared (FDE_TABLE_INCREMENT * sizeof (dw_fde_node)); 2623 fde_table_allocated = FDE_TABLE_INCREMENT; 2624 fde_table_in_use = 0; 2625 2626 /* Generate the CFA instructions common to all FDE's. Do it now for the 2627 sake of lookup_cfa. */ 2628 2629 /* On entry, the Canonical Frame Address is at SP. */ 2630 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET); 2631 2632#ifdef DWARF2_UNWIND_INFO 2633 if (DWARF2_UNWIND_INFO) 2634 initial_return_save (INCOMING_RETURN_ADDR_RTX); 2635#endif 2636} 2637 2638void 2639dwarf2out_frame_finish (void) 2640{ 2641 /* Output call frame information. */ 2642 if (DWARF2_FRAME_INFO) 2643 output_call_frame_info (0); 2644 2645#ifndef TARGET_UNWIND_INFO 2646 /* Output another copy for the unwinder. */ 2647 if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions)) 2648 output_call_frame_info (1); 2649#endif 2650} 2651#endif 2652 2653/* And now, the subset of the debugging information support code necessary 2654 for emitting location expressions. */ 2655 2656/* Data about a single source file. */ 2657struct dwarf_file_data GTY(()) 2658{ 2659 const char * filename; 2660 int emitted_number; 2661}; 2662 2663/* We need some way to distinguish DW_OP_addr with a direct symbol 2664 relocation from DW_OP_addr with a dtp-relative symbol relocation. */ 2665#define INTERNAL_DW_OP_tls_addr (0x100 + DW_OP_addr) 2666 2667 2668typedef struct dw_val_struct *dw_val_ref; 2669typedef struct die_struct *dw_die_ref; 2670typedef struct dw_loc_descr_struct *dw_loc_descr_ref; 2671typedef struct dw_loc_list_struct *dw_loc_list_ref; 2672 2673/* Each DIE may have a series of attribute/value pairs. Values 2674 can take on several forms. The forms that are used in this 2675 implementation are listed below. */ 2676 2677enum dw_val_class 2678{ 2679 dw_val_class_addr, 2680 dw_val_class_offset, 2681 dw_val_class_loc, 2682 dw_val_class_loc_list, 2683 dw_val_class_range_list, 2684 dw_val_class_const, 2685 dw_val_class_unsigned_const, 2686 dw_val_class_long_long, 2687 dw_val_class_vec, 2688 dw_val_class_flag, 2689 dw_val_class_die_ref, 2690 dw_val_class_fde_ref, 2691 dw_val_class_lbl_id, 2692 dw_val_class_lineptr, 2693 dw_val_class_str, 2694 dw_val_class_macptr, 2695 dw_val_class_file 2696}; 2697 2698/* Describe a double word constant value. */ 2699/* ??? Every instance of long_long in the code really means CONST_DOUBLE. */ 2700 2701typedef struct dw_long_long_struct GTY(()) 2702{ 2703 unsigned long hi; 2704 unsigned long low; 2705} 2706dw_long_long_const; 2707 2708/* Describe a floating point constant value, or a vector constant value. */ 2709 2710typedef struct dw_vec_struct GTY(()) 2711{ 2712 unsigned char * GTY((length ("%h.length"))) array; 2713 unsigned length; 2714 unsigned elt_size; 2715} 2716dw_vec_const; 2717 2718/* The dw_val_node describes an attribute's value, as it is 2719 represented internally. */ 2720 2721typedef struct dw_val_struct GTY(()) 2722{ 2723 enum dw_val_class val_class; 2724 union dw_val_struct_union 2725 { 2726 rtx GTY ((tag ("dw_val_class_addr"))) val_addr; 2727 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset; 2728 dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list; 2729 dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc; 2730 HOST_WIDE_INT GTY ((default)) val_int; 2731 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned; 2732 dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long; 2733 dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec; 2734 struct dw_val_die_union 2735 { 2736 dw_die_ref die; 2737 int external; 2738 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref; 2739 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index; 2740 struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str; 2741 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id; 2742 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag; 2743 struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file; 2744 } 2745 GTY ((desc ("%1.val_class"))) v; 2746} 2747dw_val_node; 2748 2749/* Locations in memory are described using a sequence of stack machine 2750 operations. */ 2751 2752typedef struct dw_loc_descr_struct GTY(()) 2753{ 2754 dw_loc_descr_ref dw_loc_next; 2755 enum dwarf_location_atom dw_loc_opc; 2756 dw_val_node dw_loc_oprnd1; 2757 dw_val_node dw_loc_oprnd2; 2758 int dw_loc_addr; 2759} 2760dw_loc_descr_node; 2761 2762/* Location lists are ranges + location descriptions for that range, 2763 so you can track variables that are in different places over 2764 their entire life. */ 2765typedef struct dw_loc_list_struct GTY(()) 2766{ 2767 dw_loc_list_ref dw_loc_next; 2768 const char *begin; /* Label for begin address of range */ 2769 const char *end; /* Label for end address of range */ 2770 char *ll_symbol; /* Label for beginning of location list. 2771 Only on head of list */ 2772 const char *section; /* Section this loclist is relative to */ 2773 dw_loc_descr_ref expr; 2774} dw_loc_list_node; 2775 2776#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 2777 2778static const char *dwarf_stack_op_name (unsigned); 2779static dw_loc_descr_ref new_loc_descr (enum dwarf_location_atom, 2780 unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT); 2781static void add_loc_descr (dw_loc_descr_ref *, dw_loc_descr_ref); 2782static unsigned long size_of_loc_descr (dw_loc_descr_ref); 2783static unsigned long size_of_locs (dw_loc_descr_ref); 2784static void output_loc_operands (dw_loc_descr_ref); 2785static void output_loc_sequence (dw_loc_descr_ref); 2786 2787/* Convert a DWARF stack opcode into its string name. */ 2788 2789static const char * 2790dwarf_stack_op_name (unsigned int op) 2791{ 2792 switch (op) 2793 { 2794 case DW_OP_addr: 2795 case INTERNAL_DW_OP_tls_addr: 2796 return "DW_OP_addr"; 2797 case DW_OP_deref: 2798 return "DW_OP_deref"; 2799 case DW_OP_const1u: 2800 return "DW_OP_const1u"; 2801 case DW_OP_const1s: 2802 return "DW_OP_const1s"; 2803 case DW_OP_const2u: 2804 return "DW_OP_const2u"; 2805 case DW_OP_const2s: 2806 return "DW_OP_const2s"; 2807 case DW_OP_const4u: 2808 return "DW_OP_const4u"; 2809 case DW_OP_const4s: 2810 return "DW_OP_const4s"; 2811 case DW_OP_const8u: 2812 return "DW_OP_const8u"; 2813 case DW_OP_const8s: 2814 return "DW_OP_const8s"; 2815 case DW_OP_constu: 2816 return "DW_OP_constu"; 2817 case DW_OP_consts: 2818 return "DW_OP_consts"; 2819 case DW_OP_dup: 2820 return "DW_OP_dup"; 2821 case DW_OP_drop: 2822 return "DW_OP_drop"; 2823 case DW_OP_over: 2824 return "DW_OP_over"; 2825 case DW_OP_pick: 2826 return "DW_OP_pick"; 2827 case DW_OP_swap: 2828 return "DW_OP_swap"; 2829 case DW_OP_rot: 2830 return "DW_OP_rot"; 2831 case DW_OP_xderef: 2832 return "DW_OP_xderef"; 2833 case DW_OP_abs: 2834 return "DW_OP_abs"; 2835 case DW_OP_and: 2836 return "DW_OP_and"; 2837 case DW_OP_div: 2838 return "DW_OP_div"; 2839 case DW_OP_minus: 2840 return "DW_OP_minus"; 2841 case DW_OP_mod: 2842 return "DW_OP_mod"; 2843 case DW_OP_mul: 2844 return "DW_OP_mul"; 2845 case DW_OP_neg: 2846 return "DW_OP_neg"; 2847 case DW_OP_not: 2848 return "DW_OP_not"; 2849 case DW_OP_or: 2850 return "DW_OP_or"; 2851 case DW_OP_plus: 2852 return "DW_OP_plus"; 2853 case DW_OP_plus_uconst: 2854 return "DW_OP_plus_uconst"; 2855 case DW_OP_shl: 2856 return "DW_OP_shl"; 2857 case DW_OP_shr: 2858 return "DW_OP_shr"; 2859 case DW_OP_shra: 2860 return "DW_OP_shra"; 2861 case DW_OP_xor: 2862 return "DW_OP_xor"; 2863 case DW_OP_bra: 2864 return "DW_OP_bra"; 2865 case DW_OP_eq: 2866 return "DW_OP_eq"; 2867 case DW_OP_ge: 2868 return "DW_OP_ge"; 2869 case DW_OP_gt: 2870 return "DW_OP_gt"; 2871 case DW_OP_le: 2872 return "DW_OP_le"; 2873 case DW_OP_lt: 2874 return "DW_OP_lt"; 2875 case DW_OP_ne: 2876 return "DW_OP_ne"; 2877 case DW_OP_skip: 2878 return "DW_OP_skip"; 2879 case DW_OP_lit0: 2880 return "DW_OP_lit0"; 2881 case DW_OP_lit1: 2882 return "DW_OP_lit1"; 2883 case DW_OP_lit2: 2884 return "DW_OP_lit2"; 2885 case DW_OP_lit3: 2886 return "DW_OP_lit3"; 2887 case DW_OP_lit4: 2888 return "DW_OP_lit4"; 2889 case DW_OP_lit5: 2890 return "DW_OP_lit5"; 2891 case DW_OP_lit6: 2892 return "DW_OP_lit6"; 2893 case DW_OP_lit7: 2894 return "DW_OP_lit7"; 2895 case DW_OP_lit8: 2896 return "DW_OP_lit8"; 2897 case DW_OP_lit9: 2898 return "DW_OP_lit9"; 2899 case DW_OP_lit10: 2900 return "DW_OP_lit10"; 2901 case DW_OP_lit11: 2902 return "DW_OP_lit11"; 2903 case DW_OP_lit12: 2904 return "DW_OP_lit12"; 2905 case DW_OP_lit13: 2906 return "DW_OP_lit13"; 2907 case DW_OP_lit14: 2908 return "DW_OP_lit14"; 2909 case DW_OP_lit15: 2910 return "DW_OP_lit15"; 2911 case DW_OP_lit16: 2912 return "DW_OP_lit16"; 2913 case DW_OP_lit17: 2914 return "DW_OP_lit17"; 2915 case DW_OP_lit18: 2916 return "DW_OP_lit18"; 2917 case DW_OP_lit19: 2918 return "DW_OP_lit19"; 2919 case DW_OP_lit20: 2920 return "DW_OP_lit20"; 2921 case DW_OP_lit21: 2922 return "DW_OP_lit21"; 2923 case DW_OP_lit22: 2924 return "DW_OP_lit22"; 2925 case DW_OP_lit23: 2926 return "DW_OP_lit23"; 2927 case DW_OP_lit24: 2928 return "DW_OP_lit24"; 2929 case DW_OP_lit25: 2930 return "DW_OP_lit25"; 2931 case DW_OP_lit26: 2932 return "DW_OP_lit26"; 2933 case DW_OP_lit27: 2934 return "DW_OP_lit27"; 2935 case DW_OP_lit28: 2936 return "DW_OP_lit28"; 2937 case DW_OP_lit29: 2938 return "DW_OP_lit29"; 2939 case DW_OP_lit30: 2940 return "DW_OP_lit30"; 2941 case DW_OP_lit31: 2942 return "DW_OP_lit31"; 2943 case DW_OP_reg0: 2944 return "DW_OP_reg0"; 2945 case DW_OP_reg1: 2946 return "DW_OP_reg1"; 2947 case DW_OP_reg2: 2948 return "DW_OP_reg2"; 2949 case DW_OP_reg3: 2950 return "DW_OP_reg3"; 2951 case DW_OP_reg4: 2952 return "DW_OP_reg4"; 2953 case DW_OP_reg5: 2954 return "DW_OP_reg5"; 2955 case DW_OP_reg6: 2956 return "DW_OP_reg6"; 2957 case DW_OP_reg7: 2958 return "DW_OP_reg7"; 2959 case DW_OP_reg8: 2960 return "DW_OP_reg8"; 2961 case DW_OP_reg9: 2962 return "DW_OP_reg9"; 2963 case DW_OP_reg10: 2964 return "DW_OP_reg10"; 2965 case DW_OP_reg11: 2966 return "DW_OP_reg11"; 2967 case DW_OP_reg12: 2968 return "DW_OP_reg12"; 2969 case DW_OP_reg13: 2970 return "DW_OP_reg13"; 2971 case DW_OP_reg14: 2972 return "DW_OP_reg14"; 2973 case DW_OP_reg15: 2974 return "DW_OP_reg15"; 2975 case DW_OP_reg16: 2976 return "DW_OP_reg16"; 2977 case DW_OP_reg17: 2978 return "DW_OP_reg17"; 2979 case DW_OP_reg18: 2980 return "DW_OP_reg18"; 2981 case DW_OP_reg19: 2982 return "DW_OP_reg19"; 2983 case DW_OP_reg20: 2984 return "DW_OP_reg20"; 2985 case DW_OP_reg21: 2986 return "DW_OP_reg21"; 2987 case DW_OP_reg22: 2988 return "DW_OP_reg22"; 2989 case DW_OP_reg23: 2990 return "DW_OP_reg23"; 2991 case DW_OP_reg24: 2992 return "DW_OP_reg24"; 2993 case DW_OP_reg25: 2994 return "DW_OP_reg25"; 2995 case DW_OP_reg26: 2996 return "DW_OP_reg26"; 2997 case DW_OP_reg27: 2998 return "DW_OP_reg27"; 2999 case DW_OP_reg28: 3000 return "DW_OP_reg28"; 3001 case DW_OP_reg29: 3002 return "DW_OP_reg29"; 3003 case DW_OP_reg30: 3004 return "DW_OP_reg30"; 3005 case DW_OP_reg31: 3006 return "DW_OP_reg31"; 3007 case DW_OP_breg0: 3008 return "DW_OP_breg0"; 3009 case DW_OP_breg1: 3010 return "DW_OP_breg1"; 3011 case DW_OP_breg2: 3012 return "DW_OP_breg2"; 3013 case DW_OP_breg3: 3014 return "DW_OP_breg3"; 3015 case DW_OP_breg4: 3016 return "DW_OP_breg4"; 3017 case DW_OP_breg5: 3018 return "DW_OP_breg5"; 3019 case DW_OP_breg6: 3020 return "DW_OP_breg6"; 3021 case DW_OP_breg7: 3022 return "DW_OP_breg7"; 3023 case DW_OP_breg8: 3024 return "DW_OP_breg8"; 3025 case DW_OP_breg9: 3026 return "DW_OP_breg9"; 3027 case DW_OP_breg10: 3028 return "DW_OP_breg10"; 3029 case DW_OP_breg11: 3030 return "DW_OP_breg11"; 3031 case DW_OP_breg12: 3032 return "DW_OP_breg12"; 3033 case DW_OP_breg13: 3034 return "DW_OP_breg13"; 3035 case DW_OP_breg14: 3036 return "DW_OP_breg14"; 3037 case DW_OP_breg15: 3038 return "DW_OP_breg15"; 3039 case DW_OP_breg16: 3040 return "DW_OP_breg16"; 3041 case DW_OP_breg17: 3042 return "DW_OP_breg17"; 3043 case DW_OP_breg18: 3044 return "DW_OP_breg18"; 3045 case DW_OP_breg19: 3046 return "DW_OP_breg19"; 3047 case DW_OP_breg20: 3048 return "DW_OP_breg20"; 3049 case DW_OP_breg21: 3050 return "DW_OP_breg21"; 3051 case DW_OP_breg22: 3052 return "DW_OP_breg22"; 3053 case DW_OP_breg23: 3054 return "DW_OP_breg23"; 3055 case DW_OP_breg24: 3056 return "DW_OP_breg24"; 3057 case DW_OP_breg25: 3058 return "DW_OP_breg25"; 3059 case DW_OP_breg26: 3060 return "DW_OP_breg26"; 3061 case DW_OP_breg27: 3062 return "DW_OP_breg27"; 3063 case DW_OP_breg28: 3064 return "DW_OP_breg28"; 3065 case DW_OP_breg29: 3066 return "DW_OP_breg29"; 3067 case DW_OP_breg30: 3068 return "DW_OP_breg30"; 3069 case DW_OP_breg31: 3070 return "DW_OP_breg31"; 3071 case DW_OP_regx: 3072 return "DW_OP_regx"; 3073 case DW_OP_fbreg: 3074 return "DW_OP_fbreg"; 3075 case DW_OP_bregx: 3076 return "DW_OP_bregx"; 3077 case DW_OP_piece: 3078 return "DW_OP_piece"; 3079 case DW_OP_deref_size: 3080 return "DW_OP_deref_size"; 3081 case DW_OP_xderef_size: 3082 return "DW_OP_xderef_size"; 3083 case DW_OP_nop: 3084 return "DW_OP_nop"; 3085 case DW_OP_push_object_address: 3086 return "DW_OP_push_object_address"; 3087 case DW_OP_call2: 3088 return "DW_OP_call2"; 3089 case DW_OP_call4: 3090 return "DW_OP_call4"; 3091 case DW_OP_call_ref: 3092 return "DW_OP_call_ref"; 3093 case DW_OP_GNU_push_tls_address: 3094 return "DW_OP_GNU_push_tls_address"; 3095 default: 3096 return "OP_<unknown>"; 3097 } 3098} 3099 3100/* Return a pointer to a newly allocated location description. Location 3101 descriptions are simple expression terms that can be strung 3102 together to form more complicated location (address) descriptions. */ 3103 3104static inline dw_loc_descr_ref 3105new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1, 3106 unsigned HOST_WIDE_INT oprnd2) 3107{ 3108 dw_loc_descr_ref descr = ggc_alloc_cleared (sizeof (dw_loc_descr_node)); 3109 3110 descr->dw_loc_opc = op; 3111 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const; 3112 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1; 3113 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const; 3114 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2; 3115 3116 return descr; 3117} 3118 3119/* Add a location description term to a location description expression. */ 3120 3121static inline void 3122add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr) 3123{ 3124 dw_loc_descr_ref *d; 3125 3126 /* Find the end of the chain. */ 3127 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next) 3128 ; 3129 3130 *d = descr; 3131} 3132 3133/* Return the size of a location descriptor. */ 3134 3135static unsigned long 3136size_of_loc_descr (dw_loc_descr_ref loc) 3137{ 3138 unsigned long size = 1; 3139 3140 switch (loc->dw_loc_opc) 3141 { 3142 case DW_OP_addr: 3143 case INTERNAL_DW_OP_tls_addr: 3144 size += DWARF2_ADDR_SIZE; 3145 break; 3146 case DW_OP_const1u: 3147 case DW_OP_const1s: 3148 size += 1; 3149 break; 3150 case DW_OP_const2u: 3151 case DW_OP_const2s: 3152 size += 2; 3153 break; 3154 case DW_OP_const4u: 3155 case DW_OP_const4s: 3156 size += 4; 3157 break; 3158 case DW_OP_const8u: 3159 case DW_OP_const8s: 3160 size += 8; 3161 break; 3162 case DW_OP_constu: 3163 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 3164 break; 3165 case DW_OP_consts: 3166 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); 3167 break; 3168 case DW_OP_pick: 3169 size += 1; 3170 break; 3171 case DW_OP_plus_uconst: 3172 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 3173 break; 3174 case DW_OP_skip: 3175 case DW_OP_bra: 3176 size += 2; 3177 break; 3178 case DW_OP_breg0: 3179 case DW_OP_breg1: 3180 case DW_OP_breg2: 3181 case DW_OP_breg3: 3182 case DW_OP_breg4: 3183 case DW_OP_breg5: 3184 case DW_OP_breg6: 3185 case DW_OP_breg7: 3186 case DW_OP_breg8: 3187 case DW_OP_breg9: 3188 case DW_OP_breg10: 3189 case DW_OP_breg11: 3190 case DW_OP_breg12: 3191 case DW_OP_breg13: 3192 case DW_OP_breg14: 3193 case DW_OP_breg15: 3194 case DW_OP_breg16: 3195 case DW_OP_breg17: 3196 case DW_OP_breg18: 3197 case DW_OP_breg19: 3198 case DW_OP_breg20: 3199 case DW_OP_breg21: 3200 case DW_OP_breg22: 3201 case DW_OP_breg23: 3202 case DW_OP_breg24: 3203 case DW_OP_breg25: 3204 case DW_OP_breg26: 3205 case DW_OP_breg27: 3206 case DW_OP_breg28: 3207 case DW_OP_breg29: 3208 case DW_OP_breg30: 3209 case DW_OP_breg31: 3210 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); 3211 break; 3212 case DW_OP_regx: 3213 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 3214 break; 3215 case DW_OP_fbreg: 3216 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); 3217 break; 3218 case DW_OP_bregx: 3219 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 3220 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int); 3221 break; 3222 case DW_OP_piece: 3223 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 3224 break; 3225 case DW_OP_deref_size: 3226 case DW_OP_xderef_size: 3227 size += 1; 3228 break; 3229 case DW_OP_call2: 3230 size += 2; 3231 break; 3232 case DW_OP_call4: 3233 size += 4; 3234 break; 3235 case DW_OP_call_ref: 3236 size += DWARF2_ADDR_SIZE; 3237 break; 3238 default: 3239 break; 3240 } 3241 3242 return size; 3243} 3244 3245/* Return the size of a series of location descriptors. */ 3246 3247static unsigned long 3248size_of_locs (dw_loc_descr_ref loc) 3249{ 3250 dw_loc_descr_ref l; 3251 unsigned long size; 3252 3253 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr 3254 field, to avoid writing to a PCH file. */ 3255 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next) 3256 { 3257 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra) 3258 break; 3259 size += size_of_loc_descr (l); 3260 } 3261 if (! l) 3262 return size; 3263 3264 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next) 3265 { 3266 l->dw_loc_addr = size; 3267 size += size_of_loc_descr (l); 3268 } 3269 3270 return size; 3271} 3272 3273/* Output location description stack opcode's operands (if any). */ 3274 3275static void 3276output_loc_operands (dw_loc_descr_ref loc) 3277{ 3278 dw_val_ref val1 = &loc->dw_loc_oprnd1; 3279 dw_val_ref val2 = &loc->dw_loc_oprnd2; 3280 3281 switch (loc->dw_loc_opc) 3282 { 3283#ifdef DWARF2_DEBUGGING_INFO 3284 case DW_OP_addr: 3285 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL); 3286 break; 3287 case DW_OP_const2u: 3288 case DW_OP_const2s: 3289 dw2_asm_output_data (2, val1->v.val_int, NULL); 3290 break; 3291 case DW_OP_const4u: 3292 case DW_OP_const4s: 3293 dw2_asm_output_data (4, val1->v.val_int, NULL); 3294 break; 3295 case DW_OP_const8u: 3296 case DW_OP_const8s: 3297 gcc_assert (HOST_BITS_PER_LONG >= 64); 3298 dw2_asm_output_data (8, val1->v.val_int, NULL); 3299 break; 3300 case DW_OP_skip: 3301 case DW_OP_bra: 3302 { 3303 int offset; 3304 3305 gcc_assert (val1->val_class == dw_val_class_loc); 3306 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3); 3307 3308 dw2_asm_output_data (2, offset, NULL); 3309 } 3310 break; 3311#else 3312 case DW_OP_addr: 3313 case DW_OP_const2u: 3314 case DW_OP_const2s: 3315 case DW_OP_const4u: 3316 case DW_OP_const4s: 3317 case DW_OP_const8u: 3318 case DW_OP_const8s: 3319 case DW_OP_skip: 3320 case DW_OP_bra: 3321 /* We currently don't make any attempt to make sure these are 3322 aligned properly like we do for the main unwind info, so 3323 don't support emitting things larger than a byte if we're 3324 only doing unwinding. */ 3325 gcc_unreachable (); 3326#endif 3327 case DW_OP_const1u: 3328 case DW_OP_const1s: 3329 dw2_asm_output_data (1, val1->v.val_int, NULL); 3330 break; 3331 case DW_OP_constu: 3332 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3333 break; 3334 case DW_OP_consts: 3335 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); 3336 break; 3337 case DW_OP_pick: 3338 dw2_asm_output_data (1, val1->v.val_int, NULL); 3339 break; 3340 case DW_OP_plus_uconst: 3341 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3342 break; 3343 case DW_OP_breg0: 3344 case DW_OP_breg1: 3345 case DW_OP_breg2: 3346 case DW_OP_breg3: 3347 case DW_OP_breg4: 3348 case DW_OP_breg5: 3349 case DW_OP_breg6: 3350 case DW_OP_breg7: 3351 case DW_OP_breg8: 3352 case DW_OP_breg9: 3353 case DW_OP_breg10: 3354 case DW_OP_breg11: 3355 case DW_OP_breg12: 3356 case DW_OP_breg13: 3357 case DW_OP_breg14: 3358 case DW_OP_breg15: 3359 case DW_OP_breg16: 3360 case DW_OP_breg17: 3361 case DW_OP_breg18: 3362 case DW_OP_breg19: 3363 case DW_OP_breg20: 3364 case DW_OP_breg21: 3365 case DW_OP_breg22: 3366 case DW_OP_breg23: 3367 case DW_OP_breg24: 3368 case DW_OP_breg25: 3369 case DW_OP_breg26: 3370 case DW_OP_breg27: 3371 case DW_OP_breg28: 3372 case DW_OP_breg29: 3373 case DW_OP_breg30: 3374 case DW_OP_breg31: 3375 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); 3376 break; 3377 case DW_OP_regx: 3378 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3379 break; 3380 case DW_OP_fbreg: 3381 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); 3382 break; 3383 case DW_OP_bregx: 3384 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3385 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL); 3386 break; 3387 case DW_OP_piece: 3388 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3389 break; 3390 case DW_OP_deref_size: 3391 case DW_OP_xderef_size: 3392 dw2_asm_output_data (1, val1->v.val_int, NULL); 3393 break; 3394 3395 case INTERNAL_DW_OP_tls_addr: 3396 if (targetm.asm_out.output_dwarf_dtprel) 3397 { 3398 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 3399 DWARF2_ADDR_SIZE, 3400 val1->v.val_addr); 3401 fputc ('\n', asm_out_file); 3402 } 3403 else 3404 gcc_unreachable (); 3405 break; 3406 3407 default: 3408 /* Other codes have no operands. */ 3409 break; 3410 } 3411} 3412 3413/* Output a sequence of location operations. */ 3414 3415static void 3416output_loc_sequence (dw_loc_descr_ref loc) 3417{ 3418 for (; loc != NULL; loc = loc->dw_loc_next) 3419 { 3420 /* Output the opcode. */ 3421 dw2_asm_output_data (1, loc->dw_loc_opc, 3422 "%s", dwarf_stack_op_name (loc->dw_loc_opc)); 3423 3424 /* Output the operand(s) (if any). */ 3425 output_loc_operands (loc); 3426 } 3427} 3428 3429/* This routine will generate the correct assembly data for a location 3430 description based on a cfi entry with a complex address. */ 3431 3432static void 3433output_cfa_loc (dw_cfi_ref cfi) 3434{ 3435 dw_loc_descr_ref loc; 3436 unsigned long size; 3437 3438 /* Output the size of the block. */ 3439 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc; 3440 size = size_of_locs (loc); 3441 dw2_asm_output_data_uleb128 (size, NULL); 3442 3443 /* Now output the operations themselves. */ 3444 output_loc_sequence (loc); 3445} 3446 3447/* This function builds a dwarf location descriptor sequence from a 3448 dw_cfa_location, adding the given OFFSET to the result of the 3449 expression. */ 3450 3451static struct dw_loc_descr_struct * 3452build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset) 3453{ 3454 struct dw_loc_descr_struct *head, *tmp; 3455 3456 offset += cfa->offset; 3457 3458 if (cfa->indirect) 3459 { 3460 if (cfa->base_offset) 3461 { 3462 if (cfa->reg <= 31) 3463 head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0); 3464 else 3465 head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset); 3466 } 3467 else if (cfa->reg <= 31) 3468 head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0); 3469 else 3470 head = new_loc_descr (DW_OP_regx, cfa->reg, 0); 3471 3472 head->dw_loc_oprnd1.val_class = dw_val_class_const; 3473 tmp = new_loc_descr (DW_OP_deref, 0, 0); 3474 add_loc_descr (&head, tmp); 3475 if (offset != 0) 3476 { 3477 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0); 3478 add_loc_descr (&head, tmp); 3479 } 3480 } 3481 else 3482 { 3483 if (offset == 0) 3484 if (cfa->reg <= 31) 3485 head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0); 3486 else 3487 head = new_loc_descr (DW_OP_regx, cfa->reg, 0); 3488 else if (cfa->reg <= 31) 3489 head = new_loc_descr (DW_OP_breg0 + cfa->reg, offset, 0); 3490 else 3491 head = new_loc_descr (DW_OP_bregx, cfa->reg, offset); 3492 } 3493 3494 return head; 3495} 3496 3497/* This function fills in aa dw_cfa_location structure from a dwarf location 3498 descriptor sequence. */ 3499 3500static void 3501get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc) 3502{ 3503 struct dw_loc_descr_struct *ptr; 3504 cfa->offset = 0; 3505 cfa->base_offset = 0; 3506 cfa->indirect = 0; 3507 cfa->reg = -1; 3508 3509 for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next) 3510 { 3511 enum dwarf_location_atom op = ptr->dw_loc_opc; 3512 3513 switch (op) 3514 { 3515 case DW_OP_reg0: 3516 case DW_OP_reg1: 3517 case DW_OP_reg2: 3518 case DW_OP_reg3: 3519 case DW_OP_reg4: 3520 case DW_OP_reg5: 3521 case DW_OP_reg6: 3522 case DW_OP_reg7: 3523 case DW_OP_reg8: 3524 case DW_OP_reg9: 3525 case DW_OP_reg10: 3526 case DW_OP_reg11: 3527 case DW_OP_reg12: 3528 case DW_OP_reg13: 3529 case DW_OP_reg14: 3530 case DW_OP_reg15: 3531 case DW_OP_reg16: 3532 case DW_OP_reg17: 3533 case DW_OP_reg18: 3534 case DW_OP_reg19: 3535 case DW_OP_reg20: 3536 case DW_OP_reg21: 3537 case DW_OP_reg22: 3538 case DW_OP_reg23: 3539 case DW_OP_reg24: 3540 case DW_OP_reg25: 3541 case DW_OP_reg26: 3542 case DW_OP_reg27: 3543 case DW_OP_reg28: 3544 case DW_OP_reg29: 3545 case DW_OP_reg30: 3546 case DW_OP_reg31: 3547 cfa->reg = op - DW_OP_reg0; 3548 break; 3549 case DW_OP_regx: 3550 cfa->reg = ptr->dw_loc_oprnd1.v.val_int; 3551 break; 3552 case DW_OP_breg0: 3553 case DW_OP_breg1: 3554 case DW_OP_breg2: 3555 case DW_OP_breg3: 3556 case DW_OP_breg4: 3557 case DW_OP_breg5: 3558 case DW_OP_breg6: 3559 case DW_OP_breg7: 3560 case DW_OP_breg8: 3561 case DW_OP_breg9: 3562 case DW_OP_breg10: 3563 case DW_OP_breg11: 3564 case DW_OP_breg12: 3565 case DW_OP_breg13: 3566 case DW_OP_breg14: 3567 case DW_OP_breg15: 3568 case DW_OP_breg16: 3569 case DW_OP_breg17: 3570 case DW_OP_breg18: 3571 case DW_OP_breg19: 3572 case DW_OP_breg20: 3573 case DW_OP_breg21: 3574 case DW_OP_breg22: 3575 case DW_OP_breg23: 3576 case DW_OP_breg24: 3577 case DW_OP_breg25: 3578 case DW_OP_breg26: 3579 case DW_OP_breg27: 3580 case DW_OP_breg28: 3581 case DW_OP_breg29: 3582 case DW_OP_breg30: 3583 case DW_OP_breg31: 3584 cfa->reg = op - DW_OP_breg0; 3585 cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int; 3586 break; 3587 case DW_OP_bregx: 3588 cfa->reg = ptr->dw_loc_oprnd1.v.val_int; 3589 cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int; 3590 break; 3591 case DW_OP_deref: 3592 cfa->indirect = 1; 3593 break; 3594 case DW_OP_plus_uconst: 3595 cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned; 3596 break; 3597 default: 3598 internal_error ("DW_LOC_OP %s not implemented", 3599 dwarf_stack_op_name (ptr->dw_loc_opc)); 3600 } 3601 } 3602} 3603#endif /* .debug_frame support */ 3604 3605/* And now, the support for symbolic debugging information. */ 3606#ifdef DWARF2_DEBUGGING_INFO 3607 3608/* .debug_str support. */ 3609static int output_indirect_string (void **, void *); 3610 3611static void dwarf2out_init (const char *); 3612static void dwarf2out_finish (const char *); 3613static void dwarf2out_define (unsigned int, const char *); 3614static void dwarf2out_undef (unsigned int, const char *); 3615static void dwarf2out_start_source_file (unsigned, const char *); 3616static void dwarf2out_end_source_file (unsigned); 3617static void dwarf2out_begin_block (unsigned, unsigned); 3618static void dwarf2out_end_block (unsigned, unsigned); 3619static bool dwarf2out_ignore_block (tree); 3620static void dwarf2out_global_decl (tree); 3621static void dwarf2out_type_decl (tree, int); 3622static void dwarf2out_imported_module_or_decl (tree, tree); 3623static void dwarf2out_abstract_function (tree); 3624static void dwarf2out_var_location (rtx); 3625static void dwarf2out_begin_function (tree); 3626static void dwarf2out_switch_text_section (void); 3627 3628/* The debug hooks structure. */ 3629 3630const struct gcc_debug_hooks dwarf2_debug_hooks = 3631{ 3632 dwarf2out_init, 3633 dwarf2out_finish, 3634 dwarf2out_define, 3635 dwarf2out_undef, 3636 dwarf2out_start_source_file, 3637 dwarf2out_end_source_file, 3638 dwarf2out_begin_block, 3639 dwarf2out_end_block, 3640 dwarf2out_ignore_block, 3641 dwarf2out_source_line, 3642 dwarf2out_begin_prologue, 3643 debug_nothing_int_charstar, /* end_prologue */ 3644 dwarf2out_end_epilogue, 3645 dwarf2out_begin_function, 3646 debug_nothing_int, /* end_function */ 3647 dwarf2out_decl, /* function_decl */ 3648 dwarf2out_global_decl, 3649 dwarf2out_type_decl, /* type_decl */ 3650 dwarf2out_imported_module_or_decl, 3651 debug_nothing_tree, /* deferred_inline_function */ 3652 /* The DWARF 2 backend tries to reduce debugging bloat by not 3653 emitting the abstract description of inline functions until 3654 something tries to reference them. */ 3655 dwarf2out_abstract_function, /* outlining_inline_function */ 3656 debug_nothing_rtx, /* label */ 3657 debug_nothing_int, /* handle_pch */ 3658 dwarf2out_var_location, 3659 dwarf2out_switch_text_section, 3660 1 /* start_end_main_source_file */ 3661}; 3662#endif 3663 3664/* NOTE: In the comments in this file, many references are made to 3665 "Debugging Information Entries". This term is abbreviated as `DIE' 3666 throughout the remainder of this file. */ 3667 3668/* An internal representation of the DWARF output is built, and then 3669 walked to generate the DWARF debugging info. The walk of the internal 3670 representation is done after the entire program has been compiled. 3671 The types below are used to describe the internal representation. */ 3672 3673/* Various DIE's use offsets relative to the beginning of the 3674 .debug_info section to refer to each other. */ 3675 3676typedef long int dw_offset; 3677 3678/* Define typedefs here to avoid circular dependencies. */ 3679 3680typedef struct dw_attr_struct *dw_attr_ref; 3681typedef struct dw_line_info_struct *dw_line_info_ref; 3682typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref; 3683typedef struct pubname_struct *pubname_ref; 3684typedef struct dw_ranges_struct *dw_ranges_ref; 3685 3686/* Each entry in the line_info_table maintains the file and 3687 line number associated with the label generated for that 3688 entry. The label gives the PC value associated with 3689 the line number entry. */ 3690 3691typedef struct dw_line_info_struct GTY(()) 3692{ 3693 unsigned long dw_file_num; 3694 unsigned long dw_line_num; 3695} 3696dw_line_info_entry; 3697 3698/* Line information for functions in separate sections; each one gets its 3699 own sequence. */ 3700typedef struct dw_separate_line_info_struct GTY(()) 3701{ 3702 unsigned long dw_file_num; 3703 unsigned long dw_line_num; 3704 unsigned long function; 3705} 3706dw_separate_line_info_entry; 3707 3708/* Each DIE attribute has a field specifying the attribute kind, 3709 a link to the next attribute in the chain, and an attribute value. 3710 Attributes are typically linked below the DIE they modify. */ 3711 3712typedef struct dw_attr_struct GTY(()) 3713{ 3714 enum dwarf_attribute dw_attr; 3715 dw_val_node dw_attr_val; 3716} 3717dw_attr_node; 3718 3719DEF_VEC_O(dw_attr_node); 3720DEF_VEC_ALLOC_O(dw_attr_node,gc); 3721 3722/* The Debugging Information Entry (DIE) structure. DIEs form a tree. 3723 The children of each node form a circular list linked by 3724 die_sib. die_child points to the node *before* the "first" child node. */ 3725 3726typedef struct die_struct GTY(()) 3727{ 3728 enum dwarf_tag die_tag; 3729 char *die_symbol; 3730 VEC(dw_attr_node,gc) * die_attr; 3731 dw_die_ref die_parent; 3732 dw_die_ref die_child; 3733 dw_die_ref die_sib; 3734 dw_die_ref die_definition; /* ref from a specification to its definition */ 3735 dw_offset die_offset; 3736 unsigned long die_abbrev; 3737 int die_mark; 3738 /* Die is used and must not be pruned as unused. */ 3739 int die_perennial_p; 3740 unsigned int decl_id; 3741} 3742die_node; 3743 3744/* Evaluate 'expr' while 'c' is set to each child of DIE in order. */ 3745#define FOR_EACH_CHILD(die, c, expr) do { \ 3746 c = die->die_child; \ 3747 if (c) do { \ 3748 c = c->die_sib; \ 3749 expr; \ 3750 } while (c != die->die_child); \ 3751} while (0) 3752 3753/* The pubname structure */ 3754 3755typedef struct pubname_struct GTY(()) 3756{ 3757 dw_die_ref die; 3758 char *name; 3759} 3760pubname_entry; 3761 3762struct dw_ranges_struct GTY(()) 3763{ 3764 int block_num; 3765}; 3766 3767/* The limbo die list structure. */ 3768typedef struct limbo_die_struct GTY(()) 3769{ 3770 dw_die_ref die; 3771 tree created_for; 3772 struct limbo_die_struct *next; 3773} 3774limbo_die_node; 3775 3776/* How to start an assembler comment. */ 3777#ifndef ASM_COMMENT_START 3778#define ASM_COMMENT_START ";#" 3779#endif 3780 3781/* Define a macro which returns nonzero for a TYPE_DECL which was 3782 implicitly generated for a tagged type. 3783 3784 Note that unlike the gcc front end (which generates a NULL named 3785 TYPE_DECL node for each complete tagged type, each array type, and 3786 each function type node created) the g++ front end generates a 3787 _named_ TYPE_DECL node for each tagged type node created. 3788 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to 3789 generate a DW_TAG_typedef DIE for them. */ 3790 3791#define TYPE_DECL_IS_STUB(decl) \ 3792 (DECL_NAME (decl) == NULL_TREE \ 3793 || (DECL_ARTIFICIAL (decl) \ 3794 && is_tagged_type (TREE_TYPE (decl)) \ 3795 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \ 3796 /* This is necessary for stub decls that \ 3797 appear in nested inline functions. */ \ 3798 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \ 3799 && (decl_ultimate_origin (decl) \ 3800 == TYPE_STUB_DECL (TREE_TYPE (decl))))))) 3801 3802/* Information concerning the compilation unit's programming 3803 language, and compiler version. */ 3804 3805/* Fixed size portion of the DWARF compilation unit header. */ 3806#define DWARF_COMPILE_UNIT_HEADER_SIZE \ 3807 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3) 3808 3809/* Fixed size portion of public names info. */ 3810#define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2) 3811 3812/* Fixed size portion of the address range info. */ 3813#define DWARF_ARANGES_HEADER_SIZE \ 3814 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \ 3815 DWARF2_ADDR_SIZE * 2) \ 3816 - DWARF_INITIAL_LENGTH_SIZE) 3817 3818/* Size of padding portion in the address range info. It must be 3819 aligned to twice the pointer size. */ 3820#define DWARF_ARANGES_PAD_SIZE \ 3821 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \ 3822 DWARF2_ADDR_SIZE * 2) \ 3823 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4)) 3824 3825/* Use assembler line directives if available. */ 3826#ifndef DWARF2_ASM_LINE_DEBUG_INFO 3827#ifdef HAVE_AS_DWARF2_DEBUG_LINE 3828#define DWARF2_ASM_LINE_DEBUG_INFO 1 3829#else 3830#define DWARF2_ASM_LINE_DEBUG_INFO 0 3831#endif 3832#endif 3833 3834/* Minimum line offset in a special line info. opcode. 3835 This value was chosen to give a reasonable range of values. */ 3836#define DWARF_LINE_BASE -10 3837 3838/* First special line opcode - leave room for the standard opcodes. */ 3839#define DWARF_LINE_OPCODE_BASE 10 3840 3841/* Range of line offsets in a special line info. opcode. */ 3842#define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1) 3843 3844/* Flag that indicates the initial value of the is_stmt_start flag. 3845 In the present implementation, we do not mark any lines as 3846 the beginning of a source statement, because that information 3847 is not made available by the GCC front-end. */ 3848#define DWARF_LINE_DEFAULT_IS_STMT_START 1 3849 3850#ifdef DWARF2_DEBUGGING_INFO 3851/* This location is used by calc_die_sizes() to keep track 3852 the offset of each DIE within the .debug_info section. */ 3853static unsigned long next_die_offset; 3854#endif 3855 3856/* Record the root of the DIE's built for the current compilation unit. */ 3857static GTY(()) dw_die_ref comp_unit_die; 3858 3859/* A list of DIEs with a NULL parent waiting to be relocated. */ 3860static GTY(()) limbo_die_node *limbo_die_list; 3861 3862/* Filenames referenced by this compilation unit. */ 3863static GTY((param_is (struct dwarf_file_data))) htab_t file_table; 3864 3865/* A hash table of references to DIE's that describe declarations. 3866 The key is a DECL_UID() which is a unique number identifying each decl. */ 3867static GTY ((param_is (struct die_struct))) htab_t decl_die_table; 3868 3869/* Node of the variable location list. */ 3870struct var_loc_node GTY ((chain_next ("%h.next"))) 3871{ 3872 rtx GTY (()) var_loc_note; 3873 const char * GTY (()) label; 3874 const char * GTY (()) section_label; 3875 struct var_loc_node * GTY (()) next; 3876}; 3877 3878/* Variable location list. */ 3879struct var_loc_list_def GTY (()) 3880{ 3881 struct var_loc_node * GTY (()) first; 3882 3883 /* Do not mark the last element of the chained list because 3884 it is marked through the chain. */ 3885 struct var_loc_node * GTY ((skip ("%h"))) last; 3886 3887 /* DECL_UID of the variable decl. */ 3888 unsigned int decl_id; 3889}; 3890typedef struct var_loc_list_def var_loc_list; 3891 3892 3893/* Table of decl location linked lists. */ 3894static GTY ((param_is (var_loc_list))) htab_t decl_loc_table; 3895 3896/* A pointer to the base of a list of references to DIE's that 3897 are uniquely identified by their tag, presence/absence of 3898 children DIE's, and list of attribute/value pairs. */ 3899static GTY((length ("abbrev_die_table_allocated"))) 3900 dw_die_ref *abbrev_die_table; 3901 3902/* Number of elements currently allocated for abbrev_die_table. */ 3903static GTY(()) unsigned abbrev_die_table_allocated; 3904 3905/* Number of elements in type_die_table currently in use. */ 3906static GTY(()) unsigned abbrev_die_table_in_use; 3907 3908/* Size (in elements) of increments by which we may expand the 3909 abbrev_die_table. */ 3910#define ABBREV_DIE_TABLE_INCREMENT 256 3911 3912/* A pointer to the base of a table that contains line information 3913 for each source code line in .text in the compilation unit. */ 3914static GTY((length ("line_info_table_allocated"))) 3915 dw_line_info_ref line_info_table; 3916 3917/* Number of elements currently allocated for line_info_table. */ 3918static GTY(()) unsigned line_info_table_allocated; 3919 3920/* Number of elements in line_info_table currently in use. */ 3921static GTY(()) unsigned line_info_table_in_use; 3922 3923/* True if the compilation unit places functions in more than one section. */ 3924static GTY(()) bool have_multiple_function_sections = false; 3925 3926/* A pointer to the base of a table that contains line information 3927 for each source code line outside of .text in the compilation unit. */ 3928static GTY ((length ("separate_line_info_table_allocated"))) 3929 dw_separate_line_info_ref separate_line_info_table; 3930 3931/* Number of elements currently allocated for separate_line_info_table. */ 3932static GTY(()) unsigned separate_line_info_table_allocated; 3933 3934/* Number of elements in separate_line_info_table currently in use. */ 3935static GTY(()) unsigned separate_line_info_table_in_use; 3936 3937/* Size (in elements) of increments by which we may expand the 3938 line_info_table. */ 3939#define LINE_INFO_TABLE_INCREMENT 1024 3940 3941/* A pointer to the base of a table that contains a list of publicly 3942 accessible names. */ 3943static GTY ((length ("pubname_table_allocated"))) pubname_ref pubname_table; 3944 3945/* Number of elements currently allocated for pubname_table. */ 3946static GTY(()) unsigned pubname_table_allocated; 3947 3948/* Number of elements in pubname_table currently in use. */ 3949static GTY(()) unsigned pubname_table_in_use; 3950 3951/* Size (in elements) of increments by which we may expand the 3952 pubname_table. */ 3953#define PUBNAME_TABLE_INCREMENT 64 3954 3955/* Array of dies for which we should generate .debug_arange info. */ 3956static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table; 3957 3958/* Number of elements currently allocated for arange_table. */ 3959static GTY(()) unsigned arange_table_allocated; 3960 3961/* Number of elements in arange_table currently in use. */ 3962static GTY(()) unsigned arange_table_in_use; 3963 3964/* Size (in elements) of increments by which we may expand the 3965 arange_table. */ 3966#define ARANGE_TABLE_INCREMENT 64 3967 3968/* Array of dies for which we should generate .debug_ranges info. */ 3969static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table; 3970 3971/* Number of elements currently allocated for ranges_table. */ 3972static GTY(()) unsigned ranges_table_allocated; 3973 3974/* Number of elements in ranges_table currently in use. */ 3975static GTY(()) unsigned ranges_table_in_use; 3976 3977/* Size (in elements) of increments by which we may expand the 3978 ranges_table. */ 3979#define RANGES_TABLE_INCREMENT 64 3980 3981/* Whether we have location lists that need outputting */ 3982static GTY(()) bool have_location_lists; 3983 3984/* Unique label counter. */ 3985static GTY(()) unsigned int loclabel_num; 3986 3987#ifdef DWARF2_DEBUGGING_INFO 3988/* Record whether the function being analyzed contains inlined functions. */ 3989static int current_function_has_inlines; 3990#endif 3991#if 0 && defined (MIPS_DEBUGGING_INFO) 3992static int comp_unit_has_inlines; 3993#endif 3994 3995/* The last file entry emitted by maybe_emit_file(). */ 3996static GTY(()) struct dwarf_file_data * last_emitted_file; 3997 3998/* Number of internal labels generated by gen_internal_sym(). */ 3999static GTY(()) int label_num; 4000 4001/* Cached result of previous call to lookup_filename. */ 4002static GTY(()) struct dwarf_file_data * file_table_last_lookup; 4003 4004#ifdef DWARF2_DEBUGGING_INFO 4005 4006/* Offset from the "steady-state frame pointer" to the frame base, 4007 within the current function. */ 4008static HOST_WIDE_INT frame_pointer_fb_offset; 4009 4010/* Forward declarations for functions defined in this file. */ 4011 4012static int is_pseudo_reg (rtx); 4013static tree type_main_variant (tree); 4014static int is_tagged_type (tree); 4015static const char *dwarf_tag_name (unsigned); 4016static const char *dwarf_attr_name (unsigned); 4017static const char *dwarf_form_name (unsigned); 4018static tree decl_ultimate_origin (tree); 4019static tree block_ultimate_origin (tree); 4020static tree decl_class_context (tree); 4021static void add_dwarf_attr (dw_die_ref, dw_attr_ref); 4022static inline enum dw_val_class AT_class (dw_attr_ref); 4023static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned); 4024static inline unsigned AT_flag (dw_attr_ref); 4025static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT); 4026static inline HOST_WIDE_INT AT_int (dw_attr_ref); 4027static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT); 4028static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref); 4029static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long, 4030 unsigned long); 4031static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int, 4032 unsigned int, unsigned char *); 4033static hashval_t debug_str_do_hash (const void *); 4034static int debug_str_eq (const void *, const void *); 4035static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *); 4036static inline const char *AT_string (dw_attr_ref); 4037static int AT_string_form (dw_attr_ref); 4038static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref); 4039static void add_AT_specification (dw_die_ref, dw_die_ref); 4040static inline dw_die_ref AT_ref (dw_attr_ref); 4041static inline int AT_ref_external (dw_attr_ref); 4042static inline void set_AT_ref_external (dw_attr_ref, int); 4043static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned); 4044static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref); 4045static inline dw_loc_descr_ref AT_loc (dw_attr_ref); 4046static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute, 4047 dw_loc_list_ref); 4048static inline dw_loc_list_ref AT_loc_list (dw_attr_ref); 4049static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx); 4050static inline rtx AT_addr (dw_attr_ref); 4051static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *); 4052static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *); 4053static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *); 4054static void add_AT_offset (dw_die_ref, enum dwarf_attribute, 4055 unsigned HOST_WIDE_INT); 4056static void add_AT_range_list (dw_die_ref, enum dwarf_attribute, 4057 unsigned long); 4058static inline const char *AT_lbl (dw_attr_ref); 4059static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute); 4060static const char *get_AT_low_pc (dw_die_ref); 4061static const char *get_AT_hi_pc (dw_die_ref); 4062static const char *get_AT_string (dw_die_ref, enum dwarf_attribute); 4063static int get_AT_flag (dw_die_ref, enum dwarf_attribute); 4064static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute); 4065static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute); 4066static bool is_c_family (void); 4067static bool is_cxx (void); 4068static bool is_java (void); 4069static bool is_fortran (void); 4070static bool is_ada (void); 4071static void remove_AT (dw_die_ref, enum dwarf_attribute); 4072static void remove_child_TAG (dw_die_ref, enum dwarf_tag); 4073static void add_child_die (dw_die_ref, dw_die_ref); 4074static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree); 4075static dw_die_ref lookup_type_die (tree); 4076static void equate_type_number_to_die (tree, dw_die_ref); 4077static hashval_t decl_die_table_hash (const void *); 4078static int decl_die_table_eq (const void *, const void *); 4079static dw_die_ref lookup_decl_die (tree); 4080static hashval_t decl_loc_table_hash (const void *); 4081static int decl_loc_table_eq (const void *, const void *); 4082static var_loc_list *lookup_decl_loc (tree); 4083static void equate_decl_number_to_die (tree, dw_die_ref); 4084static void add_var_loc_to_decl (tree, struct var_loc_node *); 4085static void print_spaces (FILE *); 4086static void print_die (dw_die_ref, FILE *); 4087static void print_dwarf_line_table (FILE *); 4088static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref); 4089static dw_die_ref pop_compile_unit (dw_die_ref); 4090static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *); 4091static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *); 4092static void die_checksum (dw_die_ref, struct md5_ctx *, int *); 4093static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *); 4094static int same_dw_val_p (dw_val_node *, dw_val_node *, int *); 4095static int same_attr_p (dw_attr_ref, dw_attr_ref, int *); 4096static int same_die_p (dw_die_ref, dw_die_ref, int *); 4097static int same_die_p_wrap (dw_die_ref, dw_die_ref); 4098static void compute_section_prefix (dw_die_ref); 4099static int is_type_die (dw_die_ref); 4100static int is_comdat_die (dw_die_ref); 4101static int is_symbol_die (dw_die_ref); 4102static void assign_symbol_names (dw_die_ref); 4103static void break_out_includes (dw_die_ref); 4104static hashval_t htab_cu_hash (const void *); 4105static int htab_cu_eq (const void *, const void *); 4106static void htab_cu_del (void *); 4107static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *); 4108static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned); 4109static void add_sibling_attributes (dw_die_ref); 4110static void build_abbrev_table (dw_die_ref); 4111static void output_location_lists (dw_die_ref); 4112static int constant_size (long unsigned); 4113static unsigned long size_of_die (dw_die_ref); 4114static void calc_die_sizes (dw_die_ref); 4115static void mark_dies (dw_die_ref); 4116static void unmark_dies (dw_die_ref); 4117static void unmark_all_dies (dw_die_ref); 4118static unsigned long size_of_pubnames (void); 4119static unsigned long size_of_aranges (void); 4120static enum dwarf_form value_format (dw_attr_ref); 4121static void output_value_format (dw_attr_ref); 4122static void output_abbrev_section (void); 4123static void output_die_symbol (dw_die_ref); 4124static void output_die (dw_die_ref); 4125static void output_compilation_unit_header (void); 4126static void output_comp_unit (dw_die_ref, int); 4127static const char *dwarf2_name (tree, int); 4128static void add_pubname (tree, dw_die_ref); 4129static void output_pubnames (void); 4130static void add_arange (tree, dw_die_ref); 4131static void output_aranges (void); 4132static unsigned int add_ranges (tree); 4133static void output_ranges (void); 4134static void output_line_info (void); 4135static void output_file_names (void); 4136static dw_die_ref base_type_die (tree); 4137static tree root_type (tree); 4138static int is_base_type (tree); 4139static bool is_subrange_type (tree); 4140static dw_die_ref subrange_type_die (tree, dw_die_ref); 4141static dw_die_ref modified_type_die (tree, int, int, dw_die_ref); 4142static int type_is_enum (tree); 4143static unsigned int dbx_reg_number (rtx); 4144static void add_loc_descr_op_piece (dw_loc_descr_ref *, int); 4145static dw_loc_descr_ref reg_loc_descriptor (rtx); 4146static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int); 4147static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx); 4148static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT); 4149static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT); 4150static int is_based_loc (rtx); 4151static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode); 4152static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx); 4153static dw_loc_descr_ref loc_descriptor (rtx); 4154static dw_loc_descr_ref loc_descriptor_from_tree_1 (tree, int); 4155static dw_loc_descr_ref loc_descriptor_from_tree (tree); 4156static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int); 4157static tree field_type (tree); 4158static unsigned int simple_type_align_in_bits (tree); 4159static unsigned int simple_decl_align_in_bits (tree); 4160static unsigned HOST_WIDE_INT simple_type_size_in_bits (tree); 4161static HOST_WIDE_INT field_byte_offset (tree); 4162static void add_AT_location_description (dw_die_ref, enum dwarf_attribute, 4163 dw_loc_descr_ref); 4164static void add_data_member_location_attribute (dw_die_ref, tree); 4165static void add_const_value_attribute (dw_die_ref, rtx); 4166static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *); 4167static HOST_WIDE_INT extract_int (const unsigned char *, unsigned); 4168static void insert_float (rtx, unsigned char *); 4169static rtx rtl_for_decl_location (tree); 4170static void add_location_or_const_value_attribute (dw_die_ref, tree, 4171 enum dwarf_attribute); 4172static void tree_add_const_value_attribute (dw_die_ref, tree); 4173static void add_name_attribute (dw_die_ref, const char *); 4174static void add_comp_dir_attribute (dw_die_ref); 4175static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree); 4176static void add_subscript_info (dw_die_ref, tree); 4177static void add_byte_size_attribute (dw_die_ref, tree); 4178static void add_bit_offset_attribute (dw_die_ref, tree); 4179static void add_bit_size_attribute (dw_die_ref, tree); 4180static void add_prototyped_attribute (dw_die_ref, tree); 4181static void add_abstract_origin_attribute (dw_die_ref, tree); 4182static void add_pure_or_virtual_attribute (dw_die_ref, tree); 4183static void add_src_coords_attributes (dw_die_ref, tree); 4184static void add_name_and_src_coords_attributes (dw_die_ref, tree); 4185static void push_decl_scope (tree); 4186static void pop_decl_scope (void); 4187static dw_die_ref scope_die_for (tree, dw_die_ref); 4188static inline int local_scope_p (dw_die_ref); 4189static inline int class_or_namespace_scope_p (dw_die_ref); 4190static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref); 4191static void add_calling_convention_attribute (dw_die_ref, tree); 4192static const char *type_tag (tree); 4193static tree member_declared_type (tree); 4194#if 0 4195static const char *decl_start_label (tree); 4196#endif 4197static void gen_array_type_die (tree, dw_die_ref); 4198#if 0 4199static void gen_entry_point_die (tree, dw_die_ref); 4200#endif 4201static void gen_inlined_enumeration_type_die (tree, dw_die_ref); 4202static void gen_inlined_structure_type_die (tree, dw_die_ref); 4203static void gen_inlined_union_type_die (tree, dw_die_ref); 4204static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref); 4205static dw_die_ref gen_formal_parameter_die (tree, dw_die_ref); 4206static void gen_unspecified_parameters_die (tree, dw_die_ref); 4207static void gen_formal_types_die (tree, dw_die_ref); 4208static void gen_subprogram_die (tree, dw_die_ref); 4209static void gen_variable_die (tree, dw_die_ref); 4210static void gen_label_die (tree, dw_die_ref); 4211static void gen_lexical_block_die (tree, dw_die_ref, int); 4212static void gen_inlined_subroutine_die (tree, dw_die_ref, int); 4213static void gen_field_die (tree, dw_die_ref); 4214static void gen_ptr_to_mbr_type_die (tree, dw_die_ref); 4215static dw_die_ref gen_compile_unit_die (const char *); 4216static void gen_inheritance_die (tree, tree, dw_die_ref); 4217static void gen_member_die (tree, dw_die_ref); 4218static void gen_struct_or_union_type_die (tree, dw_die_ref, 4219 enum debug_info_usage); 4220static void gen_subroutine_type_die (tree, dw_die_ref); 4221static void gen_typedef_die (tree, dw_die_ref); 4222static void gen_type_die (tree, dw_die_ref); 4223static void gen_tagged_type_instantiation_die (tree, dw_die_ref); 4224static void gen_block_die (tree, dw_die_ref, int); 4225static void decls_for_scope (tree, dw_die_ref, int); 4226static int is_redundant_typedef (tree); 4227static void gen_namespace_die (tree); 4228static void gen_decl_die (tree, dw_die_ref); 4229static dw_die_ref force_decl_die (tree); 4230static dw_die_ref force_type_die (tree); 4231static dw_die_ref setup_namespace_context (tree, dw_die_ref); 4232static void declare_in_namespace (tree, dw_die_ref); 4233static struct dwarf_file_data * lookup_filename (const char *); 4234static void retry_incomplete_types (void); 4235static void gen_type_die_for_member (tree, tree, dw_die_ref); 4236static void splice_child_die (dw_die_ref, dw_die_ref); 4237static int file_info_cmp (const void *, const void *); 4238static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *, 4239 const char *, const char *, unsigned); 4240static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref, 4241 const char *, const char *, 4242 const char *); 4243static void output_loc_list (dw_loc_list_ref); 4244static char *gen_internal_sym (const char *); 4245 4246static void prune_unmark_dies (dw_die_ref); 4247static void prune_unused_types_mark (dw_die_ref, int); 4248static void prune_unused_types_walk (dw_die_ref); 4249static void prune_unused_types_walk_attribs (dw_die_ref); 4250static void prune_unused_types_prune (dw_die_ref); 4251static void prune_unused_types (void); 4252static int maybe_emit_file (struct dwarf_file_data *fd); 4253 4254/* Section names used to hold DWARF debugging information. */ 4255#ifndef DEBUG_INFO_SECTION 4256#define DEBUG_INFO_SECTION ".debug_info" 4257#endif 4258#ifndef DEBUG_ABBREV_SECTION 4259#define DEBUG_ABBREV_SECTION ".debug_abbrev" 4260#endif 4261#ifndef DEBUG_ARANGES_SECTION 4262#define DEBUG_ARANGES_SECTION ".debug_aranges" 4263#endif 4264#ifndef DEBUG_MACINFO_SECTION 4265#define DEBUG_MACINFO_SECTION ".debug_macinfo" 4266#endif 4267#ifndef DEBUG_LINE_SECTION 4268#define DEBUG_LINE_SECTION ".debug_line" 4269#endif 4270#ifndef DEBUG_LOC_SECTION 4271#define DEBUG_LOC_SECTION ".debug_loc" 4272#endif 4273#ifndef DEBUG_PUBNAMES_SECTION 4274#define DEBUG_PUBNAMES_SECTION ".debug_pubnames" 4275#endif 4276#ifndef DEBUG_STR_SECTION 4277#define DEBUG_STR_SECTION ".debug_str" 4278#endif 4279#ifndef DEBUG_RANGES_SECTION 4280#define DEBUG_RANGES_SECTION ".debug_ranges" 4281#endif 4282 4283/* Standard ELF section names for compiled code and data. */ 4284#ifndef TEXT_SECTION_NAME 4285#define TEXT_SECTION_NAME ".text" 4286#endif 4287 4288/* Section flags for .debug_str section. */ 4289#define DEBUG_STR_SECTION_FLAGS \ 4290 (HAVE_GAS_SHF_MERGE && flag_merge_constants \ 4291 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \ 4292 : SECTION_DEBUG) 4293 4294/* Labels we insert at beginning sections we can reference instead of 4295 the section names themselves. */ 4296 4297#ifndef TEXT_SECTION_LABEL 4298#define TEXT_SECTION_LABEL "Ltext" 4299#endif 4300#ifndef COLD_TEXT_SECTION_LABEL 4301#define COLD_TEXT_SECTION_LABEL "Ltext_cold" 4302#endif 4303#ifndef DEBUG_LINE_SECTION_LABEL 4304#define DEBUG_LINE_SECTION_LABEL "Ldebug_line" 4305#endif 4306#ifndef DEBUG_INFO_SECTION_LABEL 4307#define DEBUG_INFO_SECTION_LABEL "Ldebug_info" 4308#endif 4309#ifndef DEBUG_ABBREV_SECTION_LABEL 4310#define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev" 4311#endif 4312#ifndef DEBUG_LOC_SECTION_LABEL 4313#define DEBUG_LOC_SECTION_LABEL "Ldebug_loc" 4314#endif 4315#ifndef DEBUG_RANGES_SECTION_LABEL 4316#define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges" 4317#endif 4318#ifndef DEBUG_MACINFO_SECTION_LABEL 4319#define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo" 4320#endif 4321 4322/* Definitions of defaults for formats and names of various special 4323 (artificial) labels which may be generated within this file (when the -g 4324 options is used and DWARF2_DEBUGGING_INFO is in effect. 4325 If necessary, these may be overridden from within the tm.h file, but 4326 typically, overriding these defaults is unnecessary. */ 4327 4328static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4329static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4330static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4331static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4332static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4333static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4334static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4335static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4336static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4337static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES]; 4338 4339#ifndef TEXT_END_LABEL 4340#define TEXT_END_LABEL "Letext" 4341#endif 4342#ifndef COLD_END_LABEL 4343#define COLD_END_LABEL "Letext_cold" 4344#endif 4345#ifndef BLOCK_BEGIN_LABEL 4346#define BLOCK_BEGIN_LABEL "LBB" 4347#endif 4348#ifndef BLOCK_END_LABEL 4349#define BLOCK_END_LABEL "LBE" 4350#endif 4351#ifndef LINE_CODE_LABEL 4352#define LINE_CODE_LABEL "LM" 4353#endif 4354#ifndef SEPARATE_LINE_CODE_LABEL 4355#define SEPARATE_LINE_CODE_LABEL "LSM" 4356#endif 4357 4358/* We allow a language front-end to designate a function that is to be 4359 called to "demangle" any name before it is put into a DIE. */ 4360 4361static const char *(*demangle_name_func) (const char *); 4362 4363void 4364dwarf2out_set_demangle_name_func (const char *(*func) (const char *)) 4365{ 4366 demangle_name_func = func; 4367} 4368 4369/* Test if rtl node points to a pseudo register. */ 4370 4371static inline int 4372is_pseudo_reg (rtx rtl) 4373{ 4374 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER) 4375 || (GET_CODE (rtl) == SUBREG 4376 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER)); 4377} 4378 4379/* Return a reference to a type, with its const and volatile qualifiers 4380 removed. */ 4381 4382static inline tree 4383type_main_variant (tree type) 4384{ 4385 type = TYPE_MAIN_VARIANT (type); 4386 4387 /* ??? There really should be only one main variant among any group of 4388 variants of a given type (and all of the MAIN_VARIANT values for all 4389 members of the group should point to that one type) but sometimes the C 4390 front-end messes this up for array types, so we work around that bug 4391 here. */ 4392 if (TREE_CODE (type) == ARRAY_TYPE) 4393 while (type != TYPE_MAIN_VARIANT (type)) 4394 type = TYPE_MAIN_VARIANT (type); 4395 4396 return type; 4397} 4398 4399/* Return nonzero if the given type node represents a tagged type. */ 4400 4401static inline int 4402is_tagged_type (tree type) 4403{ 4404 enum tree_code code = TREE_CODE (type); 4405 4406 return (code == RECORD_TYPE || code == UNION_TYPE 4407 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE); 4408} 4409 4410/* Convert a DIE tag into its string name. */ 4411 4412static const char * 4413dwarf_tag_name (unsigned int tag) 4414{ 4415 switch (tag) 4416 { 4417 case DW_TAG_padding: 4418 return "DW_TAG_padding"; 4419 case DW_TAG_array_type: 4420 return "DW_TAG_array_type"; 4421 case DW_TAG_class_type: 4422 return "DW_TAG_class_type"; 4423 case DW_TAG_entry_point: 4424 return "DW_TAG_entry_point"; 4425 case DW_TAG_enumeration_type: 4426 return "DW_TAG_enumeration_type"; 4427 case DW_TAG_formal_parameter: 4428 return "DW_TAG_formal_parameter"; 4429 case DW_TAG_imported_declaration: 4430 return "DW_TAG_imported_declaration"; 4431 case DW_TAG_label: 4432 return "DW_TAG_label"; 4433 case DW_TAG_lexical_block: 4434 return "DW_TAG_lexical_block"; 4435 case DW_TAG_member: 4436 return "DW_TAG_member"; 4437 case DW_TAG_pointer_type: 4438 return "DW_TAG_pointer_type"; 4439 case DW_TAG_reference_type: 4440 return "DW_TAG_reference_type"; 4441 case DW_TAG_compile_unit: 4442 return "DW_TAG_compile_unit"; 4443 case DW_TAG_string_type: 4444 return "DW_TAG_string_type"; 4445 case DW_TAG_structure_type: 4446 return "DW_TAG_structure_type"; 4447 case DW_TAG_subroutine_type: 4448 return "DW_TAG_subroutine_type"; 4449 case DW_TAG_typedef: 4450 return "DW_TAG_typedef"; 4451 case DW_TAG_union_type: 4452 return "DW_TAG_union_type"; 4453 case DW_TAG_unspecified_parameters: 4454 return "DW_TAG_unspecified_parameters"; 4455 case DW_TAG_variant: 4456 return "DW_TAG_variant"; 4457 case DW_TAG_common_block: 4458 return "DW_TAG_common_block"; 4459 case DW_TAG_common_inclusion: 4460 return "DW_TAG_common_inclusion"; 4461 case DW_TAG_inheritance: 4462 return "DW_TAG_inheritance"; 4463 case DW_TAG_inlined_subroutine: 4464 return "DW_TAG_inlined_subroutine"; 4465 case DW_TAG_module: 4466 return "DW_TAG_module"; 4467 case DW_TAG_ptr_to_member_type: 4468 return "DW_TAG_ptr_to_member_type"; 4469 case DW_TAG_set_type: 4470 return "DW_TAG_set_type"; 4471 case DW_TAG_subrange_type: 4472 return "DW_TAG_subrange_type"; 4473 case DW_TAG_with_stmt: 4474 return "DW_TAG_with_stmt"; 4475 case DW_TAG_access_declaration: 4476 return "DW_TAG_access_declaration"; 4477 case DW_TAG_base_type: 4478 return "DW_TAG_base_type"; 4479 case DW_TAG_catch_block: 4480 return "DW_TAG_catch_block"; 4481 case DW_TAG_const_type: 4482 return "DW_TAG_const_type"; 4483 case DW_TAG_constant: 4484 return "DW_TAG_constant"; 4485 case DW_TAG_enumerator: 4486 return "DW_TAG_enumerator"; 4487 case DW_TAG_file_type: 4488 return "DW_TAG_file_type"; 4489 case DW_TAG_friend: 4490 return "DW_TAG_friend"; 4491 case DW_TAG_namelist: 4492 return "DW_TAG_namelist"; 4493 case DW_TAG_namelist_item: 4494 return "DW_TAG_namelist_item"; 4495 case DW_TAG_namespace: 4496 return "DW_TAG_namespace"; 4497 case DW_TAG_packed_type: 4498 return "DW_TAG_packed_type"; 4499 case DW_TAG_subprogram: 4500 return "DW_TAG_subprogram"; 4501 case DW_TAG_template_type_param: 4502 return "DW_TAG_template_type_param"; 4503 case DW_TAG_template_value_param: 4504 return "DW_TAG_template_value_param"; 4505 case DW_TAG_thrown_type: 4506 return "DW_TAG_thrown_type"; 4507 case DW_TAG_try_block: 4508 return "DW_TAG_try_block"; 4509 case DW_TAG_variant_part: 4510 return "DW_TAG_variant_part"; 4511 case DW_TAG_variable: 4512 return "DW_TAG_variable"; 4513 case DW_TAG_volatile_type: 4514 return "DW_TAG_volatile_type"; 4515 case DW_TAG_imported_module: 4516 return "DW_TAG_imported_module"; 4517 case DW_TAG_MIPS_loop: 4518 return "DW_TAG_MIPS_loop"; 4519 case DW_TAG_format_label: 4520 return "DW_TAG_format_label"; 4521 case DW_TAG_function_template: 4522 return "DW_TAG_function_template"; 4523 case DW_TAG_class_template: 4524 return "DW_TAG_class_template"; 4525 case DW_TAG_GNU_BINCL: 4526 return "DW_TAG_GNU_BINCL"; 4527 case DW_TAG_GNU_EINCL: 4528 return "DW_TAG_GNU_EINCL"; 4529 default: 4530 return "DW_TAG_<unknown>"; 4531 } 4532} 4533 4534/* Convert a DWARF attribute code into its string name. */ 4535 4536static const char * 4537dwarf_attr_name (unsigned int attr) 4538{ 4539 switch (attr) 4540 { 4541 case DW_AT_sibling: 4542 return "DW_AT_sibling"; 4543 case DW_AT_location: 4544 return "DW_AT_location"; 4545 case DW_AT_name: 4546 return "DW_AT_name"; 4547 case DW_AT_ordering: 4548 return "DW_AT_ordering"; 4549 case DW_AT_subscr_data: 4550 return "DW_AT_subscr_data"; 4551 case DW_AT_byte_size: 4552 return "DW_AT_byte_size"; 4553 case DW_AT_bit_offset: 4554 return "DW_AT_bit_offset"; 4555 case DW_AT_bit_size: 4556 return "DW_AT_bit_size"; 4557 case DW_AT_element_list: 4558 return "DW_AT_element_list"; 4559 case DW_AT_stmt_list: 4560 return "DW_AT_stmt_list"; 4561 case DW_AT_low_pc: 4562 return "DW_AT_low_pc"; 4563 case DW_AT_high_pc: 4564 return "DW_AT_high_pc"; 4565 case DW_AT_language: 4566 return "DW_AT_language"; 4567 case DW_AT_member: 4568 return "DW_AT_member"; 4569 case DW_AT_discr: 4570 return "DW_AT_discr"; 4571 case DW_AT_discr_value: 4572 return "DW_AT_discr_value"; 4573 case DW_AT_visibility: 4574 return "DW_AT_visibility"; 4575 case DW_AT_import: 4576 return "DW_AT_import"; 4577 case DW_AT_string_length: 4578 return "DW_AT_string_length"; 4579 case DW_AT_common_reference: 4580 return "DW_AT_common_reference"; 4581 case DW_AT_comp_dir: 4582 return "DW_AT_comp_dir"; 4583 case DW_AT_const_value: 4584 return "DW_AT_const_value"; 4585 case DW_AT_containing_type: 4586 return "DW_AT_containing_type"; 4587 case DW_AT_default_value: 4588 return "DW_AT_default_value"; 4589 case DW_AT_inline: 4590 return "DW_AT_inline"; 4591 case DW_AT_is_optional: 4592 return "DW_AT_is_optional"; 4593 case DW_AT_lower_bound: 4594 return "DW_AT_lower_bound"; 4595 case DW_AT_producer: 4596 return "DW_AT_producer"; 4597 case DW_AT_prototyped: 4598 return "DW_AT_prototyped"; 4599 case DW_AT_return_addr: 4600 return "DW_AT_return_addr"; 4601 case DW_AT_start_scope: 4602 return "DW_AT_start_scope"; 4603 case DW_AT_stride_size: 4604 return "DW_AT_stride_size"; 4605 case DW_AT_upper_bound: 4606 return "DW_AT_upper_bound"; 4607 case DW_AT_abstract_origin: 4608 return "DW_AT_abstract_origin"; 4609 case DW_AT_accessibility: 4610 return "DW_AT_accessibility"; 4611 case DW_AT_address_class: 4612 return "DW_AT_address_class"; 4613 case DW_AT_artificial: 4614 return "DW_AT_artificial"; 4615 case DW_AT_base_types: 4616 return "DW_AT_base_types"; 4617 case DW_AT_calling_convention: 4618 return "DW_AT_calling_convention"; 4619 case DW_AT_count: 4620 return "DW_AT_count"; 4621 case DW_AT_data_member_location: 4622 return "DW_AT_data_member_location"; 4623 case DW_AT_decl_column: 4624 return "DW_AT_decl_column"; 4625 case DW_AT_decl_file: 4626 return "DW_AT_decl_file"; 4627 case DW_AT_decl_line: 4628 return "DW_AT_decl_line"; 4629 case DW_AT_declaration: 4630 return "DW_AT_declaration"; 4631 case DW_AT_discr_list: 4632 return "DW_AT_discr_list"; 4633 case DW_AT_encoding: 4634 return "DW_AT_encoding"; 4635 case DW_AT_external: 4636 return "DW_AT_external"; 4637 case DW_AT_frame_base: 4638 return "DW_AT_frame_base"; 4639 case DW_AT_friend: 4640 return "DW_AT_friend"; 4641 case DW_AT_identifier_case: 4642 return "DW_AT_identifier_case"; 4643 case DW_AT_macro_info: 4644 return "DW_AT_macro_info"; 4645 case DW_AT_namelist_items: 4646 return "DW_AT_namelist_items"; 4647 case DW_AT_priority: 4648 return "DW_AT_priority"; 4649 case DW_AT_segment: 4650 return "DW_AT_segment"; 4651 case DW_AT_specification: 4652 return "DW_AT_specification"; 4653 case DW_AT_static_link: 4654 return "DW_AT_static_link"; 4655 case DW_AT_type: 4656 return "DW_AT_type"; 4657 case DW_AT_use_location: 4658 return "DW_AT_use_location"; 4659 case DW_AT_variable_parameter: 4660 return "DW_AT_variable_parameter"; 4661 case DW_AT_virtuality: 4662 return "DW_AT_virtuality"; 4663 case DW_AT_vtable_elem_location: 4664 return "DW_AT_vtable_elem_location"; 4665 4666 case DW_AT_allocated: 4667 return "DW_AT_allocated"; 4668 case DW_AT_associated: 4669 return "DW_AT_associated"; 4670 case DW_AT_data_location: 4671 return "DW_AT_data_location"; 4672 case DW_AT_stride: 4673 return "DW_AT_stride"; 4674 case DW_AT_entry_pc: 4675 return "DW_AT_entry_pc"; 4676 case DW_AT_use_UTF8: 4677 return "DW_AT_use_UTF8"; 4678 case DW_AT_extension: 4679 return "DW_AT_extension"; 4680 case DW_AT_ranges: 4681 return "DW_AT_ranges"; 4682 case DW_AT_trampoline: 4683 return "DW_AT_trampoline"; 4684 case DW_AT_call_column: 4685 return "DW_AT_call_column"; 4686 case DW_AT_call_file: 4687 return "DW_AT_call_file"; 4688 case DW_AT_call_line: 4689 return "DW_AT_call_line"; 4690 4691 case DW_AT_MIPS_fde: 4692 return "DW_AT_MIPS_fde"; 4693 case DW_AT_MIPS_loop_begin: 4694 return "DW_AT_MIPS_loop_begin"; 4695 case DW_AT_MIPS_tail_loop_begin: 4696 return "DW_AT_MIPS_tail_loop_begin"; 4697 case DW_AT_MIPS_epilog_begin: 4698 return "DW_AT_MIPS_epilog_begin"; 4699 case DW_AT_MIPS_loop_unroll_factor: 4700 return "DW_AT_MIPS_loop_unroll_factor"; 4701 case DW_AT_MIPS_software_pipeline_depth: 4702 return "DW_AT_MIPS_software_pipeline_depth"; 4703 case DW_AT_MIPS_linkage_name: 4704 return "DW_AT_MIPS_linkage_name"; 4705 case DW_AT_MIPS_stride: 4706 return "DW_AT_MIPS_stride"; 4707 case DW_AT_MIPS_abstract_name: 4708 return "DW_AT_MIPS_abstract_name"; 4709 case DW_AT_MIPS_clone_origin: 4710 return "DW_AT_MIPS_clone_origin"; 4711 case DW_AT_MIPS_has_inlines: 4712 return "DW_AT_MIPS_has_inlines"; 4713 4714 case DW_AT_sf_names: 4715 return "DW_AT_sf_names"; 4716 case DW_AT_src_info: 4717 return "DW_AT_src_info"; 4718 case DW_AT_mac_info: 4719 return "DW_AT_mac_info"; 4720 case DW_AT_src_coords: 4721 return "DW_AT_src_coords"; 4722 case DW_AT_body_begin: 4723 return "DW_AT_body_begin"; 4724 case DW_AT_body_end: 4725 return "DW_AT_body_end"; 4726 case DW_AT_GNU_vector: 4727 return "DW_AT_GNU_vector"; 4728 4729 case DW_AT_VMS_rtnbeg_pd_address: 4730 return "DW_AT_VMS_rtnbeg_pd_address"; 4731 4732 default: 4733 return "DW_AT_<unknown>"; 4734 } 4735} 4736 4737/* Convert a DWARF value form code into its string name. */ 4738 4739static const char * 4740dwarf_form_name (unsigned int form) 4741{ 4742 switch (form) 4743 { 4744 case DW_FORM_addr: 4745 return "DW_FORM_addr"; 4746 case DW_FORM_block2: 4747 return "DW_FORM_block2"; 4748 case DW_FORM_block4: 4749 return "DW_FORM_block4"; 4750 case DW_FORM_data2: 4751 return "DW_FORM_data2"; 4752 case DW_FORM_data4: 4753 return "DW_FORM_data4"; 4754 case DW_FORM_data8: 4755 return "DW_FORM_data8"; 4756 case DW_FORM_string: 4757 return "DW_FORM_string"; 4758 case DW_FORM_block: 4759 return "DW_FORM_block"; 4760 case DW_FORM_block1: 4761 return "DW_FORM_block1"; 4762 case DW_FORM_data1: 4763 return "DW_FORM_data1"; 4764 case DW_FORM_flag: 4765 return "DW_FORM_flag"; 4766 case DW_FORM_sdata: 4767 return "DW_FORM_sdata"; 4768 case DW_FORM_strp: 4769 return "DW_FORM_strp"; 4770 case DW_FORM_udata: 4771 return "DW_FORM_udata"; 4772 case DW_FORM_ref_addr: 4773 return "DW_FORM_ref_addr"; 4774 case DW_FORM_ref1: 4775 return "DW_FORM_ref1"; 4776 case DW_FORM_ref2: 4777 return "DW_FORM_ref2"; 4778 case DW_FORM_ref4: 4779 return "DW_FORM_ref4"; 4780 case DW_FORM_ref8: 4781 return "DW_FORM_ref8"; 4782 case DW_FORM_ref_udata: 4783 return "DW_FORM_ref_udata"; 4784 case DW_FORM_indirect: 4785 return "DW_FORM_indirect"; 4786 default: 4787 return "DW_FORM_<unknown>"; 4788 } 4789} 4790 4791/* Determine the "ultimate origin" of a decl. The decl may be an inlined 4792 instance of an inlined instance of a decl which is local to an inline 4793 function, so we have to trace all of the way back through the origin chain 4794 to find out what sort of node actually served as the original seed for the 4795 given block. */ 4796 4797static tree 4798decl_ultimate_origin (tree decl) 4799{ 4800 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON)) 4801 return NULL_TREE; 4802 4803 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the 4804 nodes in the function to point to themselves; ignore that if 4805 we're trying to output the abstract instance of this function. */ 4806 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl) 4807 return NULL_TREE; 4808 4809 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the 4810 most distant ancestor, this should never happen. */ 4811 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl))); 4812 4813 return DECL_ABSTRACT_ORIGIN (decl); 4814} 4815 4816/* Determine the "ultimate origin" of a block. The block may be an inlined 4817 instance of an inlined instance of a block which is local to an inline 4818 function, so we have to trace all of the way back through the origin chain 4819 to find out what sort of node actually served as the original seed for the 4820 given block. */ 4821 4822static tree 4823block_ultimate_origin (tree block) 4824{ 4825 tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block); 4826 4827 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the 4828 nodes in the function to point to themselves; ignore that if 4829 we're trying to output the abstract instance of this function. */ 4830 if (BLOCK_ABSTRACT (block) && immediate_origin == block) 4831 return NULL_TREE; 4832 4833 if (immediate_origin == NULL_TREE) 4834 return NULL_TREE; 4835 else 4836 { 4837 tree ret_val; 4838 tree lookahead = immediate_origin; 4839 4840 do 4841 { 4842 ret_val = lookahead; 4843 lookahead = (TREE_CODE (ret_val) == BLOCK 4844 ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL); 4845 } 4846 while (lookahead != NULL && lookahead != ret_val); 4847 4848 /* The block's abstract origin chain may not be the *ultimate* origin of 4849 the block. It could lead to a DECL that has an abstract origin set. 4850 If so, we want that DECL's abstract origin (which is what DECL_ORIGIN 4851 will give us if it has one). Note that DECL's abstract origins are 4852 supposed to be the most distant ancestor (or so decl_ultimate_origin 4853 claims), so we don't need to loop following the DECL origins. */ 4854 if (DECL_P (ret_val)) 4855 return DECL_ORIGIN (ret_val); 4856 4857 return ret_val; 4858 } 4859} 4860 4861/* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT 4862 of a virtual function may refer to a base class, so we check the 'this' 4863 parameter. */ 4864 4865static tree 4866decl_class_context (tree decl) 4867{ 4868 tree context = NULL_TREE; 4869 4870 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl)) 4871 context = DECL_CONTEXT (decl); 4872 else 4873 context = TYPE_MAIN_VARIANT 4874 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))))); 4875 4876 if (context && !TYPE_P (context)) 4877 context = NULL_TREE; 4878 4879 return context; 4880} 4881 4882/* Add an attribute/value pair to a DIE. */ 4883 4884static inline void 4885add_dwarf_attr (dw_die_ref die, dw_attr_ref attr) 4886{ 4887 /* Maybe this should be an assert? */ 4888 if (die == NULL) 4889 return; 4890 4891 if (die->die_attr == NULL) 4892 die->die_attr = VEC_alloc (dw_attr_node, gc, 1); 4893 VEC_safe_push (dw_attr_node, gc, die->die_attr, attr); 4894} 4895 4896static inline enum dw_val_class 4897AT_class (dw_attr_ref a) 4898{ 4899 return a->dw_attr_val.val_class; 4900} 4901 4902/* Add a flag value attribute to a DIE. */ 4903 4904static inline void 4905add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag) 4906{ 4907 dw_attr_node attr; 4908 4909 attr.dw_attr = attr_kind; 4910 attr.dw_attr_val.val_class = dw_val_class_flag; 4911 attr.dw_attr_val.v.val_flag = flag; 4912 add_dwarf_attr (die, &attr); 4913} 4914 4915static inline unsigned 4916AT_flag (dw_attr_ref a) 4917{ 4918 gcc_assert (a && AT_class (a) == dw_val_class_flag); 4919 return a->dw_attr_val.v.val_flag; 4920} 4921 4922/* Add a signed integer attribute value to a DIE. */ 4923 4924static inline void 4925add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val) 4926{ 4927 dw_attr_node attr; 4928 4929 attr.dw_attr = attr_kind; 4930 attr.dw_attr_val.val_class = dw_val_class_const; 4931 attr.dw_attr_val.v.val_int = int_val; 4932 add_dwarf_attr (die, &attr); 4933} 4934 4935static inline HOST_WIDE_INT 4936AT_int (dw_attr_ref a) 4937{ 4938 gcc_assert (a && AT_class (a) == dw_val_class_const); 4939 return a->dw_attr_val.v.val_int; 4940} 4941 4942/* Add an unsigned integer attribute value to a DIE. */ 4943 4944static inline void 4945add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind, 4946 unsigned HOST_WIDE_INT unsigned_val) 4947{ 4948 dw_attr_node attr; 4949 4950 attr.dw_attr = attr_kind; 4951 attr.dw_attr_val.val_class = dw_val_class_unsigned_const; 4952 attr.dw_attr_val.v.val_unsigned = unsigned_val; 4953 add_dwarf_attr (die, &attr); 4954} 4955 4956static inline unsigned HOST_WIDE_INT 4957AT_unsigned (dw_attr_ref a) 4958{ 4959 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const); 4960 return a->dw_attr_val.v.val_unsigned; 4961} 4962 4963/* Add an unsigned double integer attribute value to a DIE. */ 4964 4965static inline void 4966add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind, 4967 long unsigned int val_hi, long unsigned int val_low) 4968{ 4969 dw_attr_node attr; 4970 4971 attr.dw_attr = attr_kind; 4972 attr.dw_attr_val.val_class = dw_val_class_long_long; 4973 attr.dw_attr_val.v.val_long_long.hi = val_hi; 4974 attr.dw_attr_val.v.val_long_long.low = val_low; 4975 add_dwarf_attr (die, &attr); 4976} 4977 4978/* Add a floating point attribute value to a DIE and return it. */ 4979 4980static inline void 4981add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind, 4982 unsigned int length, unsigned int elt_size, unsigned char *array) 4983{ 4984 dw_attr_node attr; 4985 4986 attr.dw_attr = attr_kind; 4987 attr.dw_attr_val.val_class = dw_val_class_vec; 4988 attr.dw_attr_val.v.val_vec.length = length; 4989 attr.dw_attr_val.v.val_vec.elt_size = elt_size; 4990 attr.dw_attr_val.v.val_vec.array = array; 4991 add_dwarf_attr (die, &attr); 4992} 4993 4994/* Hash and equality functions for debug_str_hash. */ 4995 4996static hashval_t 4997debug_str_do_hash (const void *x) 4998{ 4999 return htab_hash_string (((const struct indirect_string_node *)x)->str); 5000} 5001 5002static int 5003debug_str_eq (const void *x1, const void *x2) 5004{ 5005 return strcmp ((((const struct indirect_string_node *)x1)->str), 5006 (const char *)x2) == 0; 5007} 5008 5009/* Add a string attribute value to a DIE. */ 5010 5011static inline void 5012add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str) 5013{ 5014 dw_attr_node attr; 5015 struct indirect_string_node *node; 5016 void **slot; 5017 5018 if (! debug_str_hash) 5019 debug_str_hash = htab_create_ggc (10, debug_str_do_hash, 5020 debug_str_eq, NULL); 5021 5022 slot = htab_find_slot_with_hash (debug_str_hash, str, 5023 htab_hash_string (str), INSERT); 5024 if (*slot == NULL) 5025 *slot = ggc_alloc_cleared (sizeof (struct indirect_string_node)); 5026 node = (struct indirect_string_node *) *slot; 5027 node->str = ggc_strdup (str); 5028 node->refcount++; 5029 5030 attr.dw_attr = attr_kind; 5031 attr.dw_attr_val.val_class = dw_val_class_str; 5032 attr.dw_attr_val.v.val_str = node; 5033 add_dwarf_attr (die, &attr); 5034} 5035 5036static inline const char * 5037AT_string (dw_attr_ref a) 5038{ 5039 gcc_assert (a && AT_class (a) == dw_val_class_str); 5040 return a->dw_attr_val.v.val_str->str; 5041} 5042 5043/* Find out whether a string should be output inline in DIE 5044 or out-of-line in .debug_str section. */ 5045 5046static int 5047AT_string_form (dw_attr_ref a) 5048{ 5049 struct indirect_string_node *node; 5050 unsigned int len; 5051 char label[32]; 5052 5053 gcc_assert (a && AT_class (a) == dw_val_class_str); 5054 5055 node = a->dw_attr_val.v.val_str; 5056 if (node->form) 5057 return node->form; 5058 5059 len = strlen (node->str) + 1; 5060 5061 /* If the string is shorter or equal to the size of the reference, it is 5062 always better to put it inline. */ 5063 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0) 5064 return node->form = DW_FORM_string; 5065 5066 /* If we cannot expect the linker to merge strings in .debug_str 5067 section, only put it into .debug_str if it is worth even in this 5068 single module. */ 5069 if ((debug_str_section->common.flags & SECTION_MERGE) == 0 5070 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len) 5071 return node->form = DW_FORM_string; 5072 5073 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter); 5074 ++dw2_string_counter; 5075 node->label = xstrdup (label); 5076 5077 return node->form = DW_FORM_strp; 5078} 5079 5080/* Add a DIE reference attribute value to a DIE. */ 5081 5082static inline void 5083add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die) 5084{ 5085 dw_attr_node attr; 5086 5087 attr.dw_attr = attr_kind; 5088 attr.dw_attr_val.val_class = dw_val_class_die_ref; 5089 attr.dw_attr_val.v.val_die_ref.die = targ_die; 5090 attr.dw_attr_val.v.val_die_ref.external = 0; 5091 add_dwarf_attr (die, &attr); 5092} 5093 5094/* Add an AT_specification attribute to a DIE, and also make the back 5095 pointer from the specification to the definition. */ 5096 5097static inline void 5098add_AT_specification (dw_die_ref die, dw_die_ref targ_die) 5099{ 5100 add_AT_die_ref (die, DW_AT_specification, targ_die); 5101 gcc_assert (!targ_die->die_definition); 5102 targ_die->die_definition = die; 5103} 5104 5105static inline dw_die_ref 5106AT_ref (dw_attr_ref a) 5107{ 5108 gcc_assert (a && AT_class (a) == dw_val_class_die_ref); 5109 return a->dw_attr_val.v.val_die_ref.die; 5110} 5111 5112static inline int 5113AT_ref_external (dw_attr_ref a) 5114{ 5115 if (a && AT_class (a) == dw_val_class_die_ref) 5116 return a->dw_attr_val.v.val_die_ref.external; 5117 5118 return 0; 5119} 5120 5121static inline void 5122set_AT_ref_external (dw_attr_ref a, int i) 5123{ 5124 gcc_assert (a && AT_class (a) == dw_val_class_die_ref); 5125 a->dw_attr_val.v.val_die_ref.external = i; 5126} 5127 5128/* Add an FDE reference attribute value to a DIE. */ 5129 5130static inline void 5131add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde) 5132{ 5133 dw_attr_node attr; 5134 5135 attr.dw_attr = attr_kind; 5136 attr.dw_attr_val.val_class = dw_val_class_fde_ref; 5137 attr.dw_attr_val.v.val_fde_index = targ_fde; 5138 add_dwarf_attr (die, &attr); 5139} 5140 5141/* Add a location description attribute value to a DIE. */ 5142 5143static inline void 5144add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc) 5145{ 5146 dw_attr_node attr; 5147 5148 attr.dw_attr = attr_kind; 5149 attr.dw_attr_val.val_class = dw_val_class_loc; 5150 attr.dw_attr_val.v.val_loc = loc; 5151 add_dwarf_attr (die, &attr); 5152} 5153 5154static inline dw_loc_descr_ref 5155AT_loc (dw_attr_ref a) 5156{ 5157 gcc_assert (a && AT_class (a) == dw_val_class_loc); 5158 return a->dw_attr_val.v.val_loc; 5159} 5160 5161static inline void 5162add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list) 5163{ 5164 dw_attr_node attr; 5165 5166 attr.dw_attr = attr_kind; 5167 attr.dw_attr_val.val_class = dw_val_class_loc_list; 5168 attr.dw_attr_val.v.val_loc_list = loc_list; 5169 add_dwarf_attr (die, &attr); 5170 have_location_lists = true; 5171} 5172 5173static inline dw_loc_list_ref 5174AT_loc_list (dw_attr_ref a) 5175{ 5176 gcc_assert (a && AT_class (a) == dw_val_class_loc_list); 5177 return a->dw_attr_val.v.val_loc_list; 5178} 5179 5180/* Add an address constant attribute value to a DIE. */ 5181 5182static inline void 5183add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr) 5184{ 5185 dw_attr_node attr; 5186 5187 attr.dw_attr = attr_kind; 5188 attr.dw_attr_val.val_class = dw_val_class_addr; 5189 attr.dw_attr_val.v.val_addr = addr; 5190 add_dwarf_attr (die, &attr); 5191} 5192 5193/* Get the RTX from to an address DIE attribute. */ 5194 5195static inline rtx 5196AT_addr (dw_attr_ref a) 5197{ 5198 gcc_assert (a && AT_class (a) == dw_val_class_addr); 5199 return a->dw_attr_val.v.val_addr; 5200} 5201 5202/* Add a file attribute value to a DIE. */ 5203 5204static inline void 5205add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind, 5206 struct dwarf_file_data *fd) 5207{ 5208 dw_attr_node attr; 5209 5210 attr.dw_attr = attr_kind; 5211 attr.dw_attr_val.val_class = dw_val_class_file; 5212 attr.dw_attr_val.v.val_file = fd; 5213 add_dwarf_attr (die, &attr); 5214} 5215 5216/* Get the dwarf_file_data from a file DIE attribute. */ 5217 5218static inline struct dwarf_file_data * 5219AT_file (dw_attr_ref a) 5220{ 5221 gcc_assert (a && AT_class (a) == dw_val_class_file); 5222 return a->dw_attr_val.v.val_file; 5223} 5224 5225/* Add a label identifier attribute value to a DIE. */ 5226 5227static inline void 5228add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id) 5229{ 5230 dw_attr_node attr; 5231 5232 attr.dw_attr = attr_kind; 5233 attr.dw_attr_val.val_class = dw_val_class_lbl_id; 5234 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id); 5235 add_dwarf_attr (die, &attr); 5236} 5237 5238/* Add a section offset attribute value to a DIE, an offset into the 5239 debug_line section. */ 5240 5241static inline void 5242add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind, 5243 const char *label) 5244{ 5245 dw_attr_node attr; 5246 5247 attr.dw_attr = attr_kind; 5248 attr.dw_attr_val.val_class = dw_val_class_lineptr; 5249 attr.dw_attr_val.v.val_lbl_id = xstrdup (label); 5250 add_dwarf_attr (die, &attr); 5251} 5252 5253/* Add a section offset attribute value to a DIE, an offset into the 5254 debug_macinfo section. */ 5255 5256static inline void 5257add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind, 5258 const char *label) 5259{ 5260 dw_attr_node attr; 5261 5262 attr.dw_attr = attr_kind; 5263 attr.dw_attr_val.val_class = dw_val_class_macptr; 5264 attr.dw_attr_val.v.val_lbl_id = xstrdup (label); 5265 add_dwarf_attr (die, &attr); 5266} 5267 5268/* Add an offset attribute value to a DIE. */ 5269 5270static inline void 5271add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind, 5272 unsigned HOST_WIDE_INT offset) 5273{ 5274 dw_attr_node attr; 5275 5276 attr.dw_attr = attr_kind; 5277 attr.dw_attr_val.val_class = dw_val_class_offset; 5278 attr.dw_attr_val.v.val_offset = offset; 5279 add_dwarf_attr (die, &attr); 5280} 5281 5282/* Add an range_list attribute value to a DIE. */ 5283 5284static void 5285add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind, 5286 long unsigned int offset) 5287{ 5288 dw_attr_node attr; 5289 5290 attr.dw_attr = attr_kind; 5291 attr.dw_attr_val.val_class = dw_val_class_range_list; 5292 attr.dw_attr_val.v.val_offset = offset; 5293 add_dwarf_attr (die, &attr); 5294} 5295 5296static inline const char * 5297AT_lbl (dw_attr_ref a) 5298{ 5299 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id 5300 || AT_class (a) == dw_val_class_lineptr 5301 || AT_class (a) == dw_val_class_macptr)); 5302 return a->dw_attr_val.v.val_lbl_id; 5303} 5304 5305/* Get the attribute of type attr_kind. */ 5306 5307static dw_attr_ref 5308get_AT (dw_die_ref die, enum dwarf_attribute attr_kind) 5309{ 5310 dw_attr_ref a; 5311 unsigned ix; 5312 dw_die_ref spec = NULL; 5313 5314 if (! die) 5315 return NULL; 5316 5317 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 5318 if (a->dw_attr == attr_kind) 5319 return a; 5320 else if (a->dw_attr == DW_AT_specification 5321 || a->dw_attr == DW_AT_abstract_origin) 5322 spec = AT_ref (a); 5323 5324 if (spec) 5325 return get_AT (spec, attr_kind); 5326 5327 return NULL; 5328} 5329 5330/* Return the "low pc" attribute value, typically associated with a subprogram 5331 DIE. Return null if the "low pc" attribute is either not present, or if it 5332 cannot be represented as an assembler label identifier. */ 5333 5334static inline const char * 5335get_AT_low_pc (dw_die_ref die) 5336{ 5337 dw_attr_ref a = get_AT (die, DW_AT_low_pc); 5338 5339 return a ? AT_lbl (a) : NULL; 5340} 5341 5342/* Return the "high pc" attribute value, typically associated with a subprogram 5343 DIE. Return null if the "high pc" attribute is either not present, or if it 5344 cannot be represented as an assembler label identifier. */ 5345 5346static inline const char * 5347get_AT_hi_pc (dw_die_ref die) 5348{ 5349 dw_attr_ref a = get_AT (die, DW_AT_high_pc); 5350 5351 return a ? AT_lbl (a) : NULL; 5352} 5353 5354/* Return the value of the string attribute designated by ATTR_KIND, or 5355 NULL if it is not present. */ 5356 5357static inline const char * 5358get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind) 5359{ 5360 dw_attr_ref a = get_AT (die, attr_kind); 5361 5362 return a ? AT_string (a) : NULL; 5363} 5364 5365/* Return the value of the flag attribute designated by ATTR_KIND, or -1 5366 if it is not present. */ 5367 5368static inline int 5369get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind) 5370{ 5371 dw_attr_ref a = get_AT (die, attr_kind); 5372 5373 return a ? AT_flag (a) : 0; 5374} 5375 5376/* Return the value of the unsigned attribute designated by ATTR_KIND, or 0 5377 if it is not present. */ 5378 5379static inline unsigned 5380get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind) 5381{ 5382 dw_attr_ref a = get_AT (die, attr_kind); 5383 5384 return a ? AT_unsigned (a) : 0; 5385} 5386 5387static inline dw_die_ref 5388get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind) 5389{ 5390 dw_attr_ref a = get_AT (die, attr_kind); 5391 5392 return a ? AT_ref (a) : NULL; 5393} 5394 5395static inline struct dwarf_file_data * 5396get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind) 5397{ 5398 dw_attr_ref a = get_AT (die, attr_kind); 5399 5400 return a ? AT_file (a) : NULL; 5401} 5402 5403/* Return TRUE if the language is C or C++. */ 5404 5405static inline bool 5406is_c_family (void) 5407{ 5408 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5409 5410 return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_ObjC 5411 || lang == DW_LANG_C99 5412 || lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus); 5413} 5414 5415/* Return TRUE if the language is C++. */ 5416 5417static inline bool 5418is_cxx (void) 5419{ 5420 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5421 5422 return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus; 5423} 5424 5425/* Return TRUE if the language is Fortran. */ 5426 5427static inline bool 5428is_fortran (void) 5429{ 5430 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5431 5432 return (lang == DW_LANG_Fortran77 5433 || lang == DW_LANG_Fortran90 5434 || lang == DW_LANG_Fortran95); 5435} 5436 5437/* Return TRUE if the language is Java. */ 5438 5439static inline bool 5440is_java (void) 5441{ 5442 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5443 5444 return lang == DW_LANG_Java; 5445} 5446 5447/* Return TRUE if the language is Ada. */ 5448 5449static inline bool 5450is_ada (void) 5451{ 5452 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5453 5454 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83; 5455} 5456 5457/* Remove the specified attribute if present. */ 5458 5459static void 5460remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind) 5461{ 5462 dw_attr_ref a; 5463 unsigned ix; 5464 5465 if (! die) 5466 return; 5467 5468 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 5469 if (a->dw_attr == attr_kind) 5470 { 5471 if (AT_class (a) == dw_val_class_str) 5472 if (a->dw_attr_val.v.val_str->refcount) 5473 a->dw_attr_val.v.val_str->refcount--; 5474 5475 /* VEC_ordered_remove should help reduce the number of abbrevs 5476 that are needed. */ 5477 VEC_ordered_remove (dw_attr_node, die->die_attr, ix); 5478 return; 5479 } 5480} 5481 5482/* Remove CHILD from its parent. PREV must have the property that 5483 PREV->DIE_SIB == CHILD. Does not alter CHILD. */ 5484 5485static void 5486remove_child_with_prev (dw_die_ref child, dw_die_ref prev) 5487{ 5488 gcc_assert (child->die_parent == prev->die_parent); 5489 gcc_assert (prev->die_sib == child); 5490 if (prev == child) 5491 { 5492 gcc_assert (child->die_parent->die_child == child); 5493 prev = NULL; 5494 } 5495 else 5496 prev->die_sib = child->die_sib; 5497 if (child->die_parent->die_child == child) 5498 child->die_parent->die_child = prev; 5499} 5500 5501/* Remove child DIE whose die_tag is TAG. Do nothing if no child 5502 matches TAG. */ 5503 5504static void 5505remove_child_TAG (dw_die_ref die, enum dwarf_tag tag) 5506{ 5507 dw_die_ref c; 5508 5509 c = die->die_child; 5510 if (c) do { 5511 dw_die_ref prev = c; 5512 c = c->die_sib; 5513 while (c->die_tag == tag) 5514 { 5515 remove_child_with_prev (c, prev); 5516 /* Might have removed every child. */ 5517 if (c == c->die_sib) 5518 return; 5519 c = c->die_sib; 5520 } 5521 } while (c != die->die_child); 5522} 5523 5524/* Add a CHILD_DIE as the last child of DIE. */ 5525 5526static void 5527add_child_die (dw_die_ref die, dw_die_ref child_die) 5528{ 5529 /* FIXME this should probably be an assert. */ 5530 if (! die || ! child_die) 5531 return; 5532 gcc_assert (die != child_die); 5533 5534 child_die->die_parent = die; 5535 if (die->die_child) 5536 { 5537 child_die->die_sib = die->die_child->die_sib; 5538 die->die_child->die_sib = child_die; 5539 } 5540 else 5541 child_die->die_sib = child_die; 5542 die->die_child = child_die; 5543} 5544 5545/* Move CHILD, which must be a child of PARENT or the DIE for which PARENT 5546 is the specification, to the end of PARENT's list of children. 5547 This is done by removing and re-adding it. */ 5548 5549static void 5550splice_child_die (dw_die_ref parent, dw_die_ref child) 5551{ 5552 dw_die_ref p; 5553 5554 /* We want the declaration DIE from inside the class, not the 5555 specification DIE at toplevel. */ 5556 if (child->die_parent != parent) 5557 { 5558 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification); 5559 5560 if (tmp) 5561 child = tmp; 5562 } 5563 5564 gcc_assert (child->die_parent == parent 5565 || (child->die_parent 5566 == get_AT_ref (parent, DW_AT_specification))); 5567 5568 for (p = child->die_parent->die_child; ; p = p->die_sib) 5569 if (p->die_sib == child) 5570 { 5571 remove_child_with_prev (child, p); 5572 break; 5573 } 5574 5575 add_child_die (parent, child); 5576} 5577 5578/* Return a pointer to a newly created DIE node. */ 5579 5580static inline dw_die_ref 5581new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t) 5582{ 5583 dw_die_ref die = ggc_alloc_cleared (sizeof (die_node)); 5584 5585 die->die_tag = tag_value; 5586 5587 if (parent_die != NULL) 5588 add_child_die (parent_die, die); 5589 else 5590 { 5591 limbo_die_node *limbo_node; 5592 5593 limbo_node = ggc_alloc_cleared (sizeof (limbo_die_node)); 5594 limbo_node->die = die; 5595 limbo_node->created_for = t; 5596 limbo_node->next = limbo_die_list; 5597 limbo_die_list = limbo_node; 5598 } 5599 5600 return die; 5601} 5602 5603/* Return the DIE associated with the given type specifier. */ 5604 5605static inline dw_die_ref 5606lookup_type_die (tree type) 5607{ 5608 return TYPE_SYMTAB_DIE (type); 5609} 5610 5611/* Equate a DIE to a given type specifier. */ 5612 5613static inline void 5614equate_type_number_to_die (tree type, dw_die_ref type_die) 5615{ 5616 TYPE_SYMTAB_DIE (type) = type_die; 5617} 5618 5619/* Returns a hash value for X (which really is a die_struct). */ 5620 5621static hashval_t 5622decl_die_table_hash (const void *x) 5623{ 5624 return (hashval_t) ((const dw_die_ref) x)->decl_id; 5625} 5626 5627/* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */ 5628 5629static int 5630decl_die_table_eq (const void *x, const void *y) 5631{ 5632 return (((const dw_die_ref) x)->decl_id == DECL_UID ((const tree) y)); 5633} 5634 5635/* Return the DIE associated with a given declaration. */ 5636 5637static inline dw_die_ref 5638lookup_decl_die (tree decl) 5639{ 5640 return htab_find_with_hash (decl_die_table, decl, DECL_UID (decl)); 5641} 5642 5643/* Returns a hash value for X (which really is a var_loc_list). */ 5644 5645static hashval_t 5646decl_loc_table_hash (const void *x) 5647{ 5648 return (hashval_t) ((const var_loc_list *) x)->decl_id; 5649} 5650 5651/* Return nonzero if decl_id of var_loc_list X is the same as 5652 UID of decl *Y. */ 5653 5654static int 5655decl_loc_table_eq (const void *x, const void *y) 5656{ 5657 return (((const var_loc_list *) x)->decl_id == DECL_UID ((const tree) y)); 5658} 5659 5660/* Return the var_loc list associated with a given declaration. */ 5661 5662static inline var_loc_list * 5663lookup_decl_loc (tree decl) 5664{ 5665 return htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl)); 5666} 5667 5668/* Equate a DIE to a particular declaration. */ 5669 5670static void 5671equate_decl_number_to_die (tree decl, dw_die_ref decl_die) 5672{ 5673 unsigned int decl_id = DECL_UID (decl); 5674 void **slot; 5675 5676 slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT); 5677 *slot = decl_die; 5678 decl_die->decl_id = decl_id; 5679} 5680 5681/* Add a variable location node to the linked list for DECL. */ 5682 5683static void 5684add_var_loc_to_decl (tree decl, struct var_loc_node *loc) 5685{ 5686 unsigned int decl_id = DECL_UID (decl); 5687 var_loc_list *temp; 5688 void **slot; 5689 5690 slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT); 5691 if (*slot == NULL) 5692 { 5693 temp = ggc_alloc_cleared (sizeof (var_loc_list)); 5694 temp->decl_id = decl_id; 5695 *slot = temp; 5696 } 5697 else 5698 temp = *slot; 5699 5700 if (temp->last) 5701 { 5702 /* If the current location is the same as the end of the list, 5703 we have nothing to do. */ 5704 if (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note), 5705 NOTE_VAR_LOCATION_LOC (loc->var_loc_note))) 5706 { 5707 /* Add LOC to the end of list and update LAST. */ 5708 temp->last->next = loc; 5709 temp->last = loc; 5710 } 5711 } 5712 /* Do not add empty location to the beginning of the list. */ 5713 else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX) 5714 { 5715 temp->first = loc; 5716 temp->last = loc; 5717 } 5718} 5719 5720/* Keep track of the number of spaces used to indent the 5721 output of the debugging routines that print the structure of 5722 the DIE internal representation. */ 5723static int print_indent; 5724 5725/* Indent the line the number of spaces given by print_indent. */ 5726 5727static inline void 5728print_spaces (FILE *outfile) 5729{ 5730 fprintf (outfile, "%*s", print_indent, ""); 5731} 5732 5733/* Print the information associated with a given DIE, and its children. 5734 This routine is a debugging aid only. */ 5735 5736static void 5737print_die (dw_die_ref die, FILE *outfile) 5738{ 5739 dw_attr_ref a; 5740 dw_die_ref c; 5741 unsigned ix; 5742 5743 print_spaces (outfile); 5744 fprintf (outfile, "DIE %4lu: %s\n", 5745 die->die_offset, dwarf_tag_name (die->die_tag)); 5746 print_spaces (outfile); 5747 fprintf (outfile, " abbrev id: %lu", die->die_abbrev); 5748 fprintf (outfile, " offset: %lu\n", die->die_offset); 5749 5750 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 5751 { 5752 print_spaces (outfile); 5753 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr)); 5754 5755 switch (AT_class (a)) 5756 { 5757 case dw_val_class_addr: 5758 fprintf (outfile, "address"); 5759 break; 5760 case dw_val_class_offset: 5761 fprintf (outfile, "offset"); 5762 break; 5763 case dw_val_class_loc: 5764 fprintf (outfile, "location descriptor"); 5765 break; 5766 case dw_val_class_loc_list: 5767 fprintf (outfile, "location list -> label:%s", 5768 AT_loc_list (a)->ll_symbol); 5769 break; 5770 case dw_val_class_range_list: 5771 fprintf (outfile, "range list"); 5772 break; 5773 case dw_val_class_const: 5774 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a)); 5775 break; 5776 case dw_val_class_unsigned_const: 5777 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a)); 5778 break; 5779 case dw_val_class_long_long: 5780 fprintf (outfile, "constant (%lu,%lu)", 5781 a->dw_attr_val.v.val_long_long.hi, 5782 a->dw_attr_val.v.val_long_long.low); 5783 break; 5784 case dw_val_class_vec: 5785 fprintf (outfile, "floating-point or vector constant"); 5786 break; 5787 case dw_val_class_flag: 5788 fprintf (outfile, "%u", AT_flag (a)); 5789 break; 5790 case dw_val_class_die_ref: 5791 if (AT_ref (a) != NULL) 5792 { 5793 if (AT_ref (a)->die_symbol) 5794 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol); 5795 else 5796 fprintf (outfile, "die -> %lu", AT_ref (a)->die_offset); 5797 } 5798 else 5799 fprintf (outfile, "die -> <null>"); 5800 break; 5801 case dw_val_class_lbl_id: 5802 case dw_val_class_lineptr: 5803 case dw_val_class_macptr: 5804 fprintf (outfile, "label: %s", AT_lbl (a)); 5805 break; 5806 case dw_val_class_str: 5807 if (AT_string (a) != NULL) 5808 fprintf (outfile, "\"%s\"", AT_string (a)); 5809 else 5810 fprintf (outfile, "<null>"); 5811 break; 5812 case dw_val_class_file: 5813 fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename, 5814 AT_file (a)->emitted_number); 5815 break; 5816 default: 5817 break; 5818 } 5819 5820 fprintf (outfile, "\n"); 5821 } 5822 5823 if (die->die_child != NULL) 5824 { 5825 print_indent += 4; 5826 FOR_EACH_CHILD (die, c, print_die (c, outfile)); 5827 print_indent -= 4; 5828 } 5829 if (print_indent == 0) 5830 fprintf (outfile, "\n"); 5831} 5832 5833/* Print the contents of the source code line number correspondence table. 5834 This routine is a debugging aid only. */ 5835 5836static void 5837print_dwarf_line_table (FILE *outfile) 5838{ 5839 unsigned i; 5840 dw_line_info_ref line_info; 5841 5842 fprintf (outfile, "\n\nDWARF source line information\n"); 5843 for (i = 1; i < line_info_table_in_use; i++) 5844 { 5845 line_info = &line_info_table[i]; 5846 fprintf (outfile, "%5d: %4ld %6ld\n", i, 5847 line_info->dw_file_num, 5848 line_info->dw_line_num); 5849 } 5850 5851 fprintf (outfile, "\n\n"); 5852} 5853 5854/* Print the information collected for a given DIE. */ 5855 5856void 5857debug_dwarf_die (dw_die_ref die) 5858{ 5859 print_die (die, stderr); 5860} 5861 5862/* Print all DWARF information collected for the compilation unit. 5863 This routine is a debugging aid only. */ 5864 5865void 5866debug_dwarf (void) 5867{ 5868 print_indent = 0; 5869 print_die (comp_unit_die, stderr); 5870 if (! DWARF2_ASM_LINE_DEBUG_INFO) 5871 print_dwarf_line_table (stderr); 5872} 5873 5874/* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU 5875 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL 5876 DIE that marks the start of the DIEs for this include file. */ 5877 5878static dw_die_ref 5879push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die) 5880{ 5881 const char *filename = get_AT_string (bincl_die, DW_AT_name); 5882 dw_die_ref new_unit = gen_compile_unit_die (filename); 5883 5884 new_unit->die_sib = old_unit; 5885 return new_unit; 5886} 5887 5888/* Close an include-file CU and reopen the enclosing one. */ 5889 5890static dw_die_ref 5891pop_compile_unit (dw_die_ref old_unit) 5892{ 5893 dw_die_ref new_unit = old_unit->die_sib; 5894 5895 old_unit->die_sib = NULL; 5896 return new_unit; 5897} 5898 5899#define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx) 5900#define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx) 5901 5902/* Calculate the checksum of a location expression. */ 5903 5904static inline void 5905loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx) 5906{ 5907 CHECKSUM (loc->dw_loc_opc); 5908 CHECKSUM (loc->dw_loc_oprnd1); 5909 CHECKSUM (loc->dw_loc_oprnd2); 5910} 5911 5912/* Calculate the checksum of an attribute. */ 5913 5914static void 5915attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark) 5916{ 5917 dw_loc_descr_ref loc; 5918 rtx r; 5919 5920 CHECKSUM (at->dw_attr); 5921 5922 /* We don't care that this was compiled with a different compiler 5923 snapshot; if the output is the same, that's what matters. */ 5924 if (at->dw_attr == DW_AT_producer) 5925 return; 5926 5927 switch (AT_class (at)) 5928 { 5929 case dw_val_class_const: 5930 CHECKSUM (at->dw_attr_val.v.val_int); 5931 break; 5932 case dw_val_class_unsigned_const: 5933 CHECKSUM (at->dw_attr_val.v.val_unsigned); 5934 break; 5935 case dw_val_class_long_long: 5936 CHECKSUM (at->dw_attr_val.v.val_long_long); 5937 break; 5938 case dw_val_class_vec: 5939 CHECKSUM (at->dw_attr_val.v.val_vec); 5940 break; 5941 case dw_val_class_flag: 5942 CHECKSUM (at->dw_attr_val.v.val_flag); 5943 break; 5944 case dw_val_class_str: 5945 CHECKSUM_STRING (AT_string (at)); 5946 break; 5947 5948 case dw_val_class_addr: 5949 r = AT_addr (at); 5950 gcc_assert (GET_CODE (r) == SYMBOL_REF); 5951 CHECKSUM_STRING (XSTR (r, 0)); 5952 break; 5953 5954 case dw_val_class_offset: 5955 CHECKSUM (at->dw_attr_val.v.val_offset); 5956 break; 5957 5958 case dw_val_class_loc: 5959 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next) 5960 loc_checksum (loc, ctx); 5961 break; 5962 5963 case dw_val_class_die_ref: 5964 die_checksum (AT_ref (at), ctx, mark); 5965 break; 5966 5967 case dw_val_class_fde_ref: 5968 case dw_val_class_lbl_id: 5969 case dw_val_class_lineptr: 5970 case dw_val_class_macptr: 5971 break; 5972 5973 case dw_val_class_file: 5974 CHECKSUM_STRING (AT_file (at)->filename); 5975 break; 5976 5977 default: 5978 break; 5979 } 5980} 5981 5982/* Calculate the checksum of a DIE. */ 5983 5984static void 5985die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark) 5986{ 5987 dw_die_ref c; 5988 dw_attr_ref a; 5989 unsigned ix; 5990 5991 /* To avoid infinite recursion. */ 5992 if (die->die_mark) 5993 { 5994 CHECKSUM (die->die_mark); 5995 return; 5996 } 5997 die->die_mark = ++(*mark); 5998 5999 CHECKSUM (die->die_tag); 6000 6001 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 6002 attr_checksum (a, ctx, mark); 6003 6004 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark)); 6005} 6006 6007#undef CHECKSUM 6008#undef CHECKSUM_STRING 6009 6010/* Do the location expressions look same? */ 6011static inline int 6012same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark) 6013{ 6014 return loc1->dw_loc_opc == loc2->dw_loc_opc 6015 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark) 6016 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark); 6017} 6018 6019/* Do the values look the same? */ 6020static int 6021same_dw_val_p (dw_val_node *v1, dw_val_node *v2, int *mark) 6022{ 6023 dw_loc_descr_ref loc1, loc2; 6024 rtx r1, r2; 6025 6026 if (v1->val_class != v2->val_class) 6027 return 0; 6028 6029 switch (v1->val_class) 6030 { 6031 case dw_val_class_const: 6032 return v1->v.val_int == v2->v.val_int; 6033 case dw_val_class_unsigned_const: 6034 return v1->v.val_unsigned == v2->v.val_unsigned; 6035 case dw_val_class_long_long: 6036 return v1->v.val_long_long.hi == v2->v.val_long_long.hi 6037 && v1->v.val_long_long.low == v2->v.val_long_long.low; 6038 case dw_val_class_vec: 6039 if (v1->v.val_vec.length != v2->v.val_vec.length 6040 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size) 6041 return 0; 6042 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array, 6043 v1->v.val_vec.length * v1->v.val_vec.elt_size)) 6044 return 0; 6045 return 1; 6046 case dw_val_class_flag: 6047 return v1->v.val_flag == v2->v.val_flag; 6048 case dw_val_class_str: 6049 return !strcmp(v1->v.val_str->str, v2->v.val_str->str); 6050 6051 case dw_val_class_addr: 6052 r1 = v1->v.val_addr; 6053 r2 = v2->v.val_addr; 6054 if (GET_CODE (r1) != GET_CODE (r2)) 6055 return 0; 6056 gcc_assert (GET_CODE (r1) == SYMBOL_REF); 6057 return !strcmp (XSTR (r1, 0), XSTR (r2, 0)); 6058 6059 case dw_val_class_offset: 6060 return v1->v.val_offset == v2->v.val_offset; 6061 6062 case dw_val_class_loc: 6063 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc; 6064 loc1 && loc2; 6065 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next) 6066 if (!same_loc_p (loc1, loc2, mark)) 6067 return 0; 6068 return !loc1 && !loc2; 6069 6070 case dw_val_class_die_ref: 6071 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark); 6072 6073 case dw_val_class_fde_ref: 6074 case dw_val_class_lbl_id: 6075 case dw_val_class_lineptr: 6076 case dw_val_class_macptr: 6077 return 1; 6078 6079 case dw_val_class_file: 6080 return v1->v.val_file == v2->v.val_file; 6081 6082 default: 6083 return 1; 6084 } 6085} 6086 6087/* Do the attributes look the same? */ 6088 6089static int 6090same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark) 6091{ 6092 if (at1->dw_attr != at2->dw_attr) 6093 return 0; 6094 6095 /* We don't care that this was compiled with a different compiler 6096 snapshot; if the output is the same, that's what matters. */ 6097 if (at1->dw_attr == DW_AT_producer) 6098 return 1; 6099 6100 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark); 6101} 6102 6103/* Do the dies look the same? */ 6104 6105static int 6106same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark) 6107{ 6108 dw_die_ref c1, c2; 6109 dw_attr_ref a1; 6110 unsigned ix; 6111 6112 /* To avoid infinite recursion. */ 6113 if (die1->die_mark) 6114 return die1->die_mark == die2->die_mark; 6115 die1->die_mark = die2->die_mark = ++(*mark); 6116 6117 if (die1->die_tag != die2->die_tag) 6118 return 0; 6119 6120 if (VEC_length (dw_attr_node, die1->die_attr) 6121 != VEC_length (dw_attr_node, die2->die_attr)) 6122 return 0; 6123 6124 for (ix = 0; VEC_iterate (dw_attr_node, die1->die_attr, ix, a1); ix++) 6125 if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark)) 6126 return 0; 6127 6128 c1 = die1->die_child; 6129 c2 = die2->die_child; 6130 if (! c1) 6131 { 6132 if (c2) 6133 return 0; 6134 } 6135 else 6136 for (;;) 6137 { 6138 if (!same_die_p (c1, c2, mark)) 6139 return 0; 6140 c1 = c1->die_sib; 6141 c2 = c2->die_sib; 6142 if (c1 == die1->die_child) 6143 { 6144 if (c2 == die2->die_child) 6145 break; 6146 else 6147 return 0; 6148 } 6149 } 6150 6151 return 1; 6152} 6153 6154/* Do the dies look the same? Wrapper around same_die_p. */ 6155 6156static int 6157same_die_p_wrap (dw_die_ref die1, dw_die_ref die2) 6158{ 6159 int mark = 0; 6160 int ret = same_die_p (die1, die2, &mark); 6161 6162 unmark_all_dies (die1); 6163 unmark_all_dies (die2); 6164 6165 return ret; 6166} 6167 6168/* The prefix to attach to symbols on DIEs in the current comdat debug 6169 info section. */ 6170static char *comdat_symbol_id; 6171 6172/* The index of the current symbol within the current comdat CU. */ 6173static unsigned int comdat_symbol_number; 6174 6175/* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its 6176 children, and set comdat_symbol_id accordingly. */ 6177 6178static void 6179compute_section_prefix (dw_die_ref unit_die) 6180{ 6181 const char *die_name = get_AT_string (unit_die, DW_AT_name); 6182 const char *base = die_name ? lbasename (die_name) : "anonymous"; 6183 char *name = alloca (strlen (base) + 64); 6184 char *p; 6185 int i, mark; 6186 unsigned char checksum[16]; 6187 struct md5_ctx ctx; 6188 6189 /* Compute the checksum of the DIE, then append part of it as hex digits to 6190 the name filename of the unit. */ 6191 6192 md5_init_ctx (&ctx); 6193 mark = 0; 6194 die_checksum (unit_die, &ctx, &mark); 6195 unmark_all_dies (unit_die); 6196 md5_finish_ctx (&ctx, checksum); 6197 6198 sprintf (name, "%s.", base); 6199 clean_symbol_name (name); 6200 6201 p = name + strlen (name); 6202 for (i = 0; i < 4; i++) 6203 { 6204 sprintf (p, "%.2x", checksum[i]); 6205 p += 2; 6206 } 6207 6208 comdat_symbol_id = unit_die->die_symbol = xstrdup (name); 6209 comdat_symbol_number = 0; 6210} 6211 6212/* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */ 6213 6214static int 6215is_type_die (dw_die_ref die) 6216{ 6217 switch (die->die_tag) 6218 { 6219 case DW_TAG_array_type: 6220 case DW_TAG_class_type: 6221 case DW_TAG_enumeration_type: 6222 case DW_TAG_pointer_type: 6223 case DW_TAG_reference_type: 6224 case DW_TAG_string_type: 6225 case DW_TAG_structure_type: 6226 case DW_TAG_subroutine_type: 6227 case DW_TAG_union_type: 6228 case DW_TAG_ptr_to_member_type: 6229 case DW_TAG_set_type: 6230 case DW_TAG_subrange_type: 6231 case DW_TAG_base_type: 6232 case DW_TAG_const_type: 6233 case DW_TAG_file_type: 6234 case DW_TAG_packed_type: 6235 case DW_TAG_volatile_type: 6236 case DW_TAG_typedef: 6237 return 1; 6238 default: 6239 return 0; 6240 } 6241} 6242 6243/* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU. 6244 Basically, we want to choose the bits that are likely to be shared between 6245 compilations (types) and leave out the bits that are specific to individual 6246 compilations (functions). */ 6247 6248static int 6249is_comdat_die (dw_die_ref c) 6250{ 6251 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as 6252 we do for stabs. The advantage is a greater likelihood of sharing between 6253 objects that don't include headers in the same order (and therefore would 6254 put the base types in a different comdat). jason 8/28/00 */ 6255 6256 if (c->die_tag == DW_TAG_base_type) 6257 return 0; 6258 6259 if (c->die_tag == DW_TAG_pointer_type 6260 || c->die_tag == DW_TAG_reference_type 6261 || c->die_tag == DW_TAG_const_type 6262 || c->die_tag == DW_TAG_volatile_type) 6263 { 6264 dw_die_ref t = get_AT_ref (c, DW_AT_type); 6265 6266 return t ? is_comdat_die (t) : 0; 6267 } 6268 6269 return is_type_die (c); 6270} 6271 6272/* Returns 1 iff C is the sort of DIE that might be referred to from another 6273 compilation unit. */ 6274 6275static int 6276is_symbol_die (dw_die_ref c) 6277{ 6278 return (is_type_die (c) 6279 || (get_AT (c, DW_AT_declaration) 6280 && !get_AT (c, DW_AT_specification)) 6281 || c->die_tag == DW_TAG_namespace); 6282} 6283 6284static char * 6285gen_internal_sym (const char *prefix) 6286{ 6287 char buf[256]; 6288 6289 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++); 6290 return xstrdup (buf); 6291} 6292 6293/* Assign symbols to all worthy DIEs under DIE. */ 6294 6295static void 6296assign_symbol_names (dw_die_ref die) 6297{ 6298 dw_die_ref c; 6299 6300 if (is_symbol_die (die)) 6301 { 6302 if (comdat_symbol_id) 6303 { 6304 char *p = alloca (strlen (comdat_symbol_id) + 64); 6305 6306 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX, 6307 comdat_symbol_id, comdat_symbol_number++); 6308 die->die_symbol = xstrdup (p); 6309 } 6310 else 6311 die->die_symbol = gen_internal_sym ("LDIE"); 6312 } 6313 6314 FOR_EACH_CHILD (die, c, assign_symbol_names (c)); 6315} 6316 6317struct cu_hash_table_entry 6318{ 6319 dw_die_ref cu; 6320 unsigned min_comdat_num, max_comdat_num; 6321 struct cu_hash_table_entry *next; 6322}; 6323 6324/* Routines to manipulate hash table of CUs. */ 6325static hashval_t 6326htab_cu_hash (const void *of) 6327{ 6328 const struct cu_hash_table_entry *entry = of; 6329 6330 return htab_hash_string (entry->cu->die_symbol); 6331} 6332 6333static int 6334htab_cu_eq (const void *of1, const void *of2) 6335{ 6336 const struct cu_hash_table_entry *entry1 = of1; 6337 const struct die_struct *entry2 = of2; 6338 6339 return !strcmp (entry1->cu->die_symbol, entry2->die_symbol); 6340} 6341 6342static void 6343htab_cu_del (void *what) 6344{ 6345 struct cu_hash_table_entry *next, *entry = what; 6346 6347 while (entry) 6348 { 6349 next = entry->next; 6350 free (entry); 6351 entry = next; 6352 } 6353} 6354 6355/* Check whether we have already seen this CU and set up SYM_NUM 6356 accordingly. */ 6357static int 6358check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num) 6359{ 6360 struct cu_hash_table_entry dummy; 6361 struct cu_hash_table_entry **slot, *entry, *last = &dummy; 6362 6363 dummy.max_comdat_num = 0; 6364 6365 slot = (struct cu_hash_table_entry **) 6366 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol), 6367 INSERT); 6368 entry = *slot; 6369 6370 for (; entry; last = entry, entry = entry->next) 6371 { 6372 if (same_die_p_wrap (cu, entry->cu)) 6373 break; 6374 } 6375 6376 if (entry) 6377 { 6378 *sym_num = entry->min_comdat_num; 6379 return 1; 6380 } 6381 6382 entry = XCNEW (struct cu_hash_table_entry); 6383 entry->cu = cu; 6384 entry->min_comdat_num = *sym_num = last->max_comdat_num; 6385 entry->next = *slot; 6386 *slot = entry; 6387 6388 return 0; 6389} 6390 6391/* Record SYM_NUM to record of CU in HTABLE. */ 6392static void 6393record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num) 6394{ 6395 struct cu_hash_table_entry **slot, *entry; 6396 6397 slot = (struct cu_hash_table_entry **) 6398 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol), 6399 NO_INSERT); 6400 entry = *slot; 6401 6402 entry->max_comdat_num = sym_num; 6403} 6404 6405/* Traverse the DIE (which is always comp_unit_die), and set up 6406 additional compilation units for each of the include files we see 6407 bracketed by BINCL/EINCL. */ 6408 6409static void 6410break_out_includes (dw_die_ref die) 6411{ 6412 dw_die_ref c; 6413 dw_die_ref unit = NULL; 6414 limbo_die_node *node, **pnode; 6415 htab_t cu_hash_table; 6416 6417 c = die->die_child; 6418 if (c) do { 6419 dw_die_ref prev = c; 6420 c = c->die_sib; 6421 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL 6422 || (unit && is_comdat_die (c))) 6423 { 6424 dw_die_ref next = c->die_sib; 6425 6426 /* This DIE is for a secondary CU; remove it from the main one. */ 6427 remove_child_with_prev (c, prev); 6428 6429 if (c->die_tag == DW_TAG_GNU_BINCL) 6430 unit = push_new_compile_unit (unit, c); 6431 else if (c->die_tag == DW_TAG_GNU_EINCL) 6432 unit = pop_compile_unit (unit); 6433 else 6434 add_child_die (unit, c); 6435 c = next; 6436 if (c == die->die_child) 6437 break; 6438 } 6439 } while (c != die->die_child); 6440 6441#if 0 6442 /* We can only use this in debugging, since the frontend doesn't check 6443 to make sure that we leave every include file we enter. */ 6444 gcc_assert (!unit); 6445#endif 6446 6447 assign_symbol_names (die); 6448 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del); 6449 for (node = limbo_die_list, pnode = &limbo_die_list; 6450 node; 6451 node = node->next) 6452 { 6453 int is_dupl; 6454 6455 compute_section_prefix (node->die); 6456 is_dupl = check_duplicate_cu (node->die, cu_hash_table, 6457 &comdat_symbol_number); 6458 assign_symbol_names (node->die); 6459 if (is_dupl) 6460 *pnode = node->next; 6461 else 6462 { 6463 pnode = &node->next; 6464 record_comdat_symbol_number (node->die, cu_hash_table, 6465 comdat_symbol_number); 6466 } 6467 } 6468 htab_delete (cu_hash_table); 6469} 6470 6471/* Traverse the DIE and add a sibling attribute if it may have the 6472 effect of speeding up access to siblings. To save some space, 6473 avoid generating sibling attributes for DIE's without children. */ 6474 6475static void 6476add_sibling_attributes (dw_die_ref die) 6477{ 6478 dw_die_ref c; 6479 6480 if (! die->die_child) 6481 return; 6482 6483 if (die->die_parent && die != die->die_parent->die_child) 6484 add_AT_die_ref (die, DW_AT_sibling, die->die_sib); 6485 6486 FOR_EACH_CHILD (die, c, add_sibling_attributes (c)); 6487} 6488 6489/* Output all location lists for the DIE and its children. */ 6490 6491static void 6492output_location_lists (dw_die_ref die) 6493{ 6494 dw_die_ref c; 6495 dw_attr_ref a; 6496 unsigned ix; 6497 6498 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 6499 if (AT_class (a) == dw_val_class_loc_list) 6500 output_loc_list (AT_loc_list (a)); 6501 6502 FOR_EACH_CHILD (die, c, output_location_lists (c)); 6503} 6504 6505/* The format of each DIE (and its attribute value pairs) is encoded in an 6506 abbreviation table. This routine builds the abbreviation table and assigns 6507 a unique abbreviation id for each abbreviation entry. The children of each 6508 die are visited recursively. */ 6509 6510static void 6511build_abbrev_table (dw_die_ref die) 6512{ 6513 unsigned long abbrev_id; 6514 unsigned int n_alloc; 6515 dw_die_ref c; 6516 dw_attr_ref a; 6517 unsigned ix; 6518 6519 /* Scan the DIE references, and mark as external any that refer to 6520 DIEs from other CUs (i.e. those which are not marked). */ 6521 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 6522 if (AT_class (a) == dw_val_class_die_ref 6523 && AT_ref (a)->die_mark == 0) 6524 { 6525 gcc_assert (AT_ref (a)->die_symbol); 6526 6527 set_AT_ref_external (a, 1); 6528 } 6529 6530 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id) 6531 { 6532 dw_die_ref abbrev = abbrev_die_table[abbrev_id]; 6533 dw_attr_ref die_a, abbrev_a; 6534 unsigned ix; 6535 bool ok = true; 6536 6537 if (abbrev->die_tag != die->die_tag) 6538 continue; 6539 if ((abbrev->die_child != NULL) != (die->die_child != NULL)) 6540 continue; 6541 6542 if (VEC_length (dw_attr_node, abbrev->die_attr) 6543 != VEC_length (dw_attr_node, die->die_attr)) 6544 continue; 6545 6546 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, die_a); ix++) 6547 { 6548 abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix); 6549 if ((abbrev_a->dw_attr != die_a->dw_attr) 6550 || (value_format (abbrev_a) != value_format (die_a))) 6551 { 6552 ok = false; 6553 break; 6554 } 6555 } 6556 if (ok) 6557 break; 6558 } 6559 6560 if (abbrev_id >= abbrev_die_table_in_use) 6561 { 6562 if (abbrev_die_table_in_use >= abbrev_die_table_allocated) 6563 { 6564 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT; 6565 abbrev_die_table = ggc_realloc (abbrev_die_table, 6566 sizeof (dw_die_ref) * n_alloc); 6567 6568 memset (&abbrev_die_table[abbrev_die_table_allocated], 0, 6569 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref)); 6570 abbrev_die_table_allocated = n_alloc; 6571 } 6572 6573 ++abbrev_die_table_in_use; 6574 abbrev_die_table[abbrev_id] = die; 6575 } 6576 6577 die->die_abbrev = abbrev_id; 6578 FOR_EACH_CHILD (die, c, build_abbrev_table (c)); 6579} 6580 6581/* Return the power-of-two number of bytes necessary to represent VALUE. */ 6582 6583static int 6584constant_size (long unsigned int value) 6585{ 6586 int log; 6587 6588 if (value == 0) 6589 log = 0; 6590 else 6591 log = floor_log2 (value); 6592 6593 log = log / 8; 6594 log = 1 << (floor_log2 (log) + 1); 6595 6596 return log; 6597} 6598 6599/* Return the size of a DIE as it is represented in the 6600 .debug_info section. */ 6601 6602static unsigned long 6603size_of_die (dw_die_ref die) 6604{ 6605 unsigned long size = 0; 6606 dw_attr_ref a; 6607 unsigned ix; 6608 6609 size += size_of_uleb128 (die->die_abbrev); 6610 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 6611 { 6612 switch (AT_class (a)) 6613 { 6614 case dw_val_class_addr: 6615 size += DWARF2_ADDR_SIZE; 6616 break; 6617 case dw_val_class_offset: 6618 size += DWARF_OFFSET_SIZE; 6619 break; 6620 case dw_val_class_loc: 6621 { 6622 unsigned long lsize = size_of_locs (AT_loc (a)); 6623 6624 /* Block length. */ 6625 size += constant_size (lsize); 6626 size += lsize; 6627 } 6628 break; 6629 case dw_val_class_loc_list: 6630 size += DWARF_OFFSET_SIZE; 6631 break; 6632 case dw_val_class_range_list: 6633 size += DWARF_OFFSET_SIZE; 6634 break; 6635 case dw_val_class_const: 6636 size += size_of_sleb128 (AT_int (a)); 6637 break; 6638 case dw_val_class_unsigned_const: 6639 size += constant_size (AT_unsigned (a)); 6640 break; 6641 case dw_val_class_long_long: 6642 size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */ 6643 break; 6644 case dw_val_class_vec: 6645 size += 1 + (a->dw_attr_val.v.val_vec.length 6646 * a->dw_attr_val.v.val_vec.elt_size); /* block */ 6647 break; 6648 case dw_val_class_flag: 6649 size += 1; 6650 break; 6651 case dw_val_class_die_ref: 6652 if (AT_ref_external (a)) 6653 size += DWARF2_ADDR_SIZE; 6654 else 6655 size += DWARF_OFFSET_SIZE; 6656 break; 6657 case dw_val_class_fde_ref: 6658 size += DWARF_OFFSET_SIZE; 6659 break; 6660 case dw_val_class_lbl_id: 6661 size += DWARF2_ADDR_SIZE; 6662 break; 6663 case dw_val_class_lineptr: 6664 case dw_val_class_macptr: 6665 size += DWARF_OFFSET_SIZE; 6666 break; 6667 case dw_val_class_str: 6668 if (AT_string_form (a) == DW_FORM_strp) 6669 size += DWARF_OFFSET_SIZE; 6670 else 6671 size += strlen (a->dw_attr_val.v.val_str->str) + 1; 6672 break; 6673 case dw_val_class_file: 6674 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)); 6675 break; 6676 default: 6677 gcc_unreachable (); 6678 } 6679 } 6680 6681 return size; 6682} 6683 6684/* Size the debugging information associated with a given DIE. Visits the 6685 DIE's children recursively. Updates the global variable next_die_offset, on 6686 each time through. Uses the current value of next_die_offset to update the 6687 die_offset field in each DIE. */ 6688 6689static void 6690calc_die_sizes (dw_die_ref die) 6691{ 6692 dw_die_ref c; 6693 6694 die->die_offset = next_die_offset; 6695 next_die_offset += size_of_die (die); 6696 6697 FOR_EACH_CHILD (die, c, calc_die_sizes (c)); 6698 6699 if (die->die_child != NULL) 6700 /* Count the null byte used to terminate sibling lists. */ 6701 next_die_offset += 1; 6702} 6703 6704/* Set the marks for a die and its children. We do this so 6705 that we know whether or not a reference needs to use FORM_ref_addr; only 6706 DIEs in the same CU will be marked. We used to clear out the offset 6707 and use that as the flag, but ran into ordering problems. */ 6708 6709static void 6710mark_dies (dw_die_ref die) 6711{ 6712 dw_die_ref c; 6713 6714 gcc_assert (!die->die_mark); 6715 6716 die->die_mark = 1; 6717 FOR_EACH_CHILD (die, c, mark_dies (c)); 6718} 6719 6720/* Clear the marks for a die and its children. */ 6721 6722static void 6723unmark_dies (dw_die_ref die) 6724{ 6725 dw_die_ref c; 6726 6727 gcc_assert (die->die_mark); 6728 6729 die->die_mark = 0; 6730 FOR_EACH_CHILD (die, c, unmark_dies (c)); 6731} 6732 6733/* Clear the marks for a die, its children and referred dies. */ 6734 6735static void 6736unmark_all_dies (dw_die_ref die) 6737{ 6738 dw_die_ref c; 6739 dw_attr_ref a; 6740 unsigned ix; 6741 6742 if (!die->die_mark) 6743 return; 6744 die->die_mark = 0; 6745 6746 FOR_EACH_CHILD (die, c, unmark_all_dies (c)); 6747 6748 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 6749 if (AT_class (a) == dw_val_class_die_ref) 6750 unmark_all_dies (AT_ref (a)); 6751} 6752 6753/* Return the size of the .debug_pubnames table generated for the 6754 compilation unit. */ 6755 6756static unsigned long 6757size_of_pubnames (void) 6758{ 6759 unsigned long size; 6760 unsigned i; 6761 6762 size = DWARF_PUBNAMES_HEADER_SIZE; 6763 for (i = 0; i < pubname_table_in_use; i++) 6764 { 6765 pubname_ref p = &pubname_table[i]; 6766 size += DWARF_OFFSET_SIZE + strlen (p->name) + 1; 6767 } 6768 6769 size += DWARF_OFFSET_SIZE; 6770 return size; 6771} 6772 6773/* Return the size of the information in the .debug_aranges section. */ 6774 6775static unsigned long 6776size_of_aranges (void) 6777{ 6778 unsigned long size; 6779 6780 size = DWARF_ARANGES_HEADER_SIZE; 6781 6782 /* Count the address/length pair for this compilation unit. */ 6783 size += 2 * DWARF2_ADDR_SIZE; 6784 size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use; 6785 6786 /* Count the two zero words used to terminated the address range table. */ 6787 size += 2 * DWARF2_ADDR_SIZE; 6788 return size; 6789} 6790 6791/* Select the encoding of an attribute value. */ 6792 6793static enum dwarf_form 6794value_format (dw_attr_ref a) 6795{ 6796 switch (a->dw_attr_val.val_class) 6797 { 6798 case dw_val_class_addr: 6799 return DW_FORM_addr; 6800 case dw_val_class_range_list: 6801 case dw_val_class_offset: 6802 case dw_val_class_loc_list: 6803 switch (DWARF_OFFSET_SIZE) 6804 { 6805 case 4: 6806 return DW_FORM_data4; 6807 case 8: 6808 return DW_FORM_data8; 6809 default: 6810 gcc_unreachable (); 6811 } 6812 case dw_val_class_loc: 6813 switch (constant_size (size_of_locs (AT_loc (a)))) 6814 { 6815 case 1: 6816 return DW_FORM_block1; 6817 case 2: 6818 return DW_FORM_block2; 6819 default: 6820 gcc_unreachable (); 6821 } 6822 case dw_val_class_const: 6823 return DW_FORM_sdata; 6824 case dw_val_class_unsigned_const: 6825 switch (constant_size (AT_unsigned (a))) 6826 { 6827 case 1: 6828 return DW_FORM_data1; 6829 case 2: 6830 return DW_FORM_data2; 6831 case 4: 6832 return DW_FORM_data4; 6833 case 8: 6834 return DW_FORM_data8; 6835 default: 6836 gcc_unreachable (); 6837 } 6838 case dw_val_class_long_long: 6839 return DW_FORM_block1; 6840 case dw_val_class_vec: 6841 return DW_FORM_block1; 6842 case dw_val_class_flag: 6843 return DW_FORM_flag; 6844 case dw_val_class_die_ref: 6845 if (AT_ref_external (a)) 6846 return DW_FORM_ref_addr; 6847 else 6848 return DW_FORM_ref; 6849 case dw_val_class_fde_ref: 6850 return DW_FORM_data; 6851 case dw_val_class_lbl_id: 6852 return DW_FORM_addr; 6853 case dw_val_class_lineptr: 6854 case dw_val_class_macptr: 6855 return DW_FORM_data; 6856 case dw_val_class_str: 6857 return AT_string_form (a); 6858 case dw_val_class_file: 6859 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file))) 6860 { 6861 case 1: 6862 return DW_FORM_data1; 6863 case 2: 6864 return DW_FORM_data2; 6865 case 4: 6866 return DW_FORM_data4; 6867 default: 6868 gcc_unreachable (); 6869 } 6870 6871 default: 6872 gcc_unreachable (); 6873 } 6874} 6875 6876/* Output the encoding of an attribute value. */ 6877 6878static void 6879output_value_format (dw_attr_ref a) 6880{ 6881 enum dwarf_form form = value_format (a); 6882 6883 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form)); 6884} 6885 6886/* Output the .debug_abbrev section which defines the DIE abbreviation 6887 table. */ 6888 6889static void 6890output_abbrev_section (void) 6891{ 6892 unsigned long abbrev_id; 6893 6894 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id) 6895 { 6896 dw_die_ref abbrev = abbrev_die_table[abbrev_id]; 6897 unsigned ix; 6898 dw_attr_ref a_attr; 6899 6900 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)"); 6901 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)", 6902 dwarf_tag_name (abbrev->die_tag)); 6903 6904 if (abbrev->die_child != NULL) 6905 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes"); 6906 else 6907 dw2_asm_output_data (1, DW_children_no, "DW_children_no"); 6908 6909 for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr); 6910 ix++) 6911 { 6912 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)", 6913 dwarf_attr_name (a_attr->dw_attr)); 6914 output_value_format (a_attr); 6915 } 6916 6917 dw2_asm_output_data (1, 0, NULL); 6918 dw2_asm_output_data (1, 0, NULL); 6919 } 6920 6921 /* Terminate the table. */ 6922 dw2_asm_output_data (1, 0, NULL); 6923} 6924 6925/* Output a symbol we can use to refer to this DIE from another CU. */ 6926 6927static inline void 6928output_die_symbol (dw_die_ref die) 6929{ 6930 char *sym = die->die_symbol; 6931 6932 if (sym == 0) 6933 return; 6934 6935 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0) 6936 /* We make these global, not weak; if the target doesn't support 6937 .linkonce, it doesn't support combining the sections, so debugging 6938 will break. */ 6939 targetm.asm_out.globalize_label (asm_out_file, sym); 6940 6941 ASM_OUTPUT_LABEL (asm_out_file, sym); 6942} 6943 6944/* Return a new location list, given the begin and end range, and the 6945 expression. gensym tells us whether to generate a new internal symbol for 6946 this location list node, which is done for the head of the list only. */ 6947 6948static inline dw_loc_list_ref 6949new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end, 6950 const char *section, unsigned int gensym) 6951{ 6952 dw_loc_list_ref retlist = ggc_alloc_cleared (sizeof (dw_loc_list_node)); 6953 6954 retlist->begin = begin; 6955 retlist->end = end; 6956 retlist->expr = expr; 6957 retlist->section = section; 6958 if (gensym) 6959 retlist->ll_symbol = gen_internal_sym ("LLST"); 6960 6961 return retlist; 6962} 6963 6964/* Add a location description expression to a location list. */ 6965 6966static inline void 6967add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr, 6968 const char *begin, const char *end, 6969 const char *section) 6970{ 6971 dw_loc_list_ref *d; 6972 6973 /* Find the end of the chain. */ 6974 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next) 6975 ; 6976 6977 /* Add a new location list node to the list. */ 6978 *d = new_loc_list (descr, begin, end, section, 0); 6979} 6980 6981static void 6982dwarf2out_switch_text_section (void) 6983{ 6984 dw_fde_ref fde; 6985 6986 gcc_assert (cfun); 6987 6988 fde = &fde_table[fde_table_in_use - 1]; 6989 fde->dw_fde_switched_sections = true; 6990 fde->dw_fde_hot_section_label = cfun->hot_section_label; 6991 fde->dw_fde_hot_section_end_label = cfun->hot_section_end_label; 6992 fde->dw_fde_unlikely_section_label = cfun->cold_section_label; 6993 fde->dw_fde_unlikely_section_end_label = cfun->cold_section_end_label; 6994 have_multiple_function_sections = true; 6995 6996 /* Reset the current label on switching text sections, so that we 6997 don't attempt to advance_loc4 between labels in different sections. */ 6998 fde->dw_fde_current_label = NULL; 6999} 7000 7001/* Output the location list given to us. */ 7002 7003static void 7004output_loc_list (dw_loc_list_ref list_head) 7005{ 7006 dw_loc_list_ref curr = list_head; 7007 7008 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol); 7009 7010 /* Walk the location list, and output each range + expression. */ 7011 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next) 7012 { 7013 unsigned long size; 7014 if (!have_multiple_function_sections) 7015 { 7016 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section, 7017 "Location list begin address (%s)", 7018 list_head->ll_symbol); 7019 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section, 7020 "Location list end address (%s)", 7021 list_head->ll_symbol); 7022 } 7023 else 7024 { 7025 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin, 7026 "Location list begin address (%s)", 7027 list_head->ll_symbol); 7028 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end, 7029 "Location list end address (%s)", 7030 list_head->ll_symbol); 7031 } 7032 size = size_of_locs (curr->expr); 7033 7034 /* Output the block length for this list of location operations. */ 7035 gcc_assert (size <= 0xffff); 7036 dw2_asm_output_data (2, size, "%s", "Location expression size"); 7037 7038 output_loc_sequence (curr->expr); 7039 } 7040 7041 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, 7042 "Location list terminator begin (%s)", 7043 list_head->ll_symbol); 7044 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, 7045 "Location list terminator end (%s)", 7046 list_head->ll_symbol); 7047} 7048 7049/* Output the DIE and its attributes. Called recursively to generate 7050 the definitions of each child DIE. */ 7051 7052static void 7053output_die (dw_die_ref die) 7054{ 7055 dw_attr_ref a; 7056 dw_die_ref c; 7057 unsigned long size; 7058 unsigned ix; 7059 7060 /* If someone in another CU might refer to us, set up a symbol for 7061 them to point to. */ 7062 if (die->die_symbol) 7063 output_die_symbol (die); 7064 7065 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)", 7066 die->die_offset, dwarf_tag_name (die->die_tag)); 7067 7068 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 7069 { 7070 const char *name = dwarf_attr_name (a->dw_attr); 7071 7072 switch (AT_class (a)) 7073 { 7074 case dw_val_class_addr: 7075 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name); 7076 break; 7077 7078 case dw_val_class_offset: 7079 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset, 7080 "%s", name); 7081 break; 7082 7083 case dw_val_class_range_list: 7084 { 7085 char *p = strchr (ranges_section_label, '\0'); 7086 7087 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX, 7088 a->dw_attr_val.v.val_offset); 7089 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label, 7090 debug_ranges_section, "%s", name); 7091 *p = '\0'; 7092 } 7093 break; 7094 7095 case dw_val_class_loc: 7096 size = size_of_locs (AT_loc (a)); 7097 7098 /* Output the block length for this list of location operations. */ 7099 dw2_asm_output_data (constant_size (size), size, "%s", name); 7100 7101 output_loc_sequence (AT_loc (a)); 7102 break; 7103 7104 case dw_val_class_const: 7105 /* ??? It would be slightly more efficient to use a scheme like is 7106 used for unsigned constants below, but gdb 4.x does not sign 7107 extend. Gdb 5.x does sign extend. */ 7108 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name); 7109 break; 7110 7111 case dw_val_class_unsigned_const: 7112 dw2_asm_output_data (constant_size (AT_unsigned (a)), 7113 AT_unsigned (a), "%s", name); 7114 break; 7115 7116 case dw_val_class_long_long: 7117 { 7118 unsigned HOST_WIDE_INT first, second; 7119 7120 dw2_asm_output_data (1, 7121 2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR, 7122 "%s", name); 7123 7124 if (WORDS_BIG_ENDIAN) 7125 { 7126 first = a->dw_attr_val.v.val_long_long.hi; 7127 second = a->dw_attr_val.v.val_long_long.low; 7128 } 7129 else 7130 { 7131 first = a->dw_attr_val.v.val_long_long.low; 7132 second = a->dw_attr_val.v.val_long_long.hi; 7133 } 7134 7135 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR, 7136 first, "long long constant"); 7137 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR, 7138 second, NULL); 7139 } 7140 break; 7141 7142 case dw_val_class_vec: 7143 { 7144 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size; 7145 unsigned int len = a->dw_attr_val.v.val_vec.length; 7146 unsigned int i; 7147 unsigned char *p; 7148 7149 dw2_asm_output_data (1, len * elt_size, "%s", name); 7150 if (elt_size > sizeof (HOST_WIDE_INT)) 7151 { 7152 elt_size /= 2; 7153 len *= 2; 7154 } 7155 for (i = 0, p = a->dw_attr_val.v.val_vec.array; 7156 i < len; 7157 i++, p += elt_size) 7158 dw2_asm_output_data (elt_size, extract_int (p, elt_size), 7159 "fp or vector constant word %u", i); 7160 break; 7161 } 7162 7163 case dw_val_class_flag: 7164 dw2_asm_output_data (1, AT_flag (a), "%s", name); 7165 break; 7166 7167 case dw_val_class_loc_list: 7168 { 7169 char *sym = AT_loc_list (a)->ll_symbol; 7170 7171 gcc_assert (sym); 7172 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section, 7173 "%s", name); 7174 } 7175 break; 7176 7177 case dw_val_class_die_ref: 7178 if (AT_ref_external (a)) 7179 { 7180 char *sym = AT_ref (a)->die_symbol; 7181 7182 gcc_assert (sym); 7183 dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, debug_info_section, 7184 "%s", name); 7185 } 7186 else 7187 { 7188 gcc_assert (AT_ref (a)->die_offset); 7189 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset, 7190 "%s", name); 7191 } 7192 break; 7193 7194 case dw_val_class_fde_ref: 7195 { 7196 char l1[20]; 7197 7198 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL, 7199 a->dw_attr_val.v.val_fde_index * 2); 7200 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section, 7201 "%s", name); 7202 } 7203 break; 7204 7205 case dw_val_class_lbl_id: 7206 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name); 7207 break; 7208 7209 case dw_val_class_lineptr: 7210 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a), 7211 debug_line_section, "%s", name); 7212 break; 7213 7214 case dw_val_class_macptr: 7215 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a), 7216 debug_macinfo_section, "%s", name); 7217 break; 7218 7219 case dw_val_class_str: 7220 if (AT_string_form (a) == DW_FORM_strp) 7221 dw2_asm_output_offset (DWARF_OFFSET_SIZE, 7222 a->dw_attr_val.v.val_str->label, 7223 debug_str_section, 7224 "%s: \"%s\"", name, AT_string (a)); 7225 else 7226 dw2_asm_output_nstring (AT_string (a), -1, "%s", name); 7227 break; 7228 7229 case dw_val_class_file: 7230 { 7231 int f = maybe_emit_file (a->dw_attr_val.v.val_file); 7232 7233 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name, 7234 a->dw_attr_val.v.val_file->filename); 7235 break; 7236 } 7237 7238 default: 7239 gcc_unreachable (); 7240 } 7241 } 7242 7243 FOR_EACH_CHILD (die, c, output_die (c)); 7244 7245 /* Add null byte to terminate sibling list. */ 7246 if (die->die_child != NULL) 7247 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx", 7248 die->die_offset); 7249} 7250 7251/* Output the compilation unit that appears at the beginning of the 7252 .debug_info section, and precedes the DIE descriptions. */ 7253 7254static void 7255output_compilation_unit_header (void) 7256{ 7257 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 7258 dw2_asm_output_data (4, 0xffffffff, 7259 "Initial length escape value indicating 64-bit DWARF extension"); 7260 dw2_asm_output_data (DWARF_OFFSET_SIZE, 7261 next_die_offset - DWARF_INITIAL_LENGTH_SIZE, 7262 "Length of Compilation Unit Info"); 7263 dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number"); 7264 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label, 7265 debug_abbrev_section, 7266 "Offset Into Abbrev. Section"); 7267 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)"); 7268} 7269 7270/* Output the compilation unit DIE and its children. */ 7271 7272static void 7273output_comp_unit (dw_die_ref die, int output_if_empty) 7274{ 7275 const char *secname; 7276 char *oldsym, *tmp; 7277 7278 /* Unless we are outputting main CU, we may throw away empty ones. */ 7279 if (!output_if_empty && die->die_child == NULL) 7280 return; 7281 7282 /* Even if there are no children of this DIE, we must output the information 7283 about the compilation unit. Otherwise, on an empty translation unit, we 7284 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm' 7285 will then complain when examining the file. First mark all the DIEs in 7286 this CU so we know which get local refs. */ 7287 mark_dies (die); 7288 7289 build_abbrev_table (die); 7290 7291 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */ 7292 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE; 7293 calc_die_sizes (die); 7294 7295 oldsym = die->die_symbol; 7296 if (oldsym) 7297 { 7298 tmp = alloca (strlen (oldsym) + 24); 7299 7300 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym); 7301 secname = tmp; 7302 die->die_symbol = NULL; 7303 switch_to_section (get_section (secname, SECTION_DEBUG, NULL)); 7304 } 7305 else 7306 switch_to_section (debug_info_section); 7307 7308 /* Output debugging information. */ 7309 output_compilation_unit_header (); 7310 output_die (die); 7311 7312 /* Leave the marks on the main CU, so we can check them in 7313 output_pubnames. */ 7314 if (oldsym) 7315 { 7316 unmark_dies (die); 7317 die->die_symbol = oldsym; 7318 } 7319} 7320 7321/* Return the DWARF2/3 pubname associated with a decl. */ 7322 7323static const char * 7324dwarf2_name (tree decl, int scope) 7325{ 7326 return lang_hooks.dwarf_name (decl, scope ? 1 : 0); 7327} 7328 7329/* Add a new entry to .debug_pubnames if appropriate. */ 7330 7331static void 7332add_pubname (tree decl, dw_die_ref die) 7333{ 7334 pubname_ref p; 7335 7336 if (! TREE_PUBLIC (decl)) 7337 return; 7338 7339 if (pubname_table_in_use == pubname_table_allocated) 7340 { 7341 pubname_table_allocated += PUBNAME_TABLE_INCREMENT; 7342 pubname_table 7343 = ggc_realloc (pubname_table, 7344 (pubname_table_allocated * sizeof (pubname_entry))); 7345 memset (pubname_table + pubname_table_in_use, 0, 7346 PUBNAME_TABLE_INCREMENT * sizeof (pubname_entry)); 7347 } 7348 7349 p = &pubname_table[pubname_table_in_use++]; 7350 p->die = die; 7351 p->name = xstrdup (dwarf2_name (decl, 1)); 7352} 7353 7354/* Output the public names table used to speed up access to externally 7355 visible names. For now, only generate entries for externally 7356 visible procedures. */ 7357 7358static void 7359output_pubnames (void) 7360{ 7361 unsigned i; 7362 unsigned long pubnames_length = size_of_pubnames (); 7363 7364 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 7365 dw2_asm_output_data (4, 0xffffffff, 7366 "Initial length escape value indicating 64-bit DWARF extension"); 7367 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length, 7368 "Length of Public Names Info"); 7369 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version"); 7370 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label, 7371 debug_info_section, 7372 "Offset of Compilation Unit Info"); 7373 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset, 7374 "Compilation Unit Length"); 7375 7376 for (i = 0; i < pubname_table_in_use; i++) 7377 { 7378 pubname_ref pub = &pubname_table[i]; 7379 7380 /* We shouldn't see pubnames for DIEs outside of the main CU. */ 7381 gcc_assert (pub->die->die_mark); 7382 7383 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset, 7384 "DIE offset"); 7385 7386 dw2_asm_output_nstring (pub->name, -1, "external name"); 7387 } 7388 7389 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL); 7390} 7391 7392/* Add a new entry to .debug_aranges if appropriate. */ 7393 7394static void 7395add_arange (tree decl, dw_die_ref die) 7396{ 7397 if (! DECL_SECTION_NAME (decl)) 7398 return; 7399 7400 if (arange_table_in_use == arange_table_allocated) 7401 { 7402 arange_table_allocated += ARANGE_TABLE_INCREMENT; 7403 arange_table = ggc_realloc (arange_table, 7404 (arange_table_allocated 7405 * sizeof (dw_die_ref))); 7406 memset (arange_table + arange_table_in_use, 0, 7407 ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref)); 7408 } 7409 7410 arange_table[arange_table_in_use++] = die; 7411} 7412 7413/* Output the information that goes into the .debug_aranges table. 7414 Namely, define the beginning and ending address range of the 7415 text section generated for this compilation unit. */ 7416 7417static void 7418output_aranges (void) 7419{ 7420 unsigned i; 7421 unsigned long aranges_length = size_of_aranges (); 7422 7423 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 7424 dw2_asm_output_data (4, 0xffffffff, 7425 "Initial length escape value indicating 64-bit DWARF extension"); 7426 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length, 7427 "Length of Address Ranges Info"); 7428 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version"); 7429 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label, 7430 debug_info_section, 7431 "Offset of Compilation Unit Info"); 7432 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address"); 7433 dw2_asm_output_data (1, 0, "Size of Segment Descriptor"); 7434 7435 /* We need to align to twice the pointer size here. */ 7436 if (DWARF_ARANGES_PAD_SIZE) 7437 { 7438 /* Pad using a 2 byte words so that padding is correct for any 7439 pointer size. */ 7440 dw2_asm_output_data (2, 0, "Pad to %d byte boundary", 7441 2 * DWARF2_ADDR_SIZE); 7442 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2) 7443 dw2_asm_output_data (2, 0, NULL); 7444 } 7445 7446 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address"); 7447 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label, 7448 text_section_label, "Length"); 7449 if (flag_reorder_blocks_and_partition) 7450 { 7451 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label, 7452 "Address"); 7453 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label, 7454 cold_text_section_label, "Length"); 7455 } 7456 7457 for (i = 0; i < arange_table_in_use; i++) 7458 { 7459 dw_die_ref die = arange_table[i]; 7460 7461 /* We shouldn't see aranges for DIEs outside of the main CU. */ 7462 gcc_assert (die->die_mark); 7463 7464 if (die->die_tag == DW_TAG_subprogram) 7465 { 7466 dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die), 7467 "Address"); 7468 dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die), 7469 get_AT_low_pc (die), "Length"); 7470 } 7471 else 7472 { 7473 /* A static variable; extract the symbol from DW_AT_location. 7474 Note that this code isn't currently hit, as we only emit 7475 aranges for functions (jason 9/23/99). */ 7476 dw_attr_ref a = get_AT (die, DW_AT_location); 7477 dw_loc_descr_ref loc; 7478 7479 gcc_assert (a && AT_class (a) == dw_val_class_loc); 7480 7481 loc = AT_loc (a); 7482 gcc_assert (loc->dw_loc_opc == DW_OP_addr); 7483 7484 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, 7485 loc->dw_loc_oprnd1.v.val_addr, "Address"); 7486 dw2_asm_output_data (DWARF2_ADDR_SIZE, 7487 get_AT_unsigned (die, DW_AT_byte_size), 7488 "Length"); 7489 } 7490 } 7491 7492 /* Output the terminator words. */ 7493 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 7494 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 7495} 7496 7497/* Add a new entry to .debug_ranges. Return the offset at which it 7498 was placed. */ 7499 7500static unsigned int 7501add_ranges (tree block) 7502{ 7503 unsigned int in_use = ranges_table_in_use; 7504 7505 if (in_use == ranges_table_allocated) 7506 { 7507 ranges_table_allocated += RANGES_TABLE_INCREMENT; 7508 ranges_table 7509 = ggc_realloc (ranges_table, (ranges_table_allocated 7510 * sizeof (struct dw_ranges_struct))); 7511 memset (ranges_table + ranges_table_in_use, 0, 7512 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct)); 7513 } 7514 7515 ranges_table[in_use].block_num = (block ? BLOCK_NUMBER (block) : 0); 7516 ranges_table_in_use = in_use + 1; 7517 7518 return in_use * 2 * DWARF2_ADDR_SIZE; 7519} 7520 7521static void 7522output_ranges (void) 7523{ 7524 unsigned i; 7525 static const char *const start_fmt = "Offset 0x%x"; 7526 const char *fmt = start_fmt; 7527 7528 for (i = 0; i < ranges_table_in_use; i++) 7529 { 7530 int block_num = ranges_table[i].block_num; 7531 7532 if (block_num) 7533 { 7534 char blabel[MAX_ARTIFICIAL_LABEL_BYTES]; 7535 char elabel[MAX_ARTIFICIAL_LABEL_BYTES]; 7536 7537 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num); 7538 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num); 7539 7540 /* If all code is in the text section, then the compilation 7541 unit base address defaults to DW_AT_low_pc, which is the 7542 base of the text section. */ 7543 if (!have_multiple_function_sections) 7544 { 7545 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel, 7546 text_section_label, 7547 fmt, i * 2 * DWARF2_ADDR_SIZE); 7548 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel, 7549 text_section_label, NULL); 7550 } 7551 7552 /* Otherwise, we add a DW_AT_entry_pc attribute to force the 7553 compilation unit base address to zero, which allows us to 7554 use absolute addresses, and not worry about whether the 7555 target supports cross-section arithmetic. */ 7556 else 7557 { 7558 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel, 7559 fmt, i * 2 * DWARF2_ADDR_SIZE); 7560 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL); 7561 } 7562 7563 fmt = NULL; 7564 } 7565 else 7566 { 7567 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 7568 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 7569 fmt = start_fmt; 7570 } 7571 } 7572} 7573 7574/* Data structure containing information about input files. */ 7575struct file_info 7576{ 7577 const char *path; /* Complete file name. */ 7578 const char *fname; /* File name part. */ 7579 int length; /* Length of entire string. */ 7580 struct dwarf_file_data * file_idx; /* Index in input file table. */ 7581 int dir_idx; /* Index in directory table. */ 7582}; 7583 7584/* Data structure containing information about directories with source 7585 files. */ 7586struct dir_info 7587{ 7588 const char *path; /* Path including directory name. */ 7589 int length; /* Path length. */ 7590 int prefix; /* Index of directory entry which is a prefix. */ 7591 int count; /* Number of files in this directory. */ 7592 int dir_idx; /* Index of directory used as base. */ 7593}; 7594 7595/* Callback function for file_info comparison. We sort by looking at 7596 the directories in the path. */ 7597 7598static int 7599file_info_cmp (const void *p1, const void *p2) 7600{ 7601 const struct file_info *s1 = p1; 7602 const struct file_info *s2 = p2; 7603 unsigned char *cp1; 7604 unsigned char *cp2; 7605 7606 /* Take care of file names without directories. We need to make sure that 7607 we return consistent values to qsort since some will get confused if 7608 we return the same value when identical operands are passed in opposite 7609 orders. So if neither has a directory, return 0 and otherwise return 7610 1 or -1 depending on which one has the directory. */ 7611 if ((s1->path == s1->fname || s2->path == s2->fname)) 7612 return (s2->path == s2->fname) - (s1->path == s1->fname); 7613 7614 cp1 = (unsigned char *) s1->path; 7615 cp2 = (unsigned char *) s2->path; 7616 7617 while (1) 7618 { 7619 ++cp1; 7620 ++cp2; 7621 /* Reached the end of the first path? If so, handle like above. */ 7622 if ((cp1 == (unsigned char *) s1->fname) 7623 || (cp2 == (unsigned char *) s2->fname)) 7624 return ((cp2 == (unsigned char *) s2->fname) 7625 - (cp1 == (unsigned char *) s1->fname)); 7626 7627 /* Character of current path component the same? */ 7628 else if (*cp1 != *cp2) 7629 return *cp1 - *cp2; 7630 } 7631} 7632 7633struct file_name_acquire_data 7634{ 7635 struct file_info *files; 7636 int used_files; 7637 int max_files; 7638}; 7639 7640/* Traversal function for the hash table. */ 7641 7642static int 7643file_name_acquire (void ** slot, void *data) 7644{ 7645 struct file_name_acquire_data *fnad = data; 7646 struct dwarf_file_data *d = *slot; 7647 struct file_info *fi; 7648 const char *f; 7649 7650 gcc_assert (fnad->max_files >= d->emitted_number); 7651 7652 if (! d->emitted_number) 7653 return 1; 7654 7655 gcc_assert (fnad->max_files != fnad->used_files); 7656 7657 fi = fnad->files + fnad->used_files++; 7658 7659 /* Skip all leading "./". */ 7660 f = d->filename; 7661 while (f[0] == '.' && f[1] == '/') 7662 f += 2; 7663 7664 /* Create a new array entry. */ 7665 fi->path = f; 7666 fi->length = strlen (f); 7667 fi->file_idx = d; 7668 7669 /* Search for the file name part. */ 7670 f = strrchr (f, '/'); 7671 fi->fname = f == NULL ? fi->path : f + 1; 7672 return 1; 7673} 7674 7675/* Output the directory table and the file name table. We try to minimize 7676 the total amount of memory needed. A heuristic is used to avoid large 7677 slowdowns with many input files. */ 7678 7679static void 7680output_file_names (void) 7681{ 7682 struct file_name_acquire_data fnad; 7683 int numfiles; 7684 struct file_info *files; 7685 struct dir_info *dirs; 7686 int *saved; 7687 int *savehere; 7688 int *backmap; 7689 int ndirs; 7690 int idx_offset; 7691 int i; 7692 int idx; 7693 7694 if (!last_emitted_file) 7695 { 7696 dw2_asm_output_data (1, 0, "End directory table"); 7697 dw2_asm_output_data (1, 0, "End file name table"); 7698 return; 7699 } 7700 7701 numfiles = last_emitted_file->emitted_number; 7702 7703 /* Allocate the various arrays we need. */ 7704 files = alloca (numfiles * sizeof (struct file_info)); 7705 dirs = alloca (numfiles * sizeof (struct dir_info)); 7706 7707 fnad.files = files; 7708 fnad.used_files = 0; 7709 fnad.max_files = numfiles; 7710 htab_traverse (file_table, file_name_acquire, &fnad); 7711 gcc_assert (fnad.used_files == fnad.max_files); 7712 7713 qsort (files, numfiles, sizeof (files[0]), file_info_cmp); 7714 7715 /* Find all the different directories used. */ 7716 dirs[0].path = files[0].path; 7717 dirs[0].length = files[0].fname - files[0].path; 7718 dirs[0].prefix = -1; 7719 dirs[0].count = 1; 7720 dirs[0].dir_idx = 0; 7721 files[0].dir_idx = 0; 7722 ndirs = 1; 7723 7724 for (i = 1; i < numfiles; i++) 7725 if (files[i].fname - files[i].path == dirs[ndirs - 1].length 7726 && memcmp (dirs[ndirs - 1].path, files[i].path, 7727 dirs[ndirs - 1].length) == 0) 7728 { 7729 /* Same directory as last entry. */ 7730 files[i].dir_idx = ndirs - 1; 7731 ++dirs[ndirs - 1].count; 7732 } 7733 else 7734 { 7735 int j; 7736 7737 /* This is a new directory. */ 7738 dirs[ndirs].path = files[i].path; 7739 dirs[ndirs].length = files[i].fname - files[i].path; 7740 dirs[ndirs].count = 1; 7741 dirs[ndirs].dir_idx = ndirs; 7742 files[i].dir_idx = ndirs; 7743 7744 /* Search for a prefix. */ 7745 dirs[ndirs].prefix = -1; 7746 for (j = 0; j < ndirs; j++) 7747 if (dirs[j].length < dirs[ndirs].length 7748 && dirs[j].length > 1 7749 && (dirs[ndirs].prefix == -1 7750 || dirs[j].length > dirs[dirs[ndirs].prefix].length) 7751 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0) 7752 dirs[ndirs].prefix = j; 7753 7754 ++ndirs; 7755 } 7756 7757 /* Now to the actual work. We have to find a subset of the directories which 7758 allow expressing the file name using references to the directory table 7759 with the least amount of characters. We do not do an exhaustive search 7760 where we would have to check out every combination of every single 7761 possible prefix. Instead we use a heuristic which provides nearly optimal 7762 results in most cases and never is much off. */ 7763 saved = alloca (ndirs * sizeof (int)); 7764 savehere = alloca (ndirs * sizeof (int)); 7765 7766 memset (saved, '\0', ndirs * sizeof (saved[0])); 7767 for (i = 0; i < ndirs; i++) 7768 { 7769 int j; 7770 int total; 7771 7772 /* We can always save some space for the current directory. But this 7773 does not mean it will be enough to justify adding the directory. */ 7774 savehere[i] = dirs[i].length; 7775 total = (savehere[i] - saved[i]) * dirs[i].count; 7776 7777 for (j = i + 1; j < ndirs; j++) 7778 { 7779 savehere[j] = 0; 7780 if (saved[j] < dirs[i].length) 7781 { 7782 /* Determine whether the dirs[i] path is a prefix of the 7783 dirs[j] path. */ 7784 int k; 7785 7786 k = dirs[j].prefix; 7787 while (k != -1 && k != (int) i) 7788 k = dirs[k].prefix; 7789 7790 if (k == (int) i) 7791 { 7792 /* Yes it is. We can possibly save some memory by 7793 writing the filenames in dirs[j] relative to 7794 dirs[i]. */ 7795 savehere[j] = dirs[i].length; 7796 total += (savehere[j] - saved[j]) * dirs[j].count; 7797 } 7798 } 7799 } 7800 7801 /* Check whether we can save enough to justify adding the dirs[i] 7802 directory. */ 7803 if (total > dirs[i].length + 1) 7804 { 7805 /* It's worthwhile adding. */ 7806 for (j = i; j < ndirs; j++) 7807 if (savehere[j] > 0) 7808 { 7809 /* Remember how much we saved for this directory so far. */ 7810 saved[j] = savehere[j]; 7811 7812 /* Remember the prefix directory. */ 7813 dirs[j].dir_idx = i; 7814 } 7815 } 7816 } 7817 7818 /* Emit the directory name table. */ 7819 idx = 1; 7820 idx_offset = dirs[0].length > 0 ? 1 : 0; 7821 for (i = 1 - idx_offset; i < ndirs; i++) 7822 dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1, 7823 "Directory Entry: 0x%x", i + idx_offset); 7824 7825 dw2_asm_output_data (1, 0, "End directory table"); 7826 7827 /* We have to emit them in the order of emitted_number since that's 7828 used in the debug info generation. To do this efficiently we 7829 generate a back-mapping of the indices first. */ 7830 backmap = alloca (numfiles * sizeof (int)); 7831 for (i = 0; i < numfiles; i++) 7832 backmap[files[i].file_idx->emitted_number - 1] = i; 7833 7834 /* Now write all the file names. */ 7835 for (i = 0; i < numfiles; i++) 7836 { 7837 int file_idx = backmap[i]; 7838 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx; 7839 7840 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1, 7841 "File Entry: 0x%x", (unsigned) i + 1); 7842 7843 /* Include directory index. */ 7844 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL); 7845 7846 /* Modification time. */ 7847 dw2_asm_output_data_uleb128 (0, NULL); 7848 7849 /* File length in bytes. */ 7850 dw2_asm_output_data_uleb128 (0, NULL); 7851 } 7852 7853 dw2_asm_output_data (1, 0, "End file name table"); 7854} 7855 7856 7857/* Output the source line number correspondence information. This 7858 information goes into the .debug_line section. */ 7859 7860static void 7861output_line_info (void) 7862{ 7863 char l1[20], l2[20], p1[20], p2[20]; 7864 char line_label[MAX_ARTIFICIAL_LABEL_BYTES]; 7865 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES]; 7866 unsigned opc; 7867 unsigned n_op_args; 7868 unsigned long lt_index; 7869 unsigned long current_line; 7870 long line_offset; 7871 long line_delta; 7872 unsigned long current_file; 7873 unsigned long function; 7874 7875 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0); 7876 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0); 7877 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0); 7878 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0); 7879 7880 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 7881 dw2_asm_output_data (4, 0xffffffff, 7882 "Initial length escape value indicating 64-bit DWARF extension"); 7883 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1, 7884 "Length of Source Line Info"); 7885 ASM_OUTPUT_LABEL (asm_out_file, l1); 7886 7887 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version"); 7888 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length"); 7889 ASM_OUTPUT_LABEL (asm_out_file, p1); 7890 7891 /* Define the architecture-dependent minimum instruction length (in 7892 bytes). In this implementation of DWARF, this field is used for 7893 information purposes only. Since GCC generates assembly language, 7894 we have no a priori knowledge of how many instruction bytes are 7895 generated for each source line, and therefore can use only the 7896 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information 7897 commands. Accordingly, we fix this as `1', which is "correct 7898 enough" for all architectures, and don't let the target override. */ 7899 dw2_asm_output_data (1, 1, 7900 "Minimum Instruction Length"); 7901 7902 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START, 7903 "Default is_stmt_start flag"); 7904 dw2_asm_output_data (1, DWARF_LINE_BASE, 7905 "Line Base Value (Special Opcodes)"); 7906 dw2_asm_output_data (1, DWARF_LINE_RANGE, 7907 "Line Range Value (Special Opcodes)"); 7908 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE, 7909 "Special Opcode Base"); 7910 7911 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++) 7912 { 7913 switch (opc) 7914 { 7915 case DW_LNS_advance_pc: 7916 case DW_LNS_advance_line: 7917 case DW_LNS_set_file: 7918 case DW_LNS_set_column: 7919 case DW_LNS_fixed_advance_pc: 7920 n_op_args = 1; 7921 break; 7922 default: 7923 n_op_args = 0; 7924 break; 7925 } 7926 7927 dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args", 7928 opc, n_op_args); 7929 } 7930 7931 /* Write out the information about the files we use. */ 7932 output_file_names (); 7933 ASM_OUTPUT_LABEL (asm_out_file, p2); 7934 7935 /* We used to set the address register to the first location in the text 7936 section here, but that didn't accomplish anything since we already 7937 have a line note for the opening brace of the first function. */ 7938 7939 /* Generate the line number to PC correspondence table, encoded as 7940 a series of state machine operations. */ 7941 current_file = 1; 7942 current_line = 1; 7943 7944 if (cfun && in_cold_section_p) 7945 strcpy (prev_line_label, cfun->cold_section_label); 7946 else 7947 strcpy (prev_line_label, text_section_label); 7948 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index) 7949 { 7950 dw_line_info_ref line_info = &line_info_table[lt_index]; 7951 7952#if 0 7953 /* Disable this optimization for now; GDB wants to see two line notes 7954 at the beginning of a function so it can find the end of the 7955 prologue. */ 7956 7957 /* Don't emit anything for redundant notes. Just updating the 7958 address doesn't accomplish anything, because we already assume 7959 that anything after the last address is this line. */ 7960 if (line_info->dw_line_num == current_line 7961 && line_info->dw_file_num == current_file) 7962 continue; 7963#endif 7964 7965 /* Emit debug info for the address of the current line. 7966 7967 Unfortunately, we have little choice here currently, and must always 7968 use the most general form. GCC does not know the address delta 7969 itself, so we can't use DW_LNS_advance_pc. Many ports do have length 7970 attributes which will give an upper bound on the address range. We 7971 could perhaps use length attributes to determine when it is safe to 7972 use DW_LNS_fixed_advance_pc. */ 7973 7974 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index); 7975 if (0) 7976 { 7977 /* This can handle deltas up to 0xffff. This takes 3 bytes. */ 7978 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, 7979 "DW_LNS_fixed_advance_pc"); 7980 dw2_asm_output_delta (2, line_label, prev_line_label, NULL); 7981 } 7982 else 7983 { 7984 /* This can handle any delta. This takes 7985 4+DWARF2_ADDR_SIZE bytes. */ 7986 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 7987 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 7988 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 7989 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL); 7990 } 7991 7992 strcpy (prev_line_label, line_label); 7993 7994 /* Emit debug info for the source file of the current line, if 7995 different from the previous line. */ 7996 if (line_info->dw_file_num != current_file) 7997 { 7998 current_file = line_info->dw_file_num; 7999 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file"); 8000 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file); 8001 } 8002 8003 /* Emit debug info for the current line number, choosing the encoding 8004 that uses the least amount of space. */ 8005 if (line_info->dw_line_num != current_line) 8006 { 8007 line_offset = line_info->dw_line_num - current_line; 8008 line_delta = line_offset - DWARF_LINE_BASE; 8009 current_line = line_info->dw_line_num; 8010 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1)) 8011 /* This can handle deltas from -10 to 234, using the current 8012 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This 8013 takes 1 byte. */ 8014 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta, 8015 "line %lu", current_line); 8016 else 8017 { 8018 /* This can handle any delta. This takes at least 4 bytes, 8019 depending on the value being encoded. */ 8020 dw2_asm_output_data (1, DW_LNS_advance_line, 8021 "advance to line %lu", current_line); 8022 dw2_asm_output_data_sleb128 (line_offset, NULL); 8023 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); 8024 } 8025 } 8026 else 8027 /* We still need to start a new row, so output a copy insn. */ 8028 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); 8029 } 8030 8031 /* Emit debug info for the address of the end of the function. */ 8032 if (0) 8033 { 8034 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, 8035 "DW_LNS_fixed_advance_pc"); 8036 dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL); 8037 } 8038 else 8039 { 8040 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 8041 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 8042 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 8043 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL); 8044 } 8045 8046 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence"); 8047 dw2_asm_output_data_uleb128 (1, NULL); 8048 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL); 8049 8050 function = 0; 8051 current_file = 1; 8052 current_line = 1; 8053 for (lt_index = 0; lt_index < separate_line_info_table_in_use;) 8054 { 8055 dw_separate_line_info_ref line_info 8056 = &separate_line_info_table[lt_index]; 8057 8058#if 0 8059 /* Don't emit anything for redundant notes. */ 8060 if (line_info->dw_line_num == current_line 8061 && line_info->dw_file_num == current_file 8062 && line_info->function == function) 8063 goto cont; 8064#endif 8065 8066 /* Emit debug info for the address of the current line. If this is 8067 a new function, or the first line of a function, then we need 8068 to handle it differently. */ 8069 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL, 8070 lt_index); 8071 if (function != line_info->function) 8072 { 8073 function = line_info->function; 8074 8075 /* Set the address register to the first line in the function. */ 8076 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 8077 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 8078 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 8079 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL); 8080 } 8081 else 8082 { 8083 /* ??? See the DW_LNS_advance_pc comment above. */ 8084 if (0) 8085 { 8086 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, 8087 "DW_LNS_fixed_advance_pc"); 8088 dw2_asm_output_delta (2, line_label, prev_line_label, NULL); 8089 } 8090 else 8091 { 8092 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 8093 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 8094 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 8095 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL); 8096 } 8097 } 8098 8099 strcpy (prev_line_label, line_label); 8100 8101 /* Emit debug info for the source file of the current line, if 8102 different from the previous line. */ 8103 if (line_info->dw_file_num != current_file) 8104 { 8105 current_file = line_info->dw_file_num; 8106 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file"); 8107 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file); 8108 } 8109 8110 /* Emit debug info for the current line number, choosing the encoding 8111 that uses the least amount of space. */ 8112 if (line_info->dw_line_num != current_line) 8113 { 8114 line_offset = line_info->dw_line_num - current_line; 8115 line_delta = line_offset - DWARF_LINE_BASE; 8116 current_line = line_info->dw_line_num; 8117 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1)) 8118 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta, 8119 "line %lu", current_line); 8120 else 8121 { 8122 dw2_asm_output_data (1, DW_LNS_advance_line, 8123 "advance to line %lu", current_line); 8124 dw2_asm_output_data_sleb128 (line_offset, NULL); 8125 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); 8126 } 8127 } 8128 else 8129 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); 8130 8131#if 0 8132 cont: 8133#endif 8134 8135 lt_index++; 8136 8137 /* If we're done with a function, end its sequence. */ 8138 if (lt_index == separate_line_info_table_in_use 8139 || separate_line_info_table[lt_index].function != function) 8140 { 8141 current_file = 1; 8142 current_line = 1; 8143 8144 /* Emit debug info for the address of the end of the function. */ 8145 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function); 8146 if (0) 8147 { 8148 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, 8149 "DW_LNS_fixed_advance_pc"); 8150 dw2_asm_output_delta (2, line_label, prev_line_label, NULL); 8151 } 8152 else 8153 { 8154 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 8155 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 8156 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 8157 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL); 8158 } 8159 8160 /* Output the marker for the end of this sequence. */ 8161 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence"); 8162 dw2_asm_output_data_uleb128 (1, NULL); 8163 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL); 8164 } 8165 } 8166 8167 /* Output the marker for the end of the line number info. */ 8168 ASM_OUTPUT_LABEL (asm_out_file, l2); 8169} 8170 8171/* Given a pointer to a tree node for some base type, return a pointer to 8172 a DIE that describes the given type. 8173 8174 This routine must only be called for GCC type nodes that correspond to 8175 Dwarf base (fundamental) types. */ 8176 8177static dw_die_ref 8178base_type_die (tree type) 8179{ 8180 dw_die_ref base_type_result; 8181 enum dwarf_type encoding; 8182 8183 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE) 8184 return 0; 8185 8186 switch (TREE_CODE (type)) 8187 { 8188 case INTEGER_TYPE: 8189 if (TYPE_STRING_FLAG (type)) 8190 { 8191 if (TYPE_UNSIGNED (type)) 8192 encoding = DW_ATE_unsigned_char; 8193 else 8194 encoding = DW_ATE_signed_char; 8195 } 8196 else if (TYPE_UNSIGNED (type)) 8197 encoding = DW_ATE_unsigned; 8198 else 8199 encoding = DW_ATE_signed; 8200 break; 8201 8202 case REAL_TYPE: 8203 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type))) 8204 encoding = DW_ATE_decimal_float; 8205 else 8206 encoding = DW_ATE_float; 8207 break; 8208 8209 /* Dwarf2 doesn't know anything about complex ints, so use 8210 a user defined type for it. */ 8211 case COMPLEX_TYPE: 8212 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE) 8213 encoding = DW_ATE_complex_float; 8214 else 8215 encoding = DW_ATE_lo_user; 8216 break; 8217 8218 case BOOLEAN_TYPE: 8219 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */ 8220 encoding = DW_ATE_boolean; 8221 break; 8222 8223 default: 8224 /* No other TREE_CODEs are Dwarf fundamental types. */ 8225 gcc_unreachable (); 8226 } 8227 8228 base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type); 8229 8230 /* This probably indicates a bug. */ 8231 if (! TYPE_NAME (type)) 8232 add_name_attribute (base_type_result, "__unknown__"); 8233 8234 add_AT_unsigned (base_type_result, DW_AT_byte_size, 8235 int_size_in_bytes (type)); 8236 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding); 8237 8238 return base_type_result; 8239} 8240 8241/* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to 8242 the Dwarf "root" type for the given input type. The Dwarf "root" type of 8243 a given type is generally the same as the given type, except that if the 8244 given type is a pointer or reference type, then the root type of the given 8245 type is the root type of the "basis" type for the pointer or reference 8246 type. (This definition of the "root" type is recursive.) Also, the root 8247 type of a `const' qualified type or a `volatile' qualified type is the 8248 root type of the given type without the qualifiers. */ 8249 8250static tree 8251root_type (tree type) 8252{ 8253 if (TREE_CODE (type) == ERROR_MARK) 8254 return error_mark_node; 8255 8256 switch (TREE_CODE (type)) 8257 { 8258 case ERROR_MARK: 8259 return error_mark_node; 8260 8261 case POINTER_TYPE: 8262 case REFERENCE_TYPE: 8263 return type_main_variant (root_type (TREE_TYPE (type))); 8264 8265 default: 8266 return type_main_variant (type); 8267 } 8268} 8269 8270/* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the 8271 given input type is a Dwarf "fundamental" type. Otherwise return null. */ 8272 8273static inline int 8274is_base_type (tree type) 8275{ 8276 switch (TREE_CODE (type)) 8277 { 8278 case ERROR_MARK: 8279 case VOID_TYPE: 8280 case INTEGER_TYPE: 8281 case REAL_TYPE: 8282 case COMPLEX_TYPE: 8283 case BOOLEAN_TYPE: 8284 return 1; 8285 8286 case ARRAY_TYPE: 8287 case RECORD_TYPE: 8288 case UNION_TYPE: 8289 case QUAL_UNION_TYPE: 8290 case ENUMERAL_TYPE: 8291 case FUNCTION_TYPE: 8292 case METHOD_TYPE: 8293 case POINTER_TYPE: 8294 case REFERENCE_TYPE: 8295 case OFFSET_TYPE: 8296 case LANG_TYPE: 8297 case VECTOR_TYPE: 8298 return 0; 8299 8300 default: 8301 gcc_unreachable (); 8302 } 8303 8304 return 0; 8305} 8306 8307/* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE 8308 node, return the size in bits for the type if it is a constant, or else 8309 return the alignment for the type if the type's size is not constant, or 8310 else return BITS_PER_WORD if the type actually turns out to be an 8311 ERROR_MARK node. */ 8312 8313static inline unsigned HOST_WIDE_INT 8314simple_type_size_in_bits (tree type) 8315{ 8316 if (TREE_CODE (type) == ERROR_MARK) 8317 return BITS_PER_WORD; 8318 else if (TYPE_SIZE (type) == NULL_TREE) 8319 return 0; 8320 else if (host_integerp (TYPE_SIZE (type), 1)) 8321 return tree_low_cst (TYPE_SIZE (type), 1); 8322 else 8323 return TYPE_ALIGN (type); 8324} 8325 8326/* Return true if the debug information for the given type should be 8327 emitted as a subrange type. */ 8328 8329static inline bool 8330is_subrange_type (tree type) 8331{ 8332 tree subtype = TREE_TYPE (type); 8333 8334 /* Subrange types are identified by the fact that they are integer 8335 types, and that they have a subtype which is either an integer type 8336 or an enumeral type. */ 8337 8338 if (TREE_CODE (type) != INTEGER_TYPE 8339 || subtype == NULL_TREE) 8340 return false; 8341 8342 if (TREE_CODE (subtype) != INTEGER_TYPE 8343 && TREE_CODE (subtype) != ENUMERAL_TYPE) 8344 return false; 8345 8346 if (TREE_CODE (type) == TREE_CODE (subtype) 8347 && int_size_in_bytes (type) == int_size_in_bytes (subtype) 8348 && TYPE_MIN_VALUE (type) != NULL 8349 && TYPE_MIN_VALUE (subtype) != NULL 8350 && tree_int_cst_equal (TYPE_MIN_VALUE (type), TYPE_MIN_VALUE (subtype)) 8351 && TYPE_MAX_VALUE (type) != NULL 8352 && TYPE_MAX_VALUE (subtype) != NULL 8353 && tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype))) 8354 { 8355 /* The type and its subtype have the same representation. If in 8356 addition the two types also have the same name, then the given 8357 type is not a subrange type, but rather a plain base type. */ 8358 /* FIXME: brobecker/2004-03-22: 8359 Sizetype INTEGER_CSTs nodes are canonicalized. It should 8360 therefore be sufficient to check the TYPE_SIZE node pointers 8361 rather than checking the actual size. Unfortunately, we have 8362 found some cases, such as in the Ada "integer" type, where 8363 this is not the case. Until this problem is solved, we need to 8364 keep checking the actual size. */ 8365 tree type_name = TYPE_NAME (type); 8366 tree subtype_name = TYPE_NAME (subtype); 8367 8368 if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL) 8369 type_name = DECL_NAME (type_name); 8370 8371 if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL) 8372 subtype_name = DECL_NAME (subtype_name); 8373 8374 if (type_name == subtype_name) 8375 return false; 8376 } 8377 8378 return true; 8379} 8380 8381/* Given a pointer to a tree node for a subrange type, return a pointer 8382 to a DIE that describes the given type. */ 8383 8384static dw_die_ref 8385subrange_type_die (tree type, dw_die_ref context_die) 8386{ 8387 dw_die_ref subrange_die; 8388 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type); 8389 8390 if (context_die == NULL) 8391 context_die = comp_unit_die; 8392 8393 subrange_die = new_die (DW_TAG_subrange_type, context_die, type); 8394 8395 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes) 8396 { 8397 /* The size of the subrange type and its base type do not match, 8398 so we need to generate a size attribute for the subrange type. */ 8399 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes); 8400 } 8401 8402 if (TYPE_MIN_VALUE (type) != NULL) 8403 add_bound_info (subrange_die, DW_AT_lower_bound, 8404 TYPE_MIN_VALUE (type)); 8405 if (TYPE_MAX_VALUE (type) != NULL) 8406 add_bound_info (subrange_die, DW_AT_upper_bound, 8407 TYPE_MAX_VALUE (type)); 8408 8409 return subrange_die; 8410} 8411 8412/* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging 8413 entry that chains various modifiers in front of the given type. */ 8414 8415static dw_die_ref 8416modified_type_die (tree type, int is_const_type, int is_volatile_type, 8417 dw_die_ref context_die) 8418{ 8419 enum tree_code code = TREE_CODE (type); 8420 dw_die_ref mod_type_die; 8421 dw_die_ref sub_die = NULL; 8422 tree item_type = NULL; 8423 tree qualified_type; 8424 tree name; 8425 8426 if (code == ERROR_MARK) 8427 return NULL; 8428 8429 /* See if we already have the appropriately qualified variant of 8430 this type. */ 8431 qualified_type 8432 = get_qualified_type (type, 8433 ((is_const_type ? TYPE_QUAL_CONST : 0) 8434 | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0))); 8435 8436 /* If we do, then we can just use its DIE, if it exists. */ 8437 if (qualified_type) 8438 { 8439 mod_type_die = lookup_type_die (qualified_type); 8440 if (mod_type_die) 8441 return mod_type_die; 8442 } 8443 8444 name = qualified_type ? TYPE_NAME (qualified_type) : NULL; 8445 8446 /* Handle C typedef types. */ 8447 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name)) 8448 { 8449 tree dtype = TREE_TYPE (name); 8450 8451 if (qualified_type == dtype) 8452 { 8453 /* For a named type, use the typedef. */ 8454 gen_type_die (qualified_type, context_die); 8455 return lookup_type_die (qualified_type); 8456 } 8457 else if (is_const_type < TYPE_READONLY (dtype) 8458 || is_volatile_type < TYPE_VOLATILE (dtype) 8459 || (is_const_type <= TYPE_READONLY (dtype) 8460 && is_volatile_type <= TYPE_VOLATILE (dtype) 8461 && DECL_ORIGINAL_TYPE (name) != type)) 8462 /* cv-unqualified version of named type. Just use the unnamed 8463 type to which it refers. */ 8464 return modified_type_die (DECL_ORIGINAL_TYPE (name), 8465 is_const_type, is_volatile_type, 8466 context_die); 8467 /* Else cv-qualified version of named type; fall through. */ 8468 } 8469 8470 if (is_const_type) 8471 { 8472 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type); 8473 sub_die = modified_type_die (type, 0, is_volatile_type, context_die); 8474 } 8475 else if (is_volatile_type) 8476 { 8477 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type); 8478 sub_die = modified_type_die (type, 0, 0, context_die); 8479 } 8480 else if (code == POINTER_TYPE) 8481 { 8482 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type); 8483 add_AT_unsigned (mod_type_die, DW_AT_byte_size, 8484 simple_type_size_in_bits (type) / BITS_PER_UNIT); 8485 item_type = TREE_TYPE (type); 8486 } 8487 else if (code == REFERENCE_TYPE) 8488 { 8489 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type); 8490 add_AT_unsigned (mod_type_die, DW_AT_byte_size, 8491 simple_type_size_in_bits (type) / BITS_PER_UNIT); 8492 item_type = TREE_TYPE (type); 8493 } 8494 else if (is_subrange_type (type)) 8495 { 8496 mod_type_die = subrange_type_die (type, context_die); 8497 item_type = TREE_TYPE (type); 8498 } 8499 else if (is_base_type (type)) 8500 mod_type_die = base_type_die (type); 8501 else 8502 { 8503 gen_type_die (type, context_die); 8504 8505 /* We have to get the type_main_variant here (and pass that to the 8506 `lookup_type_die' routine) because the ..._TYPE node we have 8507 might simply be a *copy* of some original type node (where the 8508 copy was created to help us keep track of typedef names) and 8509 that copy might have a different TYPE_UID from the original 8510 ..._TYPE node. */ 8511 if (TREE_CODE (type) != VECTOR_TYPE) 8512 return lookup_type_die (type_main_variant (type)); 8513 else 8514 /* Vectors have the debugging information in the type, 8515 not the main variant. */ 8516 return lookup_type_die (type); 8517 } 8518 8519 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those, 8520 don't output a DW_TAG_typedef, since there isn't one in the 8521 user's program; just attach a DW_AT_name to the type. */ 8522 if (name 8523 && (TREE_CODE (name) != TYPE_DECL || TREE_TYPE (name) == qualified_type)) 8524 { 8525 if (TREE_CODE (name) == TYPE_DECL) 8526 /* Could just call add_name_and_src_coords_attributes here, 8527 but since this is a builtin type it doesn't have any 8528 useful source coordinates anyway. */ 8529 name = DECL_NAME (name); 8530 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name)); 8531 } 8532 8533 if (qualified_type) 8534 equate_type_number_to_die (qualified_type, mod_type_die); 8535 8536 if (item_type) 8537 /* We must do this after the equate_type_number_to_die call, in case 8538 this is a recursive type. This ensures that the modified_type_die 8539 recursion will terminate even if the type is recursive. Recursive 8540 types are possible in Ada. */ 8541 sub_die = modified_type_die (item_type, 8542 TYPE_READONLY (item_type), 8543 TYPE_VOLATILE (item_type), 8544 context_die); 8545 8546 if (sub_die != NULL) 8547 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die); 8548 8549 return mod_type_die; 8550} 8551 8552/* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is 8553 an enumerated type. */ 8554 8555static inline int 8556type_is_enum (tree type) 8557{ 8558 return TREE_CODE (type) == ENUMERAL_TYPE; 8559} 8560 8561/* Return the DBX register number described by a given RTL node. */ 8562 8563static unsigned int 8564dbx_reg_number (rtx rtl) 8565{ 8566 unsigned regno = REGNO (rtl); 8567 8568 gcc_assert (regno < FIRST_PSEUDO_REGISTER); 8569 8570#ifdef LEAF_REG_REMAP 8571 if (current_function_uses_only_leaf_regs) 8572 { 8573 int leaf_reg = LEAF_REG_REMAP (regno); 8574 if (leaf_reg != -1) 8575 regno = (unsigned) leaf_reg; 8576 } 8577#endif 8578 8579 return DBX_REGISTER_NUMBER (regno); 8580} 8581 8582/* Optionally add a DW_OP_piece term to a location description expression. 8583 DW_OP_piece is only added if the location description expression already 8584 doesn't end with DW_OP_piece. */ 8585 8586static void 8587add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size) 8588{ 8589 dw_loc_descr_ref loc; 8590 8591 if (*list_head != NULL) 8592 { 8593 /* Find the end of the chain. */ 8594 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next) 8595 ; 8596 8597 if (loc->dw_loc_opc != DW_OP_piece) 8598 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0); 8599 } 8600} 8601 8602/* Return a location descriptor that designates a machine register or 8603 zero if there is none. */ 8604 8605static dw_loc_descr_ref 8606reg_loc_descriptor (rtx rtl) 8607{ 8608 rtx regs; 8609 8610 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER) 8611 return 0; 8612 8613 regs = targetm.dwarf_register_span (rtl); 8614 8615 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs) 8616 return multiple_reg_loc_descriptor (rtl, regs); 8617 else 8618 return one_reg_loc_descriptor (dbx_reg_number (rtl)); 8619} 8620 8621/* Return a location descriptor that designates a machine register for 8622 a given hard register number. */ 8623 8624static dw_loc_descr_ref 8625one_reg_loc_descriptor (unsigned int regno) 8626{ 8627 if (regno <= 31) 8628 return new_loc_descr (DW_OP_reg0 + regno, 0, 0); 8629 else 8630 return new_loc_descr (DW_OP_regx, regno, 0); 8631} 8632 8633/* Given an RTL of a register, return a location descriptor that 8634 designates a value that spans more than one register. */ 8635 8636static dw_loc_descr_ref 8637multiple_reg_loc_descriptor (rtx rtl, rtx regs) 8638{ 8639 int nregs, size, i; 8640 unsigned reg; 8641 dw_loc_descr_ref loc_result = NULL; 8642 8643 reg = REGNO (rtl); 8644#ifdef LEAF_REG_REMAP 8645 if (current_function_uses_only_leaf_regs) 8646 { 8647 int leaf_reg = LEAF_REG_REMAP (reg); 8648 if (leaf_reg != -1) 8649 reg = (unsigned) leaf_reg; 8650 } 8651#endif 8652 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl)); 8653 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)]; 8654 8655 /* Simple, contiguous registers. */ 8656 if (regs == NULL_RTX) 8657 { 8658 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs; 8659 8660 loc_result = NULL; 8661 while (nregs--) 8662 { 8663 dw_loc_descr_ref t; 8664 8665 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg)); 8666 add_loc_descr (&loc_result, t); 8667 add_loc_descr_op_piece (&loc_result, size); 8668 ++reg; 8669 } 8670 return loc_result; 8671 } 8672 8673 /* Now onto stupid register sets in non contiguous locations. */ 8674 8675 gcc_assert (GET_CODE (regs) == PARALLEL); 8676 8677 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0))); 8678 loc_result = NULL; 8679 8680 for (i = 0; i < XVECLEN (regs, 0); ++i) 8681 { 8682 dw_loc_descr_ref t; 8683 8684 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i))); 8685 add_loc_descr (&loc_result, t); 8686 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0))); 8687 add_loc_descr_op_piece (&loc_result, size); 8688 } 8689 return loc_result; 8690} 8691 8692/* Return a location descriptor that designates a constant. */ 8693 8694static dw_loc_descr_ref 8695int_loc_descriptor (HOST_WIDE_INT i) 8696{ 8697 enum dwarf_location_atom op; 8698 8699 /* Pick the smallest representation of a constant, rather than just 8700 defaulting to the LEB encoding. */ 8701 if (i >= 0) 8702 { 8703 if (i <= 31) 8704 op = DW_OP_lit0 + i; 8705 else if (i <= 0xff) 8706 op = DW_OP_const1u; 8707 else if (i <= 0xffff) 8708 op = DW_OP_const2u; 8709 else if (HOST_BITS_PER_WIDE_INT == 32 8710 || i <= 0xffffffff) 8711 op = DW_OP_const4u; 8712 else 8713 op = DW_OP_constu; 8714 } 8715 else 8716 { 8717 if (i >= -0x80) 8718 op = DW_OP_const1s; 8719 else if (i >= -0x8000) 8720 op = DW_OP_const2s; 8721 else if (HOST_BITS_PER_WIDE_INT == 32 8722 || i >= -0x80000000) 8723 op = DW_OP_const4s; 8724 else 8725 op = DW_OP_consts; 8726 } 8727 8728 return new_loc_descr (op, i, 0); 8729} 8730 8731/* Return a location descriptor that designates a base+offset location. */ 8732 8733static dw_loc_descr_ref 8734based_loc_descr (rtx reg, HOST_WIDE_INT offset) 8735{ 8736 unsigned int regno; 8737 8738 /* We only use "frame base" when we're sure we're talking about the 8739 post-prologue local stack frame. We do this by *not* running 8740 register elimination until this point, and recognizing the special 8741 argument pointer and soft frame pointer rtx's. */ 8742 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx) 8743 { 8744 rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX); 8745 8746 if (elim != reg) 8747 { 8748 if (GET_CODE (elim) == PLUS) 8749 { 8750 offset += INTVAL (XEXP (elim, 1)); 8751 elim = XEXP (elim, 0); 8752 } 8753 gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx 8754 : stack_pointer_rtx)); 8755 offset += frame_pointer_fb_offset; 8756 8757 return new_loc_descr (DW_OP_fbreg, offset, 0); 8758 } 8759 } 8760 8761 regno = dbx_reg_number (reg); 8762 if (regno <= 31) 8763 return new_loc_descr (DW_OP_breg0 + regno, offset, 0); 8764 else 8765 return new_loc_descr (DW_OP_bregx, regno, offset); 8766} 8767 8768/* Return true if this RTL expression describes a base+offset calculation. */ 8769 8770static inline int 8771is_based_loc (rtx rtl) 8772{ 8773 return (GET_CODE (rtl) == PLUS 8774 && ((REG_P (XEXP (rtl, 0)) 8775 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER 8776 && GET_CODE (XEXP (rtl, 1)) == CONST_INT))); 8777} 8778 8779/* The following routine converts the RTL for a variable or parameter 8780 (resident in memory) into an equivalent Dwarf representation of a 8781 mechanism for getting the address of that same variable onto the top of a 8782 hypothetical "address evaluation" stack. 8783 8784 When creating memory location descriptors, we are effectively transforming 8785 the RTL for a memory-resident object into its Dwarf postfix expression 8786 equivalent. This routine recursively descends an RTL tree, turning 8787 it into Dwarf postfix code as it goes. 8788 8789 MODE is the mode of the memory reference, needed to handle some 8790 autoincrement addressing modes. 8791 8792 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the 8793 location list for RTL. 8794 8795 Return 0 if we can't represent the location. */ 8796 8797static dw_loc_descr_ref 8798mem_loc_descriptor (rtx rtl, enum machine_mode mode) 8799{ 8800 dw_loc_descr_ref mem_loc_result = NULL; 8801 enum dwarf_location_atom op; 8802 8803 /* Note that for a dynamically sized array, the location we will generate a 8804 description of here will be the lowest numbered location which is 8805 actually within the array. That's *not* necessarily the same as the 8806 zeroth element of the array. */ 8807 8808 rtl = targetm.delegitimize_address (rtl); 8809 8810 switch (GET_CODE (rtl)) 8811 { 8812 case POST_INC: 8813 case POST_DEC: 8814 case POST_MODIFY: 8815 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we 8816 just fall into the SUBREG code. */ 8817 8818 /* ... fall through ... */ 8819 8820 case SUBREG: 8821 /* The case of a subreg may arise when we have a local (register) 8822 variable or a formal (register) parameter which doesn't quite fill 8823 up an entire register. For now, just assume that it is 8824 legitimate to make the Dwarf info refer to the whole register which 8825 contains the given subreg. */ 8826 rtl = XEXP (rtl, 0); 8827 8828 /* ... fall through ... */ 8829 8830 case REG: 8831 /* Whenever a register number forms a part of the description of the 8832 method for calculating the (dynamic) address of a memory resident 8833 object, DWARF rules require the register number be referred to as 8834 a "base register". This distinction is not based in any way upon 8835 what category of register the hardware believes the given register 8836 belongs to. This is strictly DWARF terminology we're dealing with 8837 here. Note that in cases where the location of a memory-resident 8838 data object could be expressed as: OP_ADD (OP_BASEREG (basereg), 8839 OP_CONST (0)) the actual DWARF location descriptor that we generate 8840 may just be OP_BASEREG (basereg). This may look deceptively like 8841 the object in question was allocated to a register (rather than in 8842 memory) so DWARF consumers need to be aware of the subtle 8843 distinction between OP_REG and OP_BASEREG. */ 8844 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER) 8845 mem_loc_result = based_loc_descr (rtl, 0); 8846 break; 8847 8848 case MEM: 8849 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl)); 8850 if (mem_loc_result != 0) 8851 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0)); 8852 break; 8853 8854 case LO_SUM: 8855 rtl = XEXP (rtl, 1); 8856 8857 /* ... fall through ... */ 8858 8859 case LABEL_REF: 8860 /* Some ports can transform a symbol ref into a label ref, because 8861 the symbol ref is too far away and has to be dumped into a constant 8862 pool. */ 8863 case CONST: 8864 case SYMBOL_REF: 8865 /* Alternatively, the symbol in the constant pool might be referenced 8866 by a different symbol. */ 8867 if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl)) 8868 { 8869 bool marked; 8870 rtx tmp = get_pool_constant_mark (rtl, &marked); 8871 8872 if (GET_CODE (tmp) == SYMBOL_REF) 8873 { 8874 rtl = tmp; 8875 if (CONSTANT_POOL_ADDRESS_P (tmp)) 8876 get_pool_constant_mark (tmp, &marked); 8877 else 8878 marked = true; 8879 } 8880 8881 /* If all references to this pool constant were optimized away, 8882 it was not output and thus we can't represent it. 8883 FIXME: might try to use DW_OP_const_value here, though 8884 DW_OP_piece complicates it. */ 8885 if (!marked) 8886 return 0; 8887 } 8888 8889 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0); 8890 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr; 8891 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl; 8892 VEC_safe_push (rtx, gc, used_rtx_array, rtl); 8893 break; 8894 8895 case PRE_MODIFY: 8896 /* Extract the PLUS expression nested inside and fall into 8897 PLUS code below. */ 8898 rtl = XEXP (rtl, 1); 8899 goto plus; 8900 8901 case PRE_INC: 8902 case PRE_DEC: 8903 /* Turn these into a PLUS expression and fall into the PLUS code 8904 below. */ 8905 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0), 8906 GEN_INT (GET_CODE (rtl) == PRE_INC 8907 ? GET_MODE_UNIT_SIZE (mode) 8908 : -GET_MODE_UNIT_SIZE (mode))); 8909 8910 /* ... fall through ... */ 8911 8912 case PLUS: 8913 plus: 8914 if (is_based_loc (rtl)) 8915 mem_loc_result = based_loc_descr (XEXP (rtl, 0), 8916 INTVAL (XEXP (rtl, 1))); 8917 else 8918 { 8919 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode); 8920 if (mem_loc_result == 0) 8921 break; 8922 8923 if (GET_CODE (XEXP (rtl, 1)) == CONST_INT 8924 && INTVAL (XEXP (rtl, 1)) >= 0) 8925 add_loc_descr (&mem_loc_result, 8926 new_loc_descr (DW_OP_plus_uconst, 8927 INTVAL (XEXP (rtl, 1)), 0)); 8928 else 8929 { 8930 add_loc_descr (&mem_loc_result, 8931 mem_loc_descriptor (XEXP (rtl, 1), mode)); 8932 add_loc_descr (&mem_loc_result, 8933 new_loc_descr (DW_OP_plus, 0, 0)); 8934 } 8935 } 8936 break; 8937 8938 /* If a pseudo-reg is optimized away, it is possible for it to 8939 be replaced with a MEM containing a multiply or shift. */ 8940 case MULT: 8941 op = DW_OP_mul; 8942 goto do_binop; 8943 8944 case ASHIFT: 8945 op = DW_OP_shl; 8946 goto do_binop; 8947 8948 case ASHIFTRT: 8949 op = DW_OP_shra; 8950 goto do_binop; 8951 8952 case LSHIFTRT: 8953 op = DW_OP_shr; 8954 goto do_binop; 8955 8956 do_binop: 8957 { 8958 dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode); 8959 dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode); 8960 8961 if (op0 == 0 || op1 == 0) 8962 break; 8963 8964 mem_loc_result = op0; 8965 add_loc_descr (&mem_loc_result, op1); 8966 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0)); 8967 break; 8968 } 8969 8970 case CONST_INT: 8971 mem_loc_result = int_loc_descriptor (INTVAL (rtl)); 8972 break; 8973 8974 default: 8975 gcc_unreachable (); 8976 } 8977 8978 return mem_loc_result; 8979} 8980 8981/* Return a descriptor that describes the concatenation of two locations. 8982 This is typically a complex variable. */ 8983 8984static dw_loc_descr_ref 8985concat_loc_descriptor (rtx x0, rtx x1) 8986{ 8987 dw_loc_descr_ref cc_loc_result = NULL; 8988 dw_loc_descr_ref x0_ref = loc_descriptor (x0); 8989 dw_loc_descr_ref x1_ref = loc_descriptor (x1); 8990 8991 if (x0_ref == 0 || x1_ref == 0) 8992 return 0; 8993 8994 cc_loc_result = x0_ref; 8995 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0))); 8996 8997 add_loc_descr (&cc_loc_result, x1_ref); 8998 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1))); 8999 9000 return cc_loc_result; 9001} 9002 9003/* Output a proper Dwarf location descriptor for a variable or parameter 9004 which is either allocated in a register or in a memory location. For a 9005 register, we just generate an OP_REG and the register number. For a 9006 memory location we provide a Dwarf postfix expression describing how to 9007 generate the (dynamic) address of the object onto the address stack. 9008 9009 If we don't know how to describe it, return 0. */ 9010 9011static dw_loc_descr_ref 9012loc_descriptor (rtx rtl) 9013{ 9014 dw_loc_descr_ref loc_result = NULL; 9015 9016 switch (GET_CODE (rtl)) 9017 { 9018 case SUBREG: 9019 /* The case of a subreg may arise when we have a local (register) 9020 variable or a formal (register) parameter which doesn't quite fill 9021 up an entire register. For now, just assume that it is 9022 legitimate to make the Dwarf info refer to the whole register which 9023 contains the given subreg. */ 9024 rtl = SUBREG_REG (rtl); 9025 9026 /* ... fall through ... */ 9027 9028 case REG: 9029 loc_result = reg_loc_descriptor (rtl); 9030 break; 9031 9032 case MEM: 9033 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl)); 9034 break; 9035 9036 case CONCAT: 9037 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1)); 9038 break; 9039 9040 case VAR_LOCATION: 9041 /* Single part. */ 9042 if (GET_CODE (XEXP (rtl, 1)) != PARALLEL) 9043 { 9044 loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0)); 9045 break; 9046 } 9047 9048 rtl = XEXP (rtl, 1); 9049 /* FALLTHRU */ 9050 9051 case PARALLEL: 9052 { 9053 rtvec par_elems = XVEC (rtl, 0); 9054 int num_elem = GET_NUM_ELEM (par_elems); 9055 enum machine_mode mode; 9056 int i; 9057 9058 /* Create the first one, so we have something to add to. */ 9059 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0)); 9060 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0)); 9061 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode)); 9062 for (i = 1; i < num_elem; i++) 9063 { 9064 dw_loc_descr_ref temp; 9065 9066 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0)); 9067 add_loc_descr (&loc_result, temp); 9068 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0)); 9069 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode)); 9070 } 9071 } 9072 break; 9073 9074 default: 9075 gcc_unreachable (); 9076 } 9077 9078 return loc_result; 9079} 9080 9081/* Similar, but generate the descriptor from trees instead of rtl. This comes 9082 up particularly with variable length arrays. WANT_ADDRESS is 2 if this is 9083 a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a 9084 top-level invocation, and we require the address of LOC; is 0 if we require 9085 the value of LOC. */ 9086 9087static dw_loc_descr_ref 9088loc_descriptor_from_tree_1 (tree loc, int want_address) 9089{ 9090 dw_loc_descr_ref ret, ret1; 9091 int have_address = 0; 9092 enum dwarf_location_atom op; 9093 9094 /* ??? Most of the time we do not take proper care for sign/zero 9095 extending the values properly. Hopefully this won't be a real 9096 problem... */ 9097 9098 switch (TREE_CODE (loc)) 9099 { 9100 case ERROR_MARK: 9101 return 0; 9102 9103 case PLACEHOLDER_EXPR: 9104 /* This case involves extracting fields from an object to determine the 9105 position of other fields. We don't try to encode this here. The 9106 only user of this is Ada, which encodes the needed information using 9107 the names of types. */ 9108 return 0; 9109 9110 case CALL_EXPR: 9111 return 0; 9112 9113 case PREINCREMENT_EXPR: 9114 case PREDECREMENT_EXPR: 9115 case POSTINCREMENT_EXPR: 9116 case POSTDECREMENT_EXPR: 9117 /* There are no opcodes for these operations. */ 9118 return 0; 9119 9120 case ADDR_EXPR: 9121 /* If we already want an address, there's nothing we can do. */ 9122 if (want_address) 9123 return 0; 9124 9125 /* Otherwise, process the argument and look for the address. */ 9126 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1); 9127 9128 case VAR_DECL: 9129 if (DECL_THREAD_LOCAL_P (loc)) 9130 { 9131 rtx rtl; 9132 9133 /* If this is not defined, we have no way to emit the data. */ 9134 if (!targetm.asm_out.output_dwarf_dtprel) 9135 return 0; 9136 9137 /* The way DW_OP_GNU_push_tls_address is specified, we can only 9138 look up addresses of objects in the current module. */ 9139 if (DECL_EXTERNAL (loc)) 9140 return 0; 9141 9142 rtl = rtl_for_decl_location (loc); 9143 if (rtl == NULL_RTX) 9144 return 0; 9145 9146 if (!MEM_P (rtl)) 9147 return 0; 9148 rtl = XEXP (rtl, 0); 9149 if (! CONSTANT_P (rtl)) 9150 return 0; 9151 9152 ret = new_loc_descr (INTERNAL_DW_OP_tls_addr, 0, 0); 9153 ret->dw_loc_oprnd1.val_class = dw_val_class_addr; 9154 ret->dw_loc_oprnd1.v.val_addr = rtl; 9155 9156 ret1 = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0); 9157 add_loc_descr (&ret, ret1); 9158 9159 have_address = 1; 9160 break; 9161 } 9162 /* FALLTHRU */ 9163 9164 case PARM_DECL: 9165 if (DECL_HAS_VALUE_EXPR_P (loc)) 9166 return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc), 9167 want_address); 9168 /* FALLTHRU */ 9169 9170 case RESULT_DECL: 9171 case FUNCTION_DECL: 9172 { 9173 rtx rtl = rtl_for_decl_location (loc); 9174 9175 if (rtl == NULL_RTX) 9176 return 0; 9177 else if (GET_CODE (rtl) == CONST_INT) 9178 { 9179 HOST_WIDE_INT val = INTVAL (rtl); 9180 if (TYPE_UNSIGNED (TREE_TYPE (loc))) 9181 val &= GET_MODE_MASK (DECL_MODE (loc)); 9182 ret = int_loc_descriptor (val); 9183 } 9184 else if (GET_CODE (rtl) == CONST_STRING) 9185 return 0; 9186 else if (CONSTANT_P (rtl)) 9187 { 9188 ret = new_loc_descr (DW_OP_addr, 0, 0); 9189 ret->dw_loc_oprnd1.val_class = dw_val_class_addr; 9190 ret->dw_loc_oprnd1.v.val_addr = rtl; 9191 } 9192 else 9193 { 9194 enum machine_mode mode; 9195 9196 /* Certain constructs can only be represented at top-level. */ 9197 if (want_address == 2) 9198 return loc_descriptor (rtl); 9199 9200 mode = GET_MODE (rtl); 9201 if (MEM_P (rtl)) 9202 { 9203 rtl = XEXP (rtl, 0); 9204 have_address = 1; 9205 } 9206 ret = mem_loc_descriptor (rtl, mode); 9207 } 9208 } 9209 break; 9210 9211 case INDIRECT_REF: 9212 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0); 9213 have_address = 1; 9214 break; 9215 9216 case COMPOUND_EXPR: 9217 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address); 9218 9219 case NOP_EXPR: 9220 case CONVERT_EXPR: 9221 case NON_LVALUE_EXPR: 9222 case VIEW_CONVERT_EXPR: 9223 case SAVE_EXPR: 9224 case MODIFY_EXPR: 9225 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), want_address); 9226 9227 case COMPONENT_REF: 9228 case BIT_FIELD_REF: 9229 case ARRAY_REF: 9230 case ARRAY_RANGE_REF: 9231 { 9232 tree obj, offset; 9233 HOST_WIDE_INT bitsize, bitpos, bytepos; 9234 enum machine_mode mode; 9235 int volatilep; 9236 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc)); 9237 9238 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode, 9239 &unsignedp, &volatilep, false); 9240 9241 if (obj == loc) 9242 return 0; 9243 9244 ret = loc_descriptor_from_tree_1 (obj, 1); 9245 if (ret == 0 9246 || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0) 9247 return 0; 9248 9249 if (offset != NULL_TREE) 9250 { 9251 /* Variable offset. */ 9252 add_loc_descr (&ret, loc_descriptor_from_tree_1 (offset, 0)); 9253 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0)); 9254 } 9255 9256 bytepos = bitpos / BITS_PER_UNIT; 9257 if (bytepos > 0) 9258 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0)); 9259 else if (bytepos < 0) 9260 { 9261 add_loc_descr (&ret, int_loc_descriptor (bytepos)); 9262 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0)); 9263 } 9264 9265 have_address = 1; 9266 break; 9267 } 9268 9269 case INTEGER_CST: 9270 if (host_integerp (loc, 0)) 9271 ret = int_loc_descriptor (tree_low_cst (loc, 0)); 9272 else 9273 return 0; 9274 break; 9275 9276 case CONSTRUCTOR: 9277 { 9278 /* Get an RTL for this, if something has been emitted. */ 9279 rtx rtl = lookup_constant_def (loc); 9280 enum machine_mode mode; 9281 9282 if (!rtl || !MEM_P (rtl)) 9283 return 0; 9284 mode = GET_MODE (rtl); 9285 rtl = XEXP (rtl, 0); 9286 ret = mem_loc_descriptor (rtl, mode); 9287 have_address = 1; 9288 break; 9289 } 9290 9291 case TRUTH_AND_EXPR: 9292 case TRUTH_ANDIF_EXPR: 9293 case BIT_AND_EXPR: 9294 op = DW_OP_and; 9295 goto do_binop; 9296 9297 case TRUTH_XOR_EXPR: 9298 case BIT_XOR_EXPR: 9299 op = DW_OP_xor; 9300 goto do_binop; 9301 9302 case TRUTH_OR_EXPR: 9303 case TRUTH_ORIF_EXPR: 9304 case BIT_IOR_EXPR: 9305 op = DW_OP_or; 9306 goto do_binop; 9307 9308 case FLOOR_DIV_EXPR: 9309 case CEIL_DIV_EXPR: 9310 case ROUND_DIV_EXPR: 9311 case TRUNC_DIV_EXPR: 9312 op = DW_OP_div; 9313 goto do_binop; 9314 9315 case MINUS_EXPR: 9316 op = DW_OP_minus; 9317 goto do_binop; 9318 9319 case FLOOR_MOD_EXPR: 9320 case CEIL_MOD_EXPR: 9321 case ROUND_MOD_EXPR: 9322 case TRUNC_MOD_EXPR: 9323 op = DW_OP_mod; 9324 goto do_binop; 9325 9326 case MULT_EXPR: 9327 op = DW_OP_mul; 9328 goto do_binop; 9329 9330 case LSHIFT_EXPR: 9331 op = DW_OP_shl; 9332 goto do_binop; 9333 9334 case RSHIFT_EXPR: 9335 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra); 9336 goto do_binop; 9337 9338 case PLUS_EXPR: 9339 if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST 9340 && host_integerp (TREE_OPERAND (loc, 1), 0)) 9341 { 9342 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0); 9343 if (ret == 0) 9344 return 0; 9345 9346 add_loc_descr (&ret, 9347 new_loc_descr (DW_OP_plus_uconst, 9348 tree_low_cst (TREE_OPERAND (loc, 1), 9349 0), 9350 0)); 9351 break; 9352 } 9353 9354 op = DW_OP_plus; 9355 goto do_binop; 9356 9357 case LE_EXPR: 9358 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 9359 return 0; 9360 9361 op = DW_OP_le; 9362 goto do_binop; 9363 9364 case GE_EXPR: 9365 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 9366 return 0; 9367 9368 op = DW_OP_ge; 9369 goto do_binop; 9370 9371 case LT_EXPR: 9372 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 9373 return 0; 9374 9375 op = DW_OP_lt; 9376 goto do_binop; 9377 9378 case GT_EXPR: 9379 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 9380 return 0; 9381 9382 op = DW_OP_gt; 9383 goto do_binop; 9384 9385 case EQ_EXPR: 9386 op = DW_OP_eq; 9387 goto do_binop; 9388 9389 case NE_EXPR: 9390 op = DW_OP_ne; 9391 goto do_binop; 9392 9393 do_binop: 9394 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0); 9395 ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0); 9396 if (ret == 0 || ret1 == 0) 9397 return 0; 9398 9399 add_loc_descr (&ret, ret1); 9400 add_loc_descr (&ret, new_loc_descr (op, 0, 0)); 9401 break; 9402 9403 case TRUTH_NOT_EXPR: 9404 case BIT_NOT_EXPR: 9405 op = DW_OP_not; 9406 goto do_unop; 9407 9408 case ABS_EXPR: 9409 op = DW_OP_abs; 9410 goto do_unop; 9411 9412 case NEGATE_EXPR: 9413 op = DW_OP_neg; 9414 goto do_unop; 9415 9416 do_unop: 9417 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0); 9418 if (ret == 0) 9419 return 0; 9420 9421 add_loc_descr (&ret, new_loc_descr (op, 0, 0)); 9422 break; 9423 9424 case MIN_EXPR: 9425 case MAX_EXPR: 9426 { 9427 const enum tree_code code = 9428 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR; 9429 9430 loc = build3 (COND_EXPR, TREE_TYPE (loc), 9431 build2 (code, integer_type_node, 9432 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)), 9433 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0)); 9434 } 9435 9436 /* ... fall through ... */ 9437 9438 case COND_EXPR: 9439 { 9440 dw_loc_descr_ref lhs 9441 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0); 9442 dw_loc_descr_ref rhs 9443 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0); 9444 dw_loc_descr_ref bra_node, jump_node, tmp; 9445 9446 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0); 9447 if (ret == 0 || lhs == 0 || rhs == 0) 9448 return 0; 9449 9450 bra_node = new_loc_descr (DW_OP_bra, 0, 0); 9451 add_loc_descr (&ret, bra_node); 9452 9453 add_loc_descr (&ret, rhs); 9454 jump_node = new_loc_descr (DW_OP_skip, 0, 0); 9455 add_loc_descr (&ret, jump_node); 9456 9457 add_loc_descr (&ret, lhs); 9458 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc; 9459 bra_node->dw_loc_oprnd1.v.val_loc = lhs; 9460 9461 /* ??? Need a node to point the skip at. Use a nop. */ 9462 tmp = new_loc_descr (DW_OP_nop, 0, 0); 9463 add_loc_descr (&ret, tmp); 9464 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc; 9465 jump_node->dw_loc_oprnd1.v.val_loc = tmp; 9466 } 9467 break; 9468 9469 case FIX_TRUNC_EXPR: 9470 case FIX_CEIL_EXPR: 9471 case FIX_FLOOR_EXPR: 9472 case FIX_ROUND_EXPR: 9473 return 0; 9474 9475 default: 9476 /* Leave front-end specific codes as simply unknown. This comes 9477 up, for instance, with the C STMT_EXPR. */ 9478 if ((unsigned int) TREE_CODE (loc) 9479 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE) 9480 return 0; 9481 9482#ifdef ENABLE_CHECKING 9483 /* Otherwise this is a generic code; we should just lists all of 9484 these explicitly. We forgot one. */ 9485 gcc_unreachable (); 9486#else 9487 /* In a release build, we want to degrade gracefully: better to 9488 generate incomplete debugging information than to crash. */ 9489 return NULL; 9490#endif 9491 } 9492 9493 /* Show if we can't fill the request for an address. */ 9494 if (want_address && !have_address) 9495 return 0; 9496 9497 /* If we've got an address and don't want one, dereference. */ 9498 if (!want_address && have_address && ret) 9499 { 9500 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc)); 9501 9502 if (size > DWARF2_ADDR_SIZE || size == -1) 9503 return 0; 9504 else if (size == DWARF2_ADDR_SIZE) 9505 op = DW_OP_deref; 9506 else 9507 op = DW_OP_deref_size; 9508 9509 add_loc_descr (&ret, new_loc_descr (op, size, 0)); 9510 } 9511 9512 return ret; 9513} 9514 9515static inline dw_loc_descr_ref 9516loc_descriptor_from_tree (tree loc) 9517{ 9518 return loc_descriptor_from_tree_1 (loc, 2); 9519} 9520 9521/* Given a value, round it up to the lowest multiple of `boundary' 9522 which is not less than the value itself. */ 9523 9524static inline HOST_WIDE_INT 9525ceiling (HOST_WIDE_INT value, unsigned int boundary) 9526{ 9527 return (((value + boundary - 1) / boundary) * boundary); 9528} 9529 9530/* Given a pointer to what is assumed to be a FIELD_DECL node, return a 9531 pointer to the declared type for the relevant field variable, or return 9532 `integer_type_node' if the given node turns out to be an 9533 ERROR_MARK node. */ 9534 9535static inline tree 9536field_type (tree decl) 9537{ 9538 tree type; 9539 9540 if (TREE_CODE (decl) == ERROR_MARK) 9541 return integer_type_node; 9542 9543 type = DECL_BIT_FIELD_TYPE (decl); 9544 if (type == NULL_TREE) 9545 type = TREE_TYPE (decl); 9546 9547 return type; 9548} 9549 9550/* Given a pointer to a tree node, return the alignment in bits for 9551 it, or else return BITS_PER_WORD if the node actually turns out to 9552 be an ERROR_MARK node. */ 9553 9554static inline unsigned 9555simple_type_align_in_bits (tree type) 9556{ 9557 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD; 9558} 9559 9560static inline unsigned 9561simple_decl_align_in_bits (tree decl) 9562{ 9563 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD; 9564} 9565 9566/* Given a pointer to a FIELD_DECL, compute and return the byte offset of the 9567 lowest addressed byte of the "containing object" for the given FIELD_DECL, 9568 or return 0 if we are unable to determine what that offset is, either 9569 because the argument turns out to be a pointer to an ERROR_MARK node, or 9570 because the offset is actually variable. (We can't handle the latter case 9571 just yet). */ 9572 9573static HOST_WIDE_INT 9574field_byte_offset (tree decl) 9575{ 9576 unsigned int type_align_in_bits; 9577 unsigned int decl_align_in_bits; 9578 unsigned HOST_WIDE_INT type_size_in_bits; 9579 HOST_WIDE_INT object_offset_in_bits; 9580 tree type; 9581 tree field_size_tree; 9582 HOST_WIDE_INT bitpos_int; 9583 HOST_WIDE_INT deepest_bitpos; 9584 unsigned HOST_WIDE_INT field_size_in_bits; 9585 9586 if (TREE_CODE (decl) == ERROR_MARK) 9587 return 0; 9588 9589 gcc_assert (TREE_CODE (decl) == FIELD_DECL); 9590 9591 type = field_type (decl); 9592 field_size_tree = DECL_SIZE (decl); 9593 9594 /* The size could be unspecified if there was an error, or for 9595 a flexible array member. */ 9596 if (! field_size_tree) 9597 field_size_tree = bitsize_zero_node; 9598 9599 /* We cannot yet cope with fields whose positions are variable, so 9600 for now, when we see such things, we simply return 0. Someday, we may 9601 be able to handle such cases, but it will be damn difficult. */ 9602 if (! host_integerp (bit_position (decl), 0)) 9603 return 0; 9604 9605 bitpos_int = int_bit_position (decl); 9606 9607 /* If we don't know the size of the field, pretend it's a full word. */ 9608 if (host_integerp (field_size_tree, 1)) 9609 field_size_in_bits = tree_low_cst (field_size_tree, 1); 9610 else 9611 field_size_in_bits = BITS_PER_WORD; 9612 9613 type_size_in_bits = simple_type_size_in_bits (type); 9614 type_align_in_bits = simple_type_align_in_bits (type); 9615 decl_align_in_bits = simple_decl_align_in_bits (decl); 9616 9617 /* The GCC front-end doesn't make any attempt to keep track of the starting 9618 bit offset (relative to the start of the containing structure type) of the 9619 hypothetical "containing object" for a bit-field. Thus, when computing 9620 the byte offset value for the start of the "containing object" of a 9621 bit-field, we must deduce this information on our own. This can be rather 9622 tricky to do in some cases. For example, handling the following structure 9623 type definition when compiling for an i386/i486 target (which only aligns 9624 long long's to 32-bit boundaries) can be very tricky: 9625 9626 struct S { int field1; long long field2:31; }; 9627 9628 Fortunately, there is a simple rule-of-thumb which can be used in such 9629 cases. When compiling for an i386/i486, GCC will allocate 8 bytes for the 9630 structure shown above. It decides to do this based upon one simple rule 9631 for bit-field allocation. GCC allocates each "containing object" for each 9632 bit-field at the first (i.e. lowest addressed) legitimate alignment 9633 boundary (based upon the required minimum alignment for the declared type 9634 of the field) which it can possibly use, subject to the condition that 9635 there is still enough available space remaining in the containing object 9636 (when allocated at the selected point) to fully accommodate all of the 9637 bits of the bit-field itself. 9638 9639 This simple rule makes it obvious why GCC allocates 8 bytes for each 9640 object of the structure type shown above. When looking for a place to 9641 allocate the "containing object" for `field2', the compiler simply tries 9642 to allocate a 64-bit "containing object" at each successive 32-bit 9643 boundary (starting at zero) until it finds a place to allocate that 64- 9644 bit field such that at least 31 contiguous (and previously unallocated) 9645 bits remain within that selected 64 bit field. (As it turns out, for the 9646 example above, the compiler finds it is OK to allocate the "containing 9647 object" 64-bit field at bit-offset zero within the structure type.) 9648 9649 Here we attempt to work backwards from the limited set of facts we're 9650 given, and we try to deduce from those facts, where GCC must have believed 9651 that the containing object started (within the structure type). The value 9652 we deduce is then used (by the callers of this routine) to generate 9653 DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields 9654 and, in the case of DW_AT_location, regular fields as well). */ 9655 9656 /* Figure out the bit-distance from the start of the structure to the 9657 "deepest" bit of the bit-field. */ 9658 deepest_bitpos = bitpos_int + field_size_in_bits; 9659 9660 /* This is the tricky part. Use some fancy footwork to deduce where the 9661 lowest addressed bit of the containing object must be. */ 9662 object_offset_in_bits = deepest_bitpos - type_size_in_bits; 9663 9664 /* Round up to type_align by default. This works best for bitfields. */ 9665 object_offset_in_bits += type_align_in_bits - 1; 9666 object_offset_in_bits /= type_align_in_bits; 9667 object_offset_in_bits *= type_align_in_bits; 9668 9669 if (object_offset_in_bits > bitpos_int) 9670 { 9671 /* Sigh, the decl must be packed. */ 9672 object_offset_in_bits = deepest_bitpos - type_size_in_bits; 9673 9674 /* Round up to decl_align instead. */ 9675 object_offset_in_bits += decl_align_in_bits - 1; 9676 object_offset_in_bits /= decl_align_in_bits; 9677 object_offset_in_bits *= decl_align_in_bits; 9678 } 9679 9680 return object_offset_in_bits / BITS_PER_UNIT; 9681} 9682 9683/* The following routines define various Dwarf attributes and any data 9684 associated with them. */ 9685 9686/* Add a location description attribute value to a DIE. 9687 9688 This emits location attributes suitable for whole variables and 9689 whole parameters. Note that the location attributes for struct fields are 9690 generated by the routine `data_member_location_attribute' below. */ 9691 9692static inline void 9693add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind, 9694 dw_loc_descr_ref descr) 9695{ 9696 if (descr != 0) 9697 add_AT_loc (die, attr_kind, descr); 9698} 9699 9700/* Attach the specialized form of location attribute used for data members of 9701 struct and union types. In the special case of a FIELD_DECL node which 9702 represents a bit-field, the "offset" part of this special location 9703 descriptor must indicate the distance in bytes from the lowest-addressed 9704 byte of the containing struct or union type to the lowest-addressed byte of 9705 the "containing object" for the bit-field. (See the `field_byte_offset' 9706 function above). 9707 9708 For any given bit-field, the "containing object" is a hypothetical object 9709 (of some integral or enum type) within which the given bit-field lives. The 9710 type of this hypothetical "containing object" is always the same as the 9711 declared type of the individual bit-field itself (for GCC anyway... the 9712 DWARF spec doesn't actually mandate this). Note that it is the size (in 9713 bytes) of the hypothetical "containing object" which will be given in the 9714 DW_AT_byte_size attribute for this bit-field. (See the 9715 `byte_size_attribute' function below.) It is also used when calculating the 9716 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute' 9717 function below.) */ 9718 9719static void 9720add_data_member_location_attribute (dw_die_ref die, tree decl) 9721{ 9722 HOST_WIDE_INT offset; 9723 dw_loc_descr_ref loc_descr = 0; 9724 9725 if (TREE_CODE (decl) == TREE_BINFO) 9726 { 9727 /* We're working on the TAG_inheritance for a base class. */ 9728 if (BINFO_VIRTUAL_P (decl) && is_cxx ()) 9729 { 9730 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they 9731 aren't at a fixed offset from all (sub)objects of the same 9732 type. We need to extract the appropriate offset from our 9733 vtable. The following dwarf expression means 9734 9735 BaseAddr = ObAddr + *((*ObAddr) - Offset) 9736 9737 This is specific to the V3 ABI, of course. */ 9738 9739 dw_loc_descr_ref tmp; 9740 9741 /* Make a copy of the object address. */ 9742 tmp = new_loc_descr (DW_OP_dup, 0, 0); 9743 add_loc_descr (&loc_descr, tmp); 9744 9745 /* Extract the vtable address. */ 9746 tmp = new_loc_descr (DW_OP_deref, 0, 0); 9747 add_loc_descr (&loc_descr, tmp); 9748 9749 /* Calculate the address of the offset. */ 9750 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0); 9751 gcc_assert (offset < 0); 9752 9753 tmp = int_loc_descriptor (-offset); 9754 add_loc_descr (&loc_descr, tmp); 9755 tmp = new_loc_descr (DW_OP_minus, 0, 0); 9756 add_loc_descr (&loc_descr, tmp); 9757 9758 /* Extract the offset. */ 9759 tmp = new_loc_descr (DW_OP_deref, 0, 0); 9760 add_loc_descr (&loc_descr, tmp); 9761 9762 /* Add it to the object address. */ 9763 tmp = new_loc_descr (DW_OP_plus, 0, 0); 9764 add_loc_descr (&loc_descr, tmp); 9765 } 9766 else 9767 offset = tree_low_cst (BINFO_OFFSET (decl), 0); 9768 } 9769 else 9770 offset = field_byte_offset (decl); 9771 9772 if (! loc_descr) 9773 { 9774 enum dwarf_location_atom op; 9775 9776 /* The DWARF2 standard says that we should assume that the structure 9777 address is already on the stack, so we can specify a structure field 9778 address by using DW_OP_plus_uconst. */ 9779 9780#ifdef MIPS_DEBUGGING_INFO 9781 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst 9782 operator correctly. It works only if we leave the offset on the 9783 stack. */ 9784 op = DW_OP_constu; 9785#else 9786 op = DW_OP_plus_uconst; 9787#endif 9788 9789 loc_descr = new_loc_descr (op, offset, 0); 9790 } 9791 9792 add_AT_loc (die, DW_AT_data_member_location, loc_descr); 9793} 9794 9795/* Writes integer values to dw_vec_const array. */ 9796 9797static void 9798insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest) 9799{ 9800 while (size != 0) 9801 { 9802 *dest++ = val & 0xff; 9803 val >>= 8; 9804 --size; 9805 } 9806} 9807 9808/* Reads integers from dw_vec_const array. Inverse of insert_int. */ 9809 9810static HOST_WIDE_INT 9811extract_int (const unsigned char *src, unsigned int size) 9812{ 9813 HOST_WIDE_INT val = 0; 9814 9815 src += size; 9816 while (size != 0) 9817 { 9818 val <<= 8; 9819 val |= *--src & 0xff; 9820 --size; 9821 } 9822 return val; 9823} 9824 9825/* Writes floating point values to dw_vec_const array. */ 9826 9827static void 9828insert_float (rtx rtl, unsigned char *array) 9829{ 9830 REAL_VALUE_TYPE rv; 9831 long val[4]; 9832 int i; 9833 9834 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl); 9835 real_to_target (val, &rv, GET_MODE (rtl)); 9836 9837 /* real_to_target puts 32-bit pieces in each long. Pack them. */ 9838 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++) 9839 { 9840 insert_int (val[i], 4, array); 9841 array += 4; 9842 } 9843} 9844 9845/* Attach a DW_AT_const_value attribute for a variable or a parameter which 9846 does not have a "location" either in memory or in a register. These 9847 things can arise in GNU C when a constant is passed as an actual parameter 9848 to an inlined function. They can also arise in C++ where declared 9849 constants do not necessarily get memory "homes". */ 9850 9851static void 9852add_const_value_attribute (dw_die_ref die, rtx rtl) 9853{ 9854 switch (GET_CODE (rtl)) 9855 { 9856 case CONST_INT: 9857 { 9858 HOST_WIDE_INT val = INTVAL (rtl); 9859 9860 if (val < 0) 9861 add_AT_int (die, DW_AT_const_value, val); 9862 else 9863 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val); 9864 } 9865 break; 9866 9867 case CONST_DOUBLE: 9868 /* Note that a CONST_DOUBLE rtx could represent either an integer or a 9869 floating-point constant. A CONST_DOUBLE is used whenever the 9870 constant requires more than one word in order to be adequately 9871 represented. We output CONST_DOUBLEs as blocks. */ 9872 { 9873 enum machine_mode mode = GET_MODE (rtl); 9874 9875 if (SCALAR_FLOAT_MODE_P (mode)) 9876 { 9877 unsigned int length = GET_MODE_SIZE (mode); 9878 unsigned char *array = ggc_alloc (length); 9879 9880 insert_float (rtl, array); 9881 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array); 9882 } 9883 else 9884 { 9885 /* ??? We really should be using HOST_WIDE_INT throughout. */ 9886 gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT); 9887 9888 add_AT_long_long (die, DW_AT_const_value, 9889 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl)); 9890 } 9891 } 9892 break; 9893 9894 case CONST_VECTOR: 9895 { 9896 enum machine_mode mode = GET_MODE (rtl); 9897 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode); 9898 unsigned int length = CONST_VECTOR_NUNITS (rtl); 9899 unsigned char *array = ggc_alloc (length * elt_size); 9900 unsigned int i; 9901 unsigned char *p; 9902 9903 switch (GET_MODE_CLASS (mode)) 9904 { 9905 case MODE_VECTOR_INT: 9906 for (i = 0, p = array; i < length; i++, p += elt_size) 9907 { 9908 rtx elt = CONST_VECTOR_ELT (rtl, i); 9909 HOST_WIDE_INT lo, hi; 9910 9911 switch (GET_CODE (elt)) 9912 { 9913 case CONST_INT: 9914 lo = INTVAL (elt); 9915 hi = -(lo < 0); 9916 break; 9917 9918 case CONST_DOUBLE: 9919 lo = CONST_DOUBLE_LOW (elt); 9920 hi = CONST_DOUBLE_HIGH (elt); 9921 break; 9922 9923 default: 9924 gcc_unreachable (); 9925 } 9926 9927 if (elt_size <= sizeof (HOST_WIDE_INT)) 9928 insert_int (lo, elt_size, p); 9929 else 9930 { 9931 unsigned char *p0 = p; 9932 unsigned char *p1 = p + sizeof (HOST_WIDE_INT); 9933 9934 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT)); 9935 if (WORDS_BIG_ENDIAN) 9936 { 9937 p0 = p1; 9938 p1 = p; 9939 } 9940 insert_int (lo, sizeof (HOST_WIDE_INT), p0); 9941 insert_int (hi, sizeof (HOST_WIDE_INT), p1); 9942 } 9943 } 9944 break; 9945 9946 case MODE_VECTOR_FLOAT: 9947 for (i = 0, p = array; i < length; i++, p += elt_size) 9948 { 9949 rtx elt = CONST_VECTOR_ELT (rtl, i); 9950 insert_float (elt, p); 9951 } 9952 break; 9953 9954 default: 9955 gcc_unreachable (); 9956 } 9957 9958 add_AT_vec (die, DW_AT_const_value, length, elt_size, array); 9959 } 9960 break; 9961 9962 case CONST_STRING: 9963 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0)); 9964 break; 9965 9966 case SYMBOL_REF: 9967 case LABEL_REF: 9968 case CONST: 9969 add_AT_addr (die, DW_AT_const_value, rtl); 9970 VEC_safe_push (rtx, gc, used_rtx_array, rtl); 9971 break; 9972 9973 case PLUS: 9974 /* In cases where an inlined instance of an inline function is passed 9975 the address of an `auto' variable (which is local to the caller) we 9976 can get a situation where the DECL_RTL of the artificial local 9977 variable (for the inlining) which acts as a stand-in for the 9978 corresponding formal parameter (of the inline function) will look 9979 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not 9980 exactly a compile-time constant expression, but it isn't the address 9981 of the (artificial) local variable either. Rather, it represents the 9982 *value* which the artificial local variable always has during its 9983 lifetime. We currently have no way to represent such quasi-constant 9984 values in Dwarf, so for now we just punt and generate nothing. */ 9985 break; 9986 9987 default: 9988 /* No other kinds of rtx should be possible here. */ 9989 gcc_unreachable (); 9990 } 9991 9992} 9993 9994/* Determine whether the evaluation of EXPR references any variables 9995 or functions which aren't otherwise used (and therefore may not be 9996 output). */ 9997static tree 9998reference_to_unused (tree * tp, int * walk_subtrees, 9999 void * data ATTRIBUTE_UNUSED) 10000{ 10001 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp)) 10002 *walk_subtrees = 0; 10003 10004 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp) 10005 && ! TREE_ASM_WRITTEN (*tp)) 10006 return *tp; 10007 else if (!flag_unit_at_a_time) 10008 return NULL_TREE; 10009 else if (!cgraph_global_info_ready 10010 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL)) 10011 return *tp; 10012 else if (DECL_P (*tp) && TREE_CODE (*tp) == VAR_DECL) 10013 { 10014 struct cgraph_varpool_node *node = cgraph_varpool_node (*tp); 10015 if (!node->needed) 10016 return *tp; 10017 } 10018 else if (DECL_P (*tp) && TREE_CODE (*tp) == FUNCTION_DECL 10019 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp))) 10020 { 10021 struct cgraph_node *node = cgraph_node (*tp); 10022 if (!node->output) 10023 return *tp; 10024 } 10025 10026 return NULL_TREE; 10027} 10028 10029/* Generate an RTL constant from a decl initializer INIT with decl type TYPE, 10030 for use in a later add_const_value_attribute call. */ 10031 10032static rtx 10033rtl_for_decl_init (tree init, tree type) 10034{ 10035 rtx rtl = NULL_RTX; 10036 10037 /* If a variable is initialized with a string constant without embedded 10038 zeros, build CONST_STRING. */ 10039 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE) 10040 { 10041 tree enttype = TREE_TYPE (type); 10042 tree domain = TYPE_DOMAIN (type); 10043 enum machine_mode mode = TYPE_MODE (enttype); 10044 10045 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1 10046 && domain 10047 && integer_zerop (TYPE_MIN_VALUE (domain)) 10048 && compare_tree_int (TYPE_MAX_VALUE (domain), 10049 TREE_STRING_LENGTH (init) - 1) == 0 10050 && ((size_t) TREE_STRING_LENGTH (init) 10051 == strlen (TREE_STRING_POINTER (init)) + 1)) 10052 rtl = gen_rtx_CONST_STRING (VOIDmode, 10053 ggc_strdup (TREE_STRING_POINTER (init))); 10054 } 10055 /* Other aggregates, and complex values, could be represented using 10056 CONCAT: FIXME! */ 10057 else if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE) 10058 ; 10059 /* Vectors only work if their mode is supported by the target. 10060 FIXME: generic vectors ought to work too. */ 10061 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_MODE (type) == BLKmode) 10062 ; 10063 /* If the initializer is something that we know will expand into an 10064 immediate RTL constant, expand it now. We must be careful not to 10065 reference variables which won't be output. */ 10066 else if (initializer_constant_valid_p (init, type) 10067 && ! walk_tree (&init, reference_to_unused, NULL, NULL)) 10068 { 10069 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if 10070 possible. */ 10071 if (TREE_CODE (type) == VECTOR_TYPE) 10072 switch (TREE_CODE (init)) 10073 { 10074 case VECTOR_CST: 10075 break; 10076 case CONSTRUCTOR: 10077 if (TREE_CONSTANT (init)) 10078 { 10079 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (init); 10080 bool constant_p = true; 10081 tree value; 10082 unsigned HOST_WIDE_INT ix; 10083 10084 /* Even when ctor is constant, it might contain non-*_CST 10085 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't 10086 belong into VECTOR_CST nodes. */ 10087 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value) 10088 if (!CONSTANT_CLASS_P (value)) 10089 { 10090 constant_p = false; 10091 break; 10092 } 10093 10094 if (constant_p) 10095 { 10096 init = build_vector_from_ctor (type, elts); 10097 break; 10098 } 10099 } 10100 /* FALLTHRU */ 10101 10102 default: 10103 return NULL; 10104 } 10105 10106 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER); 10107 10108 /* If expand_expr returns a MEM, it wasn't immediate. */ 10109 gcc_assert (!rtl || !MEM_P (rtl)); 10110 } 10111 10112 return rtl; 10113} 10114 10115/* Generate RTL for the variable DECL to represent its location. */ 10116 10117static rtx 10118rtl_for_decl_location (tree decl) 10119{ 10120 rtx rtl; 10121 10122 /* Here we have to decide where we are going to say the parameter "lives" 10123 (as far as the debugger is concerned). We only have a couple of 10124 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL. 10125 10126 DECL_RTL normally indicates where the parameter lives during most of the 10127 activation of the function. If optimization is enabled however, this 10128 could be either NULL or else a pseudo-reg. Both of those cases indicate 10129 that the parameter doesn't really live anywhere (as far as the code 10130 generation parts of GCC are concerned) during most of the function's 10131 activation. That will happen (for example) if the parameter is never 10132 referenced within the function. 10133 10134 We could just generate a location descriptor here for all non-NULL 10135 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be 10136 a little nicer than that if we also consider DECL_INCOMING_RTL in cases 10137 where DECL_RTL is NULL or is a pseudo-reg. 10138 10139 Note however that we can only get away with using DECL_INCOMING_RTL as 10140 a backup substitute for DECL_RTL in certain limited cases. In cases 10141 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl), 10142 we can be sure that the parameter was passed using the same type as it is 10143 declared to have within the function, and that its DECL_INCOMING_RTL 10144 points us to a place where a value of that type is passed. 10145 10146 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different, 10147 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL 10148 because in these cases DECL_INCOMING_RTL points us to a value of some 10149 type which is *different* from the type of the parameter itself. Thus, 10150 if we tried to use DECL_INCOMING_RTL to generate a location attribute in 10151 such cases, the debugger would end up (for example) trying to fetch a 10152 `float' from a place which actually contains the first part of a 10153 `double'. That would lead to really incorrect and confusing 10154 output at debug-time. 10155 10156 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL 10157 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There 10158 are a couple of exceptions however. On little-endian machines we can 10159 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is 10160 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is 10161 an integral type that is smaller than TREE_TYPE (decl). These cases arise 10162 when (on a little-endian machine) a non-prototyped function has a 10163 parameter declared to be of type `short' or `char'. In such cases, 10164 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will 10165 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the 10166 passed `int' value. If the debugger then uses that address to fetch 10167 a `short' or a `char' (on a little-endian machine) the result will be 10168 the correct data, so we allow for such exceptional cases below. 10169 10170 Note that our goal here is to describe the place where the given formal 10171 parameter lives during most of the function's activation (i.e. between the 10172 end of the prologue and the start of the epilogue). We'll do that as best 10173 as we can. Note however that if the given formal parameter is modified 10174 sometime during the execution of the function, then a stack backtrace (at 10175 debug-time) will show the function as having been called with the *new* 10176 value rather than the value which was originally passed in. This happens 10177 rarely enough that it is not a major problem, but it *is* a problem, and 10178 I'd like to fix it. 10179 10180 A future version of dwarf2out.c may generate two additional attributes for 10181 any given DW_TAG_formal_parameter DIE which will describe the "passed 10182 type" and the "passed location" for the given formal parameter in addition 10183 to the attributes we now generate to indicate the "declared type" and the 10184 "active location" for each parameter. This additional set of attributes 10185 could be used by debuggers for stack backtraces. Separately, note that 10186 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also. 10187 This happens (for example) for inlined-instances of inline function formal 10188 parameters which are never referenced. This really shouldn't be 10189 happening. All PARM_DECL nodes should get valid non-NULL 10190 DECL_INCOMING_RTL values. FIXME. */ 10191 10192 /* Use DECL_RTL as the "location" unless we find something better. */ 10193 rtl = DECL_RTL_IF_SET (decl); 10194 10195 /* When generating abstract instances, ignore everything except 10196 constants, symbols living in memory, and symbols living in 10197 fixed registers. */ 10198 if (! reload_completed) 10199 { 10200 if (rtl 10201 && (CONSTANT_P (rtl) 10202 || (MEM_P (rtl) 10203 && CONSTANT_P (XEXP (rtl, 0))) 10204 || (REG_P (rtl) 10205 && TREE_CODE (decl) == VAR_DECL 10206 && TREE_STATIC (decl)))) 10207 { 10208 rtl = targetm.delegitimize_address (rtl); 10209 return rtl; 10210 } 10211 rtl = NULL_RTX; 10212 } 10213 else if (TREE_CODE (decl) == PARM_DECL) 10214 { 10215 if (rtl == NULL_RTX || is_pseudo_reg (rtl)) 10216 { 10217 tree declared_type = TREE_TYPE (decl); 10218 tree passed_type = DECL_ARG_TYPE (decl); 10219 enum machine_mode dmode = TYPE_MODE (declared_type); 10220 enum machine_mode pmode = TYPE_MODE (passed_type); 10221 10222 /* This decl represents a formal parameter which was optimized out. 10223 Note that DECL_INCOMING_RTL may be NULL in here, but we handle 10224 all cases where (rtl == NULL_RTX) just below. */ 10225 if (dmode == pmode) 10226 rtl = DECL_INCOMING_RTL (decl); 10227 else if (SCALAR_INT_MODE_P (dmode) 10228 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode) 10229 && DECL_INCOMING_RTL (decl)) 10230 { 10231 rtx inc = DECL_INCOMING_RTL (decl); 10232 if (REG_P (inc)) 10233 rtl = inc; 10234 else if (MEM_P (inc)) 10235 { 10236 if (BYTES_BIG_ENDIAN) 10237 rtl = adjust_address_nv (inc, dmode, 10238 GET_MODE_SIZE (pmode) 10239 - GET_MODE_SIZE (dmode)); 10240 else 10241 rtl = inc; 10242 } 10243 } 10244 } 10245 10246 /* If the parm was passed in registers, but lives on the stack, then 10247 make a big endian correction if the mode of the type of the 10248 parameter is not the same as the mode of the rtl. */ 10249 /* ??? This is the same series of checks that are made in dbxout.c before 10250 we reach the big endian correction code there. It isn't clear if all 10251 of these checks are necessary here, but keeping them all is the safe 10252 thing to do. */ 10253 else if (MEM_P (rtl) 10254 && XEXP (rtl, 0) != const0_rtx 10255 && ! CONSTANT_P (XEXP (rtl, 0)) 10256 /* Not passed in memory. */ 10257 && !MEM_P (DECL_INCOMING_RTL (decl)) 10258 /* Not passed by invisible reference. */ 10259 && (!REG_P (XEXP (rtl, 0)) 10260 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM 10261 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM 10262#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM 10263 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM 10264#endif 10265 ) 10266 /* Big endian correction check. */ 10267 && BYTES_BIG_ENDIAN 10268 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl) 10269 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))) 10270 < UNITS_PER_WORD)) 10271 { 10272 int offset = (UNITS_PER_WORD 10273 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))); 10274 10275 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)), 10276 plus_constant (XEXP (rtl, 0), offset)); 10277 } 10278 } 10279 else if (TREE_CODE (decl) == VAR_DECL 10280 && rtl 10281 && MEM_P (rtl) 10282 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl)) 10283 && BYTES_BIG_ENDIAN) 10284 { 10285 int rsize = GET_MODE_SIZE (GET_MODE (rtl)); 10286 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))); 10287 10288 /* If a variable is declared "register" yet is smaller than 10289 a register, then if we store the variable to memory, it 10290 looks like we're storing a register-sized value, when in 10291 fact we are not. We need to adjust the offset of the 10292 storage location to reflect the actual value's bytes, 10293 else gdb will not be able to display it. */ 10294 if (rsize > dsize) 10295 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)), 10296 plus_constant (XEXP (rtl, 0), rsize-dsize)); 10297 } 10298 10299 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant, 10300 and will have been substituted directly into all expressions that use it. 10301 C does not have such a concept, but C++ and other languages do. */ 10302 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl)) 10303 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl)); 10304 10305 if (rtl) 10306 rtl = targetm.delegitimize_address (rtl); 10307 10308 /* If we don't look past the constant pool, we risk emitting a 10309 reference to a constant pool entry that isn't referenced from 10310 code, and thus is not emitted. */ 10311 if (rtl) 10312 rtl = avoid_constant_pool_reference (rtl); 10313 10314 return rtl; 10315} 10316 10317/* We need to figure out what section we should use as the base for the 10318 address ranges where a given location is valid. 10319 1. If this particular DECL has a section associated with it, use that. 10320 2. If this function has a section associated with it, use that. 10321 3. Otherwise, use the text section. 10322 XXX: If you split a variable across multiple sections, we won't notice. */ 10323 10324static const char * 10325secname_for_decl (tree decl) 10326{ 10327 const char *secname; 10328 10329 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl)) 10330 { 10331 tree sectree = DECL_SECTION_NAME (decl); 10332 secname = TREE_STRING_POINTER (sectree); 10333 } 10334 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl)) 10335 { 10336 tree sectree = DECL_SECTION_NAME (current_function_decl); 10337 secname = TREE_STRING_POINTER (sectree); 10338 } 10339 else if (cfun && in_cold_section_p) 10340 secname = cfun->cold_section_label; 10341 else 10342 secname = text_section_label; 10343 10344 return secname; 10345} 10346 10347/* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value 10348 data attribute for a variable or a parameter. We generate the 10349 DW_AT_const_value attribute only in those cases where the given variable 10350 or parameter does not have a true "location" either in memory or in a 10351 register. This can happen (for example) when a constant is passed as an 10352 actual argument in a call to an inline function. (It's possible that 10353 these things can crop up in other ways also.) Note that one type of 10354 constant value which can be passed into an inlined function is a constant 10355 pointer. This can happen for example if an actual argument in an inlined 10356 function call evaluates to a compile-time constant address. */ 10357 10358static void 10359add_location_or_const_value_attribute (dw_die_ref die, tree decl, 10360 enum dwarf_attribute attr) 10361{ 10362 rtx rtl; 10363 dw_loc_descr_ref descr; 10364 var_loc_list *loc_list; 10365 struct var_loc_node *node; 10366 if (TREE_CODE (decl) == ERROR_MARK) 10367 return; 10368 10369 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL 10370 || TREE_CODE (decl) == RESULT_DECL); 10371 10372 /* See if we possibly have multiple locations for this variable. */ 10373 loc_list = lookup_decl_loc (decl); 10374 10375 /* If it truly has multiple locations, the first and last node will 10376 differ. */ 10377 if (loc_list && loc_list->first != loc_list->last) 10378 { 10379 const char *endname, *secname; 10380 dw_loc_list_ref list; 10381 rtx varloc; 10382 10383 /* Now that we know what section we are using for a base, 10384 actually construct the list of locations. 10385 The first location information is what is passed to the 10386 function that creates the location list, and the remaining 10387 locations just get added on to that list. 10388 Note that we only know the start address for a location 10389 (IE location changes), so to build the range, we use 10390 the range [current location start, next location start]. 10391 This means we have to special case the last node, and generate 10392 a range of [last location start, end of function label]. */ 10393 10394 node = loc_list->first; 10395 varloc = NOTE_VAR_LOCATION (node->var_loc_note); 10396 secname = secname_for_decl (decl); 10397 10398 list = new_loc_list (loc_descriptor (varloc), 10399 node->label, node->next->label, secname, 1); 10400 node = node->next; 10401 10402 for (; node->next; node = node->next) 10403 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX) 10404 { 10405 /* The variable has a location between NODE->LABEL and 10406 NODE->NEXT->LABEL. */ 10407 varloc = NOTE_VAR_LOCATION (node->var_loc_note); 10408 add_loc_descr_to_loc_list (&list, loc_descriptor (varloc), 10409 node->label, node->next->label, secname); 10410 } 10411 10412 /* If the variable has a location at the last label 10413 it keeps its location until the end of function. */ 10414 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX) 10415 { 10416 char label_id[MAX_ARTIFICIAL_LABEL_BYTES]; 10417 10418 varloc = NOTE_VAR_LOCATION (node->var_loc_note); 10419 if (!current_function_decl) 10420 endname = text_end_label; 10421 else 10422 { 10423 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL, 10424 current_function_funcdef_no); 10425 endname = ggc_strdup (label_id); 10426 } 10427 add_loc_descr_to_loc_list (&list, loc_descriptor (varloc), 10428 node->label, endname, secname); 10429 } 10430 10431 /* Finally, add the location list to the DIE, and we are done. */ 10432 add_AT_loc_list (die, attr, list); 10433 return; 10434 } 10435 10436 /* Try to get some constant RTL for this decl, and use that as the value of 10437 the location. */ 10438 10439 rtl = rtl_for_decl_location (decl); 10440 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)) 10441 { 10442 add_const_value_attribute (die, rtl); 10443 return; 10444 } 10445 10446 /* If we have tried to generate the location otherwise, and it 10447 didn't work out (we wouldn't be here if we did), and we have a one entry 10448 location list, try generating a location from that. */ 10449 if (loc_list && loc_list->first) 10450 { 10451 node = loc_list->first; 10452 descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note)); 10453 if (descr) 10454 { 10455 add_AT_location_description (die, attr, descr); 10456 return; 10457 } 10458 } 10459 10460 /* We couldn't get any rtl, so try directly generating the location 10461 description from the tree. */ 10462 descr = loc_descriptor_from_tree (decl); 10463 if (descr) 10464 { 10465 add_AT_location_description (die, attr, descr); 10466 return; 10467 } 10468 /* None of that worked, so it must not really have a location; 10469 try adding a constant value attribute from the DECL_INITIAL. */ 10470 tree_add_const_value_attribute (die, decl); 10471} 10472 10473/* If we don't have a copy of this variable in memory for some reason (such 10474 as a C++ member constant that doesn't have an out-of-line definition), 10475 we should tell the debugger about the constant value. */ 10476 10477static void 10478tree_add_const_value_attribute (dw_die_ref var_die, tree decl) 10479{ 10480 tree init = DECL_INITIAL (decl); 10481 tree type = TREE_TYPE (decl); 10482 rtx rtl; 10483 10484 if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init) 10485 /* OK */; 10486 else 10487 return; 10488 10489 rtl = rtl_for_decl_init (init, type); 10490 if (rtl) 10491 add_const_value_attribute (var_die, rtl); 10492} 10493 10494/* Convert the CFI instructions for the current function into a 10495 location list. This is used for DW_AT_frame_base when we targeting 10496 a dwarf2 consumer that does not support the dwarf3 10497 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA 10498 expressions. */ 10499 10500static dw_loc_list_ref 10501convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset) 10502{ 10503 dw_fde_ref fde; 10504 dw_loc_list_ref list, *list_tail; 10505 dw_cfi_ref cfi; 10506 dw_cfa_location last_cfa, next_cfa; 10507 const char *start_label, *last_label, *section; 10508 10509 fde = &fde_table[fde_table_in_use - 1]; 10510 10511 section = secname_for_decl (current_function_decl); 10512 list_tail = &list; 10513 list = NULL; 10514 10515 next_cfa.reg = INVALID_REGNUM; 10516 next_cfa.offset = 0; 10517 next_cfa.indirect = 0; 10518 next_cfa.base_offset = 0; 10519 10520 start_label = fde->dw_fde_begin; 10521 10522 /* ??? Bald assumption that the CIE opcode list does not contain 10523 advance opcodes. */ 10524 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next) 10525 lookup_cfa_1 (cfi, &next_cfa); 10526 10527 last_cfa = next_cfa; 10528 last_label = start_label; 10529 10530 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next) 10531 switch (cfi->dw_cfi_opc) 10532 { 10533 case DW_CFA_set_loc: 10534 case DW_CFA_advance_loc1: 10535 case DW_CFA_advance_loc2: 10536 case DW_CFA_advance_loc4: 10537 if (!cfa_equal_p (&last_cfa, &next_cfa)) 10538 { 10539 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset), 10540 start_label, last_label, section, 10541 list == NULL); 10542 10543 list_tail = &(*list_tail)->dw_loc_next; 10544 last_cfa = next_cfa; 10545 start_label = last_label; 10546 } 10547 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 10548 break; 10549 10550 case DW_CFA_advance_loc: 10551 /* The encoding is complex enough that we should never emit this. */ 10552 case DW_CFA_remember_state: 10553 case DW_CFA_restore_state: 10554 /* We don't handle these two in this function. It would be possible 10555 if it were to be required. */ 10556 gcc_unreachable (); 10557 10558 default: 10559 lookup_cfa_1 (cfi, &next_cfa); 10560 break; 10561 } 10562 10563 if (!cfa_equal_p (&last_cfa, &next_cfa)) 10564 { 10565 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset), 10566 start_label, last_label, section, 10567 list == NULL); 10568 list_tail = &(*list_tail)->dw_loc_next; 10569 start_label = last_label; 10570 } 10571 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset), 10572 start_label, fde->dw_fde_end, section, 10573 list == NULL); 10574 10575 return list; 10576} 10577 10578/* Compute a displacement from the "steady-state frame pointer" to the 10579 frame base (often the same as the CFA), and store it in 10580 frame_pointer_fb_offset. OFFSET is added to the displacement 10581 before the latter is negated. */ 10582 10583static void 10584compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset) 10585{ 10586 rtx reg, elim; 10587 10588#ifdef FRAME_POINTER_CFA_OFFSET 10589 reg = frame_pointer_rtx; 10590 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl); 10591#else 10592 reg = arg_pointer_rtx; 10593 offset += ARG_POINTER_CFA_OFFSET (current_function_decl); 10594#endif 10595 10596 elim = eliminate_regs (reg, VOIDmode, NULL_RTX); 10597 if (GET_CODE (elim) == PLUS) 10598 { 10599 offset += INTVAL (XEXP (elim, 1)); 10600 elim = XEXP (elim, 0); 10601 } 10602 gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx 10603 : stack_pointer_rtx)); 10604 10605 frame_pointer_fb_offset = -offset; 10606} 10607 10608/* Generate a DW_AT_name attribute given some string value to be included as 10609 the value of the attribute. */ 10610 10611static void 10612add_name_attribute (dw_die_ref die, const char *name_string) 10613{ 10614 if (name_string != NULL && *name_string != 0) 10615 { 10616 if (demangle_name_func) 10617 name_string = (*demangle_name_func) (name_string); 10618 10619 add_AT_string (die, DW_AT_name, name_string); 10620 } 10621} 10622 10623/* Generate a DW_AT_comp_dir attribute for DIE. */ 10624 10625static void 10626add_comp_dir_attribute (dw_die_ref die) 10627{ 10628 const char *wd = get_src_pwd (); 10629 if (wd != NULL) 10630 add_AT_string (die, DW_AT_comp_dir, wd); 10631} 10632 10633/* Given a tree node describing an array bound (either lower or upper) output 10634 a representation for that bound. */ 10635 10636static void 10637add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound) 10638{ 10639 switch (TREE_CODE (bound)) 10640 { 10641 case ERROR_MARK: 10642 return; 10643 10644 /* All fixed-bounds are represented by INTEGER_CST nodes. */ 10645 case INTEGER_CST: 10646 if (! host_integerp (bound, 0) 10647 || (bound_attr == DW_AT_lower_bound 10648 && (((is_c_family () || is_java ()) && integer_zerop (bound)) 10649 || (is_fortran () && integer_onep (bound))))) 10650 /* Use the default. */ 10651 ; 10652 else 10653 add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0)); 10654 break; 10655 10656 case CONVERT_EXPR: 10657 case NOP_EXPR: 10658 case NON_LVALUE_EXPR: 10659 case VIEW_CONVERT_EXPR: 10660 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0)); 10661 break; 10662 10663 case SAVE_EXPR: 10664 break; 10665 10666 case VAR_DECL: 10667 case PARM_DECL: 10668 case RESULT_DECL: 10669 { 10670 dw_die_ref decl_die = lookup_decl_die (bound); 10671 10672 /* ??? Can this happen, or should the variable have been bound 10673 first? Probably it can, since I imagine that we try to create 10674 the types of parameters in the order in which they exist in 10675 the list, and won't have created a forward reference to a 10676 later parameter. */ 10677 if (decl_die != NULL) 10678 add_AT_die_ref (subrange_die, bound_attr, decl_die); 10679 break; 10680 } 10681 10682 default: 10683 { 10684 /* Otherwise try to create a stack operation procedure to 10685 evaluate the value of the array bound. */ 10686 10687 dw_die_ref ctx, decl_die; 10688 dw_loc_descr_ref loc; 10689 10690 loc = loc_descriptor_from_tree (bound); 10691 if (loc == NULL) 10692 break; 10693 10694 if (current_function_decl == 0) 10695 ctx = comp_unit_die; 10696 else 10697 ctx = lookup_decl_die (current_function_decl); 10698 10699 decl_die = new_die (DW_TAG_variable, ctx, bound); 10700 add_AT_flag (decl_die, DW_AT_artificial, 1); 10701 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx); 10702 add_AT_loc (decl_die, DW_AT_location, loc); 10703 10704 add_AT_die_ref (subrange_die, bound_attr, decl_die); 10705 break; 10706 } 10707 } 10708} 10709 10710/* Note that the block of subscript information for an array type also 10711 includes information about the element type of type given array type. */ 10712 10713static void 10714add_subscript_info (dw_die_ref type_die, tree type) 10715{ 10716#ifndef MIPS_DEBUGGING_INFO 10717 unsigned dimension_number; 10718#endif 10719 tree lower, upper; 10720 dw_die_ref subrange_die; 10721 10722 /* The GNU compilers represent multidimensional array types as sequences of 10723 one dimensional array types whose element types are themselves array 10724 types. Here we squish that down, so that each multidimensional array 10725 type gets only one array_type DIE in the Dwarf debugging info. The draft 10726 Dwarf specification say that we are allowed to do this kind of 10727 compression in C (because there is no difference between an array or 10728 arrays and a multidimensional array in C) but for other source languages 10729 (e.g. Ada) we probably shouldn't do this. */ 10730 10731 /* ??? The SGI dwarf reader fails for multidimensional arrays with a 10732 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10]. 10733 We work around this by disabling this feature. See also 10734 gen_array_type_die. */ 10735#ifndef MIPS_DEBUGGING_INFO 10736 for (dimension_number = 0; 10737 TREE_CODE (type) == ARRAY_TYPE; 10738 type = TREE_TYPE (type), dimension_number++) 10739#endif 10740 { 10741 tree domain = TYPE_DOMAIN (type); 10742 10743 /* Arrays come in three flavors: Unspecified bounds, fixed bounds, 10744 and (in GNU C only) variable bounds. Handle all three forms 10745 here. */ 10746 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL); 10747 if (domain) 10748 { 10749 /* We have an array type with specified bounds. */ 10750 lower = TYPE_MIN_VALUE (domain); 10751 upper = TYPE_MAX_VALUE (domain); 10752 10753 /* Define the index type. */ 10754 if (TREE_TYPE (domain)) 10755 { 10756 /* ??? This is probably an Ada unnamed subrange type. Ignore the 10757 TREE_TYPE field. We can't emit debug info for this 10758 because it is an unnamed integral type. */ 10759 if (TREE_CODE (domain) == INTEGER_TYPE 10760 && TYPE_NAME (domain) == NULL_TREE 10761 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE 10762 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE) 10763 ; 10764 else 10765 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0, 10766 type_die); 10767 } 10768 10769 /* ??? If upper is NULL, the array has unspecified length, 10770 but it does have a lower bound. This happens with Fortran 10771 dimension arr(N:*) 10772 Since the debugger is definitely going to need to know N 10773 to produce useful results, go ahead and output the lower 10774 bound solo, and hope the debugger can cope. */ 10775 10776 add_bound_info (subrange_die, DW_AT_lower_bound, lower); 10777 if (upper) 10778 add_bound_info (subrange_die, DW_AT_upper_bound, upper); 10779 } 10780 10781 /* Otherwise we have an array type with an unspecified length. The 10782 DWARF-2 spec does not say how to handle this; let's just leave out the 10783 bounds. */ 10784 } 10785} 10786 10787static void 10788add_byte_size_attribute (dw_die_ref die, tree tree_node) 10789{ 10790 unsigned size; 10791 10792 switch (TREE_CODE (tree_node)) 10793 { 10794 case ERROR_MARK: 10795 size = 0; 10796 break; 10797 case ENUMERAL_TYPE: 10798 case RECORD_TYPE: 10799 case UNION_TYPE: 10800 case QUAL_UNION_TYPE: 10801 size = int_size_in_bytes (tree_node); 10802 break; 10803 case FIELD_DECL: 10804 /* For a data member of a struct or union, the DW_AT_byte_size is 10805 generally given as the number of bytes normally allocated for an 10806 object of the *declared* type of the member itself. This is true 10807 even for bit-fields. */ 10808 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT; 10809 break; 10810 default: 10811 gcc_unreachable (); 10812 } 10813 10814 /* Note that `size' might be -1 when we get to this point. If it is, that 10815 indicates that the byte size of the entity in question is variable. We 10816 have no good way of expressing this fact in Dwarf at the present time. 10817 GCC/35998: Avoid passing negative sizes to Dtrace and gdb. */ 10818 add_AT_unsigned (die, DW_AT_byte_size, (size != (unsigned)-1 ? size : 0)); 10819} 10820 10821/* For a FIELD_DECL node which represents a bit-field, output an attribute 10822 which specifies the distance in bits from the highest order bit of the 10823 "containing object" for the bit-field to the highest order bit of the 10824 bit-field itself. 10825 10826 For any given bit-field, the "containing object" is a hypothetical object 10827 (of some integral or enum type) within which the given bit-field lives. The 10828 type of this hypothetical "containing object" is always the same as the 10829 declared type of the individual bit-field itself. The determination of the 10830 exact location of the "containing object" for a bit-field is rather 10831 complicated. It's handled by the `field_byte_offset' function (above). 10832 10833 Note that it is the size (in bytes) of the hypothetical "containing object" 10834 which will be given in the DW_AT_byte_size attribute for this bit-field. 10835 (See `byte_size_attribute' above). */ 10836 10837static inline void 10838add_bit_offset_attribute (dw_die_ref die, tree decl) 10839{ 10840 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl); 10841 tree type = DECL_BIT_FIELD_TYPE (decl); 10842 HOST_WIDE_INT bitpos_int; 10843 HOST_WIDE_INT highest_order_object_bit_offset; 10844 HOST_WIDE_INT highest_order_field_bit_offset; 10845 HOST_WIDE_INT unsigned bit_offset; 10846 10847 /* Must be a field and a bit field. */ 10848 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL); 10849 10850 /* We can't yet handle bit-fields whose offsets are variable, so if we 10851 encounter such things, just return without generating any attribute 10852 whatsoever. Likewise for variable or too large size. */ 10853 if (! host_integerp (bit_position (decl), 0) 10854 || ! host_integerp (DECL_SIZE (decl), 1)) 10855 return; 10856 10857 bitpos_int = int_bit_position (decl); 10858 10859 /* Note that the bit offset is always the distance (in bits) from the 10860 highest-order bit of the "containing object" to the highest-order bit of 10861 the bit-field itself. Since the "high-order end" of any object or field 10862 is different on big-endian and little-endian machines, the computation 10863 below must take account of these differences. */ 10864 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT; 10865 highest_order_field_bit_offset = bitpos_int; 10866 10867 if (! BYTES_BIG_ENDIAN) 10868 { 10869 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0); 10870 highest_order_object_bit_offset += simple_type_size_in_bits (type); 10871 } 10872 10873 bit_offset 10874 = (! BYTES_BIG_ENDIAN 10875 ? highest_order_object_bit_offset - highest_order_field_bit_offset 10876 : highest_order_field_bit_offset - highest_order_object_bit_offset); 10877 10878 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset); 10879} 10880 10881/* For a FIELD_DECL node which represents a bit field, output an attribute 10882 which specifies the length in bits of the given field. */ 10883 10884static inline void 10885add_bit_size_attribute (dw_die_ref die, tree decl) 10886{ 10887 /* Must be a field and a bit field. */ 10888 gcc_assert (TREE_CODE (decl) == FIELD_DECL 10889 && DECL_BIT_FIELD_TYPE (decl)); 10890 10891 if (host_integerp (DECL_SIZE (decl), 1)) 10892 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1)); 10893} 10894 10895/* If the compiled language is ANSI C, then add a 'prototyped' 10896 attribute, if arg types are given for the parameters of a function. */ 10897 10898static inline void 10899add_prototyped_attribute (dw_die_ref die, tree func_type) 10900{ 10901 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89 10902 && TYPE_ARG_TYPES (func_type) != NULL) 10903 add_AT_flag (die, DW_AT_prototyped, 1); 10904} 10905 10906/* Add an 'abstract_origin' attribute below a given DIE. The DIE is found 10907 by looking in either the type declaration or object declaration 10908 equate table. */ 10909 10910static inline void 10911add_abstract_origin_attribute (dw_die_ref die, tree origin) 10912{ 10913 dw_die_ref origin_die = NULL; 10914 10915 if (TREE_CODE (origin) != FUNCTION_DECL) 10916 { 10917 /* We may have gotten separated from the block for the inlined 10918 function, if we're in an exception handler or some such; make 10919 sure that the abstract function has been written out. 10920 10921 Doing this for nested functions is wrong, however; functions are 10922 distinct units, and our context might not even be inline. */ 10923 tree fn = origin; 10924 10925 if (TYPE_P (fn)) 10926 fn = TYPE_STUB_DECL (fn); 10927 10928 fn = decl_function_context (fn); 10929 if (fn) 10930 dwarf2out_abstract_function (fn); 10931 } 10932 10933 if (DECL_P (origin)) 10934 origin_die = lookup_decl_die (origin); 10935 else if (TYPE_P (origin)) 10936 origin_die = lookup_type_die (origin); 10937 10938 /* XXX: Functions that are never lowered don't always have correct block 10939 trees (in the case of java, they simply have no block tree, in some other 10940 languages). For these functions, there is nothing we can really do to 10941 output correct debug info for inlined functions in all cases. Rather 10942 than die, we'll just produce deficient debug info now, in that we will 10943 have variables without a proper abstract origin. In the future, when all 10944 functions are lowered, we should re-add a gcc_assert (origin_die) 10945 here. */ 10946 10947 if (origin_die) 10948 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die); 10949} 10950 10951/* We do not currently support the pure_virtual attribute. */ 10952 10953static inline void 10954add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl) 10955{ 10956 if (DECL_VINDEX (func_decl)) 10957 { 10958 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual); 10959 10960 if (host_integerp (DECL_VINDEX (func_decl), 0)) 10961 add_AT_loc (die, DW_AT_vtable_elem_location, 10962 new_loc_descr (DW_OP_constu, 10963 tree_low_cst (DECL_VINDEX (func_decl), 0), 10964 0)); 10965 10966 /* GNU extension: Record what type this method came from originally. */ 10967 if (debug_info_level > DINFO_LEVEL_TERSE) 10968 add_AT_die_ref (die, DW_AT_containing_type, 10969 lookup_type_die (DECL_CONTEXT (func_decl))); 10970 } 10971} 10972 10973/* Add source coordinate attributes for the given decl. */ 10974 10975static void 10976add_src_coords_attributes (dw_die_ref die, tree decl) 10977{ 10978 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl)); 10979 10980 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file)); 10981 add_AT_unsigned (die, DW_AT_decl_line, s.line); 10982} 10983 10984/* Add a DW_AT_name attribute and source coordinate attribute for the 10985 given decl, but only if it actually has a name. */ 10986 10987static void 10988add_name_and_src_coords_attributes (dw_die_ref die, tree decl) 10989{ 10990 tree decl_name; 10991 10992 decl_name = DECL_NAME (decl); 10993 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL) 10994 { 10995 add_name_attribute (die, dwarf2_name (decl, 0)); 10996 if (! DECL_ARTIFICIAL (decl)) 10997 add_src_coords_attributes (die, decl); 10998 10999 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL) 11000 && TREE_PUBLIC (decl) 11001 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl) 11002 && !DECL_ABSTRACT (decl) 11003 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))) 11004 add_AT_string (die, DW_AT_MIPS_linkage_name, 11005 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); 11006 } 11007 11008#ifdef VMS_DEBUGGING_INFO 11009 /* Get the function's name, as described by its RTL. This may be different 11010 from the DECL_NAME name used in the source file. */ 11011 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl)) 11012 { 11013 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address, 11014 XEXP (DECL_RTL (decl), 0)); 11015 VEC_safe_push (tree, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0)); 11016 } 11017#endif 11018} 11019 11020/* Push a new declaration scope. */ 11021 11022static void 11023push_decl_scope (tree scope) 11024{ 11025 VEC_safe_push (tree, gc, decl_scope_table, scope); 11026} 11027 11028/* Pop a declaration scope. */ 11029 11030static inline void 11031pop_decl_scope (void) 11032{ 11033 VEC_pop (tree, decl_scope_table); 11034} 11035 11036/* Return the DIE for the scope that immediately contains this type. 11037 Non-named types get global scope. Named types nested in other 11038 types get their containing scope if it's open, or global scope 11039 otherwise. All other types (i.e. function-local named types) get 11040 the current active scope. */ 11041 11042static dw_die_ref 11043scope_die_for (tree t, dw_die_ref context_die) 11044{ 11045 dw_die_ref scope_die = NULL; 11046 tree containing_scope; 11047 int i; 11048 11049 /* Non-types always go in the current scope. */ 11050 gcc_assert (TYPE_P (t)); 11051 11052 containing_scope = TYPE_CONTEXT (t); 11053 11054 /* Use the containing namespace if it was passed in (for a declaration). */ 11055 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL) 11056 { 11057 if (context_die == lookup_decl_die (containing_scope)) 11058 /* OK */; 11059 else 11060 containing_scope = NULL_TREE; 11061 } 11062 11063 /* Ignore function type "scopes" from the C frontend. They mean that 11064 a tagged type is local to a parmlist of a function declarator, but 11065 that isn't useful to DWARF. */ 11066 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE) 11067 containing_scope = NULL_TREE; 11068 11069 if (containing_scope == NULL_TREE) 11070 scope_die = comp_unit_die; 11071 else if (TYPE_P (containing_scope)) 11072 { 11073 /* For types, we can just look up the appropriate DIE. But 11074 first we check to see if we're in the middle of emitting it 11075 so we know where the new DIE should go. */ 11076 for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i) 11077 if (VEC_index (tree, decl_scope_table, i) == containing_scope) 11078 break; 11079 11080 if (i < 0) 11081 { 11082 gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE 11083 || TREE_ASM_WRITTEN (containing_scope)); 11084 11085 /* If none of the current dies are suitable, we get file scope. */ 11086 scope_die = comp_unit_die; 11087 } 11088 else 11089 scope_die = lookup_type_die (containing_scope); 11090 } 11091 else 11092 scope_die = context_die; 11093 11094 return scope_die; 11095} 11096 11097/* Returns nonzero if CONTEXT_DIE is internal to a function. */ 11098 11099static inline int 11100local_scope_p (dw_die_ref context_die) 11101{ 11102 for (; context_die; context_die = context_die->die_parent) 11103 if (context_die->die_tag == DW_TAG_inlined_subroutine 11104 || context_die->die_tag == DW_TAG_subprogram) 11105 return 1; 11106 11107 return 0; 11108} 11109 11110/* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding 11111 whether or not to treat a DIE in this context as a declaration. */ 11112 11113static inline int 11114class_or_namespace_scope_p (dw_die_ref context_die) 11115{ 11116 return (context_die 11117 && (context_die->die_tag == DW_TAG_structure_type 11118 || context_die->die_tag == DW_TAG_union_type 11119 || context_die->die_tag == DW_TAG_namespace)); 11120} 11121 11122/* Many forms of DIEs require a "type description" attribute. This 11123 routine locates the proper "type descriptor" die for the type given 11124 by 'type', and adds a DW_AT_type attribute below the given die. */ 11125 11126static void 11127add_type_attribute (dw_die_ref object_die, tree type, int decl_const, 11128 int decl_volatile, dw_die_ref context_die) 11129{ 11130 enum tree_code code = TREE_CODE (type); 11131 dw_die_ref type_die = NULL; 11132 11133 /* ??? If this type is an unnamed subrange type of an integral or 11134 floating-point type, use the inner type. This is because we have no 11135 support for unnamed types in base_type_die. This can happen if this is 11136 an Ada subrange type. Correct solution is emit a subrange type die. */ 11137 if ((code == INTEGER_TYPE || code == REAL_TYPE) 11138 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0) 11139 type = TREE_TYPE (type), code = TREE_CODE (type); 11140 11141 if (code == ERROR_MARK 11142 /* Handle a special case. For functions whose return type is void, we 11143 generate *no* type attribute. (Note that no object may have type 11144 `void', so this only applies to function return types). */ 11145 || code == VOID_TYPE) 11146 return; 11147 11148 type_die = modified_type_die (type, 11149 decl_const || TYPE_READONLY (type), 11150 decl_volatile || TYPE_VOLATILE (type), 11151 context_die); 11152 11153 if (type_die != NULL) 11154 add_AT_die_ref (object_die, DW_AT_type, type_die); 11155} 11156 11157/* Given an object die, add the calling convention attribute for the 11158 function call type. */ 11159static void 11160add_calling_convention_attribute (dw_die_ref subr_die, tree type) 11161{ 11162 enum dwarf_calling_convention value = DW_CC_normal; 11163 11164 value = targetm.dwarf_calling_convention (type); 11165 11166 /* Only add the attribute if the backend requests it, and 11167 is not DW_CC_normal. */ 11168 if (value && (value != DW_CC_normal)) 11169 add_AT_unsigned (subr_die, DW_AT_calling_convention, value); 11170} 11171 11172/* Given a tree pointer to a struct, class, union, or enum type node, return 11173 a pointer to the (string) tag name for the given type, or zero if the type 11174 was declared without a tag. */ 11175 11176static const char * 11177type_tag (tree type) 11178{ 11179 const char *name = 0; 11180 11181 if (TYPE_NAME (type) != 0) 11182 { 11183 tree t = 0; 11184 11185 /* Find the IDENTIFIER_NODE for the type name. */ 11186 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) 11187 t = TYPE_NAME (type); 11188 11189 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to 11190 a TYPE_DECL node, regardless of whether or not a `typedef' was 11191 involved. */ 11192 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 11193 && ! DECL_IGNORED_P (TYPE_NAME (type))) 11194 t = DECL_NAME (TYPE_NAME (type)); 11195 11196 /* Now get the name as a string, or invent one. */ 11197 if (t != 0) 11198 name = IDENTIFIER_POINTER (t); 11199 } 11200 11201 return (name == 0 || *name == '\0') ? 0 : name; 11202} 11203 11204/* Return the type associated with a data member, make a special check 11205 for bit field types. */ 11206 11207static inline tree 11208member_declared_type (tree member) 11209{ 11210 return (DECL_BIT_FIELD_TYPE (member) 11211 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member)); 11212} 11213 11214/* Get the decl's label, as described by its RTL. This may be different 11215 from the DECL_NAME name used in the source file. */ 11216 11217#if 0 11218static const char * 11219decl_start_label (tree decl) 11220{ 11221 rtx x; 11222 const char *fnname; 11223 11224 x = DECL_RTL (decl); 11225 gcc_assert (MEM_P (x)); 11226 11227 x = XEXP (x, 0); 11228 gcc_assert (GET_CODE (x) == SYMBOL_REF); 11229 11230 fnname = XSTR (x, 0); 11231 return fnname; 11232} 11233#endif 11234 11235/* These routines generate the internal representation of the DIE's for 11236 the compilation unit. Debugging information is collected by walking 11237 the declaration trees passed in from dwarf2out_decl(). */ 11238 11239static void 11240gen_array_type_die (tree type, dw_die_ref context_die) 11241{ 11242 dw_die_ref scope_die = scope_die_for (type, context_die); 11243 dw_die_ref array_die; 11244 tree element_type; 11245 11246 /* ??? The SGI dwarf reader fails for array of array of enum types unless 11247 the inner array type comes before the outer array type. Thus we must 11248 call gen_type_die before we call new_die. See below also. */ 11249#ifdef MIPS_DEBUGGING_INFO 11250 gen_type_die (TREE_TYPE (type), context_die); 11251#endif 11252 11253 array_die = new_die (DW_TAG_array_type, scope_die, type); 11254 add_name_attribute (array_die, type_tag (type)); 11255 equate_type_number_to_die (type, array_die); 11256 11257 if (TREE_CODE (type) == VECTOR_TYPE) 11258 { 11259 /* The frontend feeds us a representation for the vector as a struct 11260 containing an array. Pull out the array type. */ 11261 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type))); 11262 add_AT_flag (array_die, DW_AT_GNU_vector, 1); 11263 } 11264 11265#if 0 11266 /* We default the array ordering. SDB will probably do 11267 the right things even if DW_AT_ordering is not present. It's not even 11268 an issue until we start to get into multidimensional arrays anyway. If 11269 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays, 11270 then we'll have to put the DW_AT_ordering attribute back in. (But if 11271 and when we find out that we need to put these in, we will only do so 11272 for multidimensional arrays. */ 11273 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major); 11274#endif 11275 11276#ifdef MIPS_DEBUGGING_INFO 11277 /* The SGI compilers handle arrays of unknown bound by setting 11278 AT_declaration and not emitting any subrange DIEs. */ 11279 if (! TYPE_DOMAIN (type)) 11280 add_AT_flag (array_die, DW_AT_declaration, 1); 11281 else 11282#endif 11283 add_subscript_info (array_die, type); 11284 11285 /* Add representation of the type of the elements of this array type. */ 11286 element_type = TREE_TYPE (type); 11287 11288 /* ??? The SGI dwarf reader fails for multidimensional arrays with a 11289 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10]. 11290 We work around this by disabling this feature. See also 11291 add_subscript_info. */ 11292#ifndef MIPS_DEBUGGING_INFO 11293 while (TREE_CODE (element_type) == ARRAY_TYPE) 11294 element_type = TREE_TYPE (element_type); 11295 11296 gen_type_die (element_type, context_die); 11297#endif 11298 11299 add_type_attribute (array_die, element_type, 0, 0, context_die); 11300} 11301 11302#if 0 11303static void 11304gen_entry_point_die (tree decl, dw_die_ref context_die) 11305{ 11306 tree origin = decl_ultimate_origin (decl); 11307 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl); 11308 11309 if (origin != NULL) 11310 add_abstract_origin_attribute (decl_die, origin); 11311 else 11312 { 11313 add_name_and_src_coords_attributes (decl_die, decl); 11314 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)), 11315 0, 0, context_die); 11316 } 11317 11318 if (DECL_ABSTRACT (decl)) 11319 equate_decl_number_to_die (decl, decl_die); 11320 else 11321 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl)); 11322} 11323#endif 11324 11325/* Walk through the list of incomplete types again, trying once more to 11326 emit full debugging info for them. */ 11327 11328static void 11329retry_incomplete_types (void) 11330{ 11331 int i; 11332 11333 for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--) 11334 gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die); 11335} 11336 11337/* Generate a DIE to represent an inlined instance of an enumeration type. */ 11338 11339static void 11340gen_inlined_enumeration_type_die (tree type, dw_die_ref context_die) 11341{ 11342 dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type); 11343 11344 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may 11345 be incomplete and such types are not marked. */ 11346 add_abstract_origin_attribute (type_die, type); 11347} 11348 11349/* Generate a DIE to represent an inlined instance of a structure type. */ 11350 11351static void 11352gen_inlined_structure_type_die (tree type, dw_die_ref context_die) 11353{ 11354 dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die, type); 11355 11356 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may 11357 be incomplete and such types are not marked. */ 11358 add_abstract_origin_attribute (type_die, type); 11359} 11360 11361/* Generate a DIE to represent an inlined instance of a union type. */ 11362 11363static void 11364gen_inlined_union_type_die (tree type, dw_die_ref context_die) 11365{ 11366 dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type); 11367 11368 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may 11369 be incomplete and such types are not marked. */ 11370 add_abstract_origin_attribute (type_die, type); 11371} 11372 11373/* Generate a DIE to represent an enumeration type. Note that these DIEs 11374 include all of the information about the enumeration values also. Each 11375 enumerated type name/value is listed as a child of the enumerated type 11376 DIE. */ 11377 11378static dw_die_ref 11379gen_enumeration_type_die (tree type, dw_die_ref context_die) 11380{ 11381 dw_die_ref type_die = lookup_type_die (type); 11382 11383 if (type_die == NULL) 11384 { 11385 type_die = new_die (DW_TAG_enumeration_type, 11386 scope_die_for (type, context_die), type); 11387 equate_type_number_to_die (type, type_die); 11388 add_name_attribute (type_die, type_tag (type)); 11389 } 11390 else if (! TYPE_SIZE (type)) 11391 return type_die; 11392 else 11393 remove_AT (type_die, DW_AT_declaration); 11394 11395 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the 11396 given enum type is incomplete, do not generate the DW_AT_byte_size 11397 attribute or the DW_AT_element_list attribute. */ 11398 if (TYPE_SIZE (type)) 11399 { 11400 tree link; 11401 11402 TREE_ASM_WRITTEN (type) = 1; 11403 add_byte_size_attribute (type_die, type); 11404 if (TYPE_STUB_DECL (type) != NULL_TREE) 11405 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type)); 11406 11407 /* If the first reference to this type was as the return type of an 11408 inline function, then it may not have a parent. Fix this now. */ 11409 if (type_die->die_parent == NULL) 11410 add_child_die (scope_die_for (type, context_die), type_die); 11411 11412 for (link = TYPE_VALUES (type); 11413 link != NULL; link = TREE_CHAIN (link)) 11414 { 11415 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link); 11416 tree value = TREE_VALUE (link); 11417 11418 add_name_attribute (enum_die, 11419 IDENTIFIER_POINTER (TREE_PURPOSE (link))); 11420 11421 if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value)))) 11422 /* DWARF2 does not provide a way of indicating whether or 11423 not enumeration constants are signed or unsigned. GDB 11424 always assumes the values are signed, so we output all 11425 values as if they were signed. That means that 11426 enumeration constants with very large unsigned values 11427 will appear to have negative values in the debugger. */ 11428 add_AT_int (enum_die, DW_AT_const_value, 11429 tree_low_cst (value, tree_int_cst_sgn (value) > 0)); 11430 } 11431 } 11432 else 11433 add_AT_flag (type_die, DW_AT_declaration, 1); 11434 11435 return type_die; 11436} 11437 11438/* Generate a DIE to represent either a real live formal parameter decl or to 11439 represent just the type of some formal parameter position in some function 11440 type. 11441 11442 Note that this routine is a bit unusual because its argument may be a 11443 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which 11444 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE 11445 node. If it's the former then this function is being called to output a 11446 DIE to represent a formal parameter object (or some inlining thereof). If 11447 it's the latter, then this function is only being called to output a 11448 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal 11449 argument type of some subprogram type. */ 11450 11451static dw_die_ref 11452gen_formal_parameter_die (tree node, dw_die_ref context_die) 11453{ 11454 dw_die_ref parm_die 11455 = new_die (DW_TAG_formal_parameter, context_die, node); 11456 tree origin; 11457 11458 switch (TREE_CODE_CLASS (TREE_CODE (node))) 11459 { 11460 case tcc_declaration: 11461 origin = decl_ultimate_origin (node); 11462 if (origin != NULL) 11463 add_abstract_origin_attribute (parm_die, origin); 11464 else 11465 { 11466 add_name_and_src_coords_attributes (parm_die, node); 11467 add_type_attribute (parm_die, TREE_TYPE (node), 11468 TREE_READONLY (node), 11469 TREE_THIS_VOLATILE (node), 11470 context_die); 11471 if (DECL_ARTIFICIAL (node)) 11472 add_AT_flag (parm_die, DW_AT_artificial, 1); 11473 } 11474 11475 equate_decl_number_to_die (node, parm_die); 11476 if (! DECL_ABSTRACT (node)) 11477 add_location_or_const_value_attribute (parm_die, node, DW_AT_location); 11478 11479 break; 11480 11481 case tcc_type: 11482 /* We were called with some kind of a ..._TYPE node. */ 11483 add_type_attribute (parm_die, node, 0, 0, context_die); 11484 break; 11485 11486 default: 11487 gcc_unreachable (); 11488 } 11489 11490 return parm_die; 11491} 11492 11493/* Generate a special type of DIE used as a stand-in for a trailing ellipsis 11494 at the end of an (ANSI prototyped) formal parameters list. */ 11495 11496static void 11497gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die) 11498{ 11499 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type); 11500} 11501 11502/* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a 11503 DW_TAG_unspecified_parameters DIE) to represent the types of the formal 11504 parameters as specified in some function type specification (except for 11505 those which appear as part of a function *definition*). */ 11506 11507static void 11508gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die) 11509{ 11510 tree link; 11511 tree formal_type = NULL; 11512 tree first_parm_type; 11513 tree arg; 11514 11515 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL) 11516 { 11517 arg = DECL_ARGUMENTS (function_or_method_type); 11518 function_or_method_type = TREE_TYPE (function_or_method_type); 11519 } 11520 else 11521 arg = NULL_TREE; 11522 11523 first_parm_type = TYPE_ARG_TYPES (function_or_method_type); 11524 11525 /* Make our first pass over the list of formal parameter types and output a 11526 DW_TAG_formal_parameter DIE for each one. */ 11527 for (link = first_parm_type; link; ) 11528 { 11529 dw_die_ref parm_die; 11530 11531 formal_type = TREE_VALUE (link); 11532 if (formal_type == void_type_node) 11533 break; 11534 11535 /* Output a (nameless) DIE to represent the formal parameter itself. */ 11536 parm_die = gen_formal_parameter_die (formal_type, context_die); 11537 if ((TREE_CODE (function_or_method_type) == METHOD_TYPE 11538 && link == first_parm_type) 11539 || (arg && DECL_ARTIFICIAL (arg))) 11540 add_AT_flag (parm_die, DW_AT_artificial, 1); 11541 11542 link = TREE_CHAIN (link); 11543 if (arg) 11544 arg = TREE_CHAIN (arg); 11545 } 11546 11547 /* If this function type has an ellipsis, add a 11548 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */ 11549 if (formal_type != void_type_node) 11550 gen_unspecified_parameters_die (function_or_method_type, context_die); 11551 11552 /* Make our second (and final) pass over the list of formal parameter types 11553 and output DIEs to represent those types (as necessary). */ 11554 for (link = TYPE_ARG_TYPES (function_or_method_type); 11555 link && TREE_VALUE (link); 11556 link = TREE_CHAIN (link)) 11557 gen_type_die (TREE_VALUE (link), context_die); 11558} 11559 11560/* We want to generate the DIE for TYPE so that we can generate the 11561 die for MEMBER, which has been defined; we will need to refer back 11562 to the member declaration nested within TYPE. If we're trying to 11563 generate minimal debug info for TYPE, processing TYPE won't do the 11564 trick; we need to attach the member declaration by hand. */ 11565 11566static void 11567gen_type_die_for_member (tree type, tree member, dw_die_ref context_die) 11568{ 11569 gen_type_die (type, context_die); 11570 11571 /* If we're trying to avoid duplicate debug info, we may not have 11572 emitted the member decl for this function. Emit it now. */ 11573 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type)) 11574 && ! lookup_decl_die (member)) 11575 { 11576 dw_die_ref type_die; 11577 gcc_assert (!decl_ultimate_origin (member)); 11578 11579 push_decl_scope (type); 11580 type_die = lookup_type_die (type); 11581 if (TREE_CODE (member) == FUNCTION_DECL) 11582 gen_subprogram_die (member, type_die); 11583 else if (TREE_CODE (member) == FIELD_DECL) 11584 { 11585 /* Ignore the nameless fields that are used to skip bits but handle 11586 C++ anonymous unions and structs. */ 11587 if (DECL_NAME (member) != NULL_TREE 11588 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE 11589 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE) 11590 { 11591 gen_type_die (member_declared_type (member), type_die); 11592 gen_field_die (member, type_die); 11593 } 11594 } 11595 else 11596 gen_variable_die (member, type_die); 11597 11598 pop_decl_scope (); 11599 } 11600} 11601 11602/* Generate the DWARF2 info for the "abstract" instance of a function which we 11603 may later generate inlined and/or out-of-line instances of. */ 11604 11605static void 11606dwarf2out_abstract_function (tree decl) 11607{ 11608 dw_die_ref old_die; 11609 tree save_fn; 11610 struct function *save_cfun; 11611 tree context; 11612 int was_abstract = DECL_ABSTRACT (decl); 11613 11614 /* Make sure we have the actual abstract inline, not a clone. */ 11615 decl = DECL_ORIGIN (decl); 11616 11617 old_die = lookup_decl_die (decl); 11618 if (old_die && get_AT (old_die, DW_AT_inline)) 11619 /* We've already generated the abstract instance. */ 11620 return; 11621 11622 /* Be sure we've emitted the in-class declaration DIE (if any) first, so 11623 we don't get confused by DECL_ABSTRACT. */ 11624 if (debug_info_level > DINFO_LEVEL_TERSE) 11625 { 11626 context = decl_class_context (decl); 11627 if (context) 11628 gen_type_die_for_member 11629 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die); 11630 } 11631 11632 /* Pretend we've just finished compiling this function. */ 11633 save_fn = current_function_decl; 11634 save_cfun = cfun; 11635 current_function_decl = decl; 11636 cfun = DECL_STRUCT_FUNCTION (decl); 11637 11638 set_decl_abstract_flags (decl, 1); 11639 dwarf2out_decl (decl); 11640 if (! was_abstract) 11641 set_decl_abstract_flags (decl, 0); 11642 11643 current_function_decl = save_fn; 11644 cfun = save_cfun; 11645} 11646 11647/* Helper function of premark_used_types() which gets called through 11648 htab_traverse_resize(). 11649 11650 Marks the DIE of a given type in *SLOT as perennial, so it never gets 11651 marked as unused by prune_unused_types. */ 11652static int 11653premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED) 11654{ 11655 tree type; 11656 dw_die_ref die; 11657 11658 type = *slot; 11659 die = lookup_type_die (type); 11660 if (die != NULL) 11661 die->die_perennial_p = 1; 11662 return 1; 11663} 11664 11665/* Mark all members of used_types_hash as perennial. */ 11666static void 11667premark_used_types (void) 11668{ 11669 if (cfun && cfun->used_types_hash) 11670 htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL); 11671} 11672 11673/* Generate a DIE to represent a declared function (either file-scope or 11674 block-local). */ 11675 11676static void 11677gen_subprogram_die (tree decl, dw_die_ref context_die) 11678{ 11679 char label_id[MAX_ARTIFICIAL_LABEL_BYTES]; 11680 tree origin = decl_ultimate_origin (decl); 11681 dw_die_ref subr_die; 11682 tree fn_arg_types; 11683 tree outer_scope; 11684 dw_die_ref old_die = lookup_decl_die (decl); 11685 int declaration = (current_function_decl != decl 11686 || class_or_namespace_scope_p (context_die)); 11687 11688 premark_used_types (); 11689 11690 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we 11691 started to generate the abstract instance of an inline, decided to output 11692 its containing class, and proceeded to emit the declaration of the inline 11693 from the member list for the class. If so, DECLARATION takes priority; 11694 we'll get back to the abstract instance when done with the class. */ 11695 11696 /* The class-scope declaration DIE must be the primary DIE. */ 11697 if (origin && declaration && class_or_namespace_scope_p (context_die)) 11698 { 11699 origin = NULL; 11700 gcc_assert (!old_die); 11701 } 11702 11703 /* Now that the C++ front end lazily declares artificial member fns, we 11704 might need to retrofit the declaration into its class. */ 11705 if (!declaration && !origin && !old_die 11706 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)) 11707 && !class_or_namespace_scope_p (context_die) 11708 && debug_info_level > DINFO_LEVEL_TERSE) 11709 old_die = force_decl_die (decl); 11710 11711 if (origin != NULL) 11712 { 11713 gcc_assert (!declaration || local_scope_p (context_die)); 11714 11715 /* Fixup die_parent for the abstract instance of a nested 11716 inline function. */ 11717 if (old_die && old_die->die_parent == NULL) 11718 add_child_die (context_die, old_die); 11719 11720 subr_die = new_die (DW_TAG_subprogram, context_die, decl); 11721 add_abstract_origin_attribute (subr_die, origin); 11722 } 11723 else if (old_die) 11724 { 11725 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl)); 11726 struct dwarf_file_data * file_index = lookup_filename (s.file); 11727 11728 if (!get_AT_flag (old_die, DW_AT_declaration) 11729 /* We can have a normal definition following an inline one in the 11730 case of redefinition of GNU C extern inlines. 11731 It seems reasonable to use AT_specification in this case. */ 11732 && !get_AT (old_die, DW_AT_inline)) 11733 { 11734 /* Detect and ignore this case, where we are trying to output 11735 something we have already output. */ 11736 return; 11737 } 11738 11739 /* If the definition comes from the same place as the declaration, 11740 maybe use the old DIE. We always want the DIE for this function 11741 that has the *_pc attributes to be under comp_unit_die so the 11742 debugger can find it. We also need to do this for abstract 11743 instances of inlines, since the spec requires the out-of-line copy 11744 to have the same parent. For local class methods, this doesn't 11745 apply; we just use the old DIE. */ 11746 if ((old_die->die_parent == comp_unit_die || context_die == NULL) 11747 && (DECL_ARTIFICIAL (decl) 11748 || (get_AT_file (old_die, DW_AT_decl_file) == file_index 11749 && (get_AT_unsigned (old_die, DW_AT_decl_line) 11750 == (unsigned) s.line)))) 11751 { 11752 subr_die = old_die; 11753 11754 /* Clear out the declaration attribute and the formal parameters. 11755 Do not remove all children, because it is possible that this 11756 declaration die was forced using force_decl_die(). In such 11757 cases die that forced declaration die (e.g. TAG_imported_module) 11758 is one of the children that we do not want to remove. */ 11759 remove_AT (subr_die, DW_AT_declaration); 11760 remove_child_TAG (subr_die, DW_TAG_formal_parameter); 11761 } 11762 else 11763 { 11764 subr_die = new_die (DW_TAG_subprogram, context_die, decl); 11765 add_AT_specification (subr_die, old_die); 11766 if (get_AT_file (old_die, DW_AT_decl_file) != file_index) 11767 add_AT_file (subr_die, DW_AT_decl_file, file_index); 11768 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line) 11769 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line); 11770 } 11771 } 11772 else 11773 { 11774 subr_die = new_die (DW_TAG_subprogram, context_die, decl); 11775 11776 if (TREE_PUBLIC (decl)) 11777 add_AT_flag (subr_die, DW_AT_external, 1); 11778 11779 add_name_and_src_coords_attributes (subr_die, decl); 11780 if (debug_info_level > DINFO_LEVEL_TERSE) 11781 { 11782 add_prototyped_attribute (subr_die, TREE_TYPE (decl)); 11783 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)), 11784 0, 0, context_die); 11785 } 11786 11787 add_pure_or_virtual_attribute (subr_die, decl); 11788 if (DECL_ARTIFICIAL (decl)) 11789 add_AT_flag (subr_die, DW_AT_artificial, 1); 11790 11791 if (TREE_PROTECTED (decl)) 11792 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected); 11793 else if (TREE_PRIVATE (decl)) 11794 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private); 11795 } 11796 11797 if (declaration) 11798 { 11799 if (!old_die || !get_AT (old_die, DW_AT_inline)) 11800 { 11801 add_AT_flag (subr_die, DW_AT_declaration, 1); 11802 11803 /* The first time we see a member function, it is in the context of 11804 the class to which it belongs. We make sure of this by emitting 11805 the class first. The next time is the definition, which is 11806 handled above. The two may come from the same source text. 11807 11808 Note that force_decl_die() forces function declaration die. It is 11809 later reused to represent definition. */ 11810 equate_decl_number_to_die (decl, subr_die); 11811 } 11812 } 11813 else if (DECL_ABSTRACT (decl)) 11814 { 11815 if (DECL_DECLARED_INLINE_P (decl)) 11816 { 11817 if (cgraph_function_possibly_inlined_p (decl)) 11818 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined); 11819 else 11820 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined); 11821 } 11822 else 11823 { 11824 if (cgraph_function_possibly_inlined_p (decl)) 11825 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined); 11826 else 11827 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined); 11828 } 11829 11830 equate_decl_number_to_die (decl, subr_die); 11831 } 11832 else if (!DECL_EXTERNAL (decl)) 11833 { 11834 HOST_WIDE_INT cfa_fb_offset; 11835 11836 if (!old_die || !get_AT (old_die, DW_AT_inline)) 11837 equate_decl_number_to_die (decl, subr_die); 11838 11839 if (!flag_reorder_blocks_and_partition) 11840 { 11841 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL, 11842 current_function_funcdef_no); 11843 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id); 11844 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL, 11845 current_function_funcdef_no); 11846 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id); 11847 11848 add_pubname (decl, subr_die); 11849 add_arange (decl, subr_die); 11850 } 11851 else 11852 { /* Do nothing for now; maybe need to duplicate die, one for 11853 hot section and ond for cold section, then use the hot/cold 11854 section begin/end labels to generate the aranges... */ 11855 /* 11856 add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label); 11857 add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label); 11858 add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label); 11859 add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label); 11860 11861 add_pubname (decl, subr_die); 11862 add_arange (decl, subr_die); 11863 add_arange (decl, subr_die); 11864 */ 11865 } 11866 11867#ifdef MIPS_DEBUGGING_INFO 11868 /* Add a reference to the FDE for this routine. */ 11869 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde); 11870#endif 11871 11872 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl); 11873 11874 /* We define the "frame base" as the function's CFA. This is more 11875 convenient for several reasons: (1) It's stable across the prologue 11876 and epilogue, which makes it better than just a frame pointer, 11877 (2) With dwarf3, there exists a one-byte encoding that allows us 11878 to reference the .debug_frame data by proxy, but failing that, 11879 (3) We can at least reuse the code inspection and interpretation 11880 code that determines the CFA position at various points in the 11881 function. */ 11882 /* ??? Use some command-line or configury switch to enable the use 11883 of dwarf3 DW_OP_call_frame_cfa. At present there are no dwarf 11884 consumers that understand it; fall back to "pure" dwarf2 and 11885 convert the CFA data into a location list. */ 11886 { 11887 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset); 11888 if (list->dw_loc_next) 11889 add_AT_loc_list (subr_die, DW_AT_frame_base, list); 11890 else 11891 add_AT_loc (subr_die, DW_AT_frame_base, list->expr); 11892 } 11893 11894 /* Compute a displacement from the "steady-state frame pointer" to 11895 the CFA. The former is what all stack slots and argument slots 11896 will reference in the rtl; the later is what we've told the 11897 debugger about. We'll need to adjust all frame_base references 11898 by this displacement. */ 11899 compute_frame_pointer_to_fb_displacement (cfa_fb_offset); 11900 11901 if (cfun->static_chain_decl) 11902 add_AT_location_description (subr_die, DW_AT_static_link, 11903 loc_descriptor_from_tree (cfun->static_chain_decl)); 11904 } 11905 11906 /* Now output descriptions of the arguments for this function. This gets 11907 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list 11908 for a FUNCTION_DECL doesn't indicate cases where there was a trailing 11909 `...' at the end of the formal parameter list. In order to find out if 11910 there was a trailing ellipsis or not, we must instead look at the type 11911 associated with the FUNCTION_DECL. This will be a node of type 11912 FUNCTION_TYPE. If the chain of type nodes hanging off of this 11913 FUNCTION_TYPE node ends with a void_type_node then there should *not* be 11914 an ellipsis at the end. */ 11915 11916 /* In the case where we are describing a mere function declaration, all we 11917 need to do here (and all we *can* do here) is to describe the *types* of 11918 its formal parameters. */ 11919 if (debug_info_level <= DINFO_LEVEL_TERSE) 11920 ; 11921 else if (declaration) 11922 gen_formal_types_die (decl, subr_die); 11923 else 11924 { 11925 /* Generate DIEs to represent all known formal parameters. */ 11926 tree arg_decls = DECL_ARGUMENTS (decl); 11927 tree parm; 11928 11929 /* When generating DIEs, generate the unspecified_parameters DIE 11930 instead if we come across the arg "__builtin_va_alist" */ 11931 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm)) 11932 if (TREE_CODE (parm) == PARM_DECL) 11933 { 11934 if (DECL_NAME (parm) 11935 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)), 11936 "__builtin_va_alist")) 11937 gen_unspecified_parameters_die (parm, subr_die); 11938 else 11939 gen_decl_die (parm, subr_die); 11940 } 11941 11942 /* Decide whether we need an unspecified_parameters DIE at the end. 11943 There are 2 more cases to do this for: 1) the ansi ... declaration - 11944 this is detectable when the end of the arg list is not a 11945 void_type_node 2) an unprototyped function declaration (not a 11946 definition). This just means that we have no info about the 11947 parameters at all. */ 11948 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl)); 11949 if (fn_arg_types != NULL) 11950 { 11951 /* This is the prototyped case, check for.... */ 11952 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node) 11953 gen_unspecified_parameters_die (decl, subr_die); 11954 } 11955 else if (DECL_INITIAL (decl) == NULL_TREE) 11956 gen_unspecified_parameters_die (decl, subr_die); 11957 } 11958 11959 /* Output Dwarf info for all of the stuff within the body of the function 11960 (if it has one - it may be just a declaration). */ 11961 outer_scope = DECL_INITIAL (decl); 11962 11963 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent 11964 a function. This BLOCK actually represents the outermost binding contour 11965 for the function, i.e. the contour in which the function's formal 11966 parameters and labels get declared. Curiously, it appears that the front 11967 end doesn't actually put the PARM_DECL nodes for the current function onto 11968 the BLOCK_VARS list for this outer scope, but are strung off of the 11969 DECL_ARGUMENTS list for the function instead. 11970 11971 The BLOCK_VARS list for the `outer_scope' does provide us with a list of 11972 the LABEL_DECL nodes for the function however, and we output DWARF info 11973 for those in decls_for_scope. Just within the `outer_scope' there will be 11974 a BLOCK node representing the function's outermost pair of curly braces, 11975 and any blocks used for the base and member initializers of a C++ 11976 constructor function. */ 11977 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK) 11978 { 11979 /* Emit a DW_TAG_variable DIE for a named return value. */ 11980 if (DECL_NAME (DECL_RESULT (decl))) 11981 gen_decl_die (DECL_RESULT (decl), subr_die); 11982 11983 current_function_has_inlines = 0; 11984 decls_for_scope (outer_scope, subr_die, 0); 11985 11986#if 0 && defined (MIPS_DEBUGGING_INFO) 11987 if (current_function_has_inlines) 11988 { 11989 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1); 11990 if (! comp_unit_has_inlines) 11991 { 11992 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1); 11993 comp_unit_has_inlines = 1; 11994 } 11995 } 11996#endif 11997 } 11998 /* Add the calling convention attribute if requested. */ 11999 add_calling_convention_attribute (subr_die, TREE_TYPE (decl)); 12000 12001} 12002 12003/* Generate a DIE to represent a declared data object. */ 12004 12005static void 12006gen_variable_die (tree decl, dw_die_ref context_die) 12007{ 12008 tree origin = decl_ultimate_origin (decl); 12009 dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl); 12010 12011 dw_die_ref old_die = lookup_decl_die (decl); 12012 int declaration = (DECL_EXTERNAL (decl) 12013 /* If DECL is COMDAT and has not actually been 12014 emitted, we cannot take its address; there 12015 might end up being no definition anywhere in 12016 the program. For example, consider the C++ 12017 test case: 12018 12019 template <class T> 12020 struct S { static const int i = 7; }; 12021 12022 template <class T> 12023 const int S<T>::i; 12024 12025 int f() { return S<int>::i; } 12026 12027 Here, S<int>::i is not DECL_EXTERNAL, but no 12028 definition is required, so the compiler will 12029 not emit a definition. */ 12030 || (TREE_CODE (decl) == VAR_DECL 12031 && DECL_COMDAT (decl) && !TREE_ASM_WRITTEN (decl)) 12032 || class_or_namespace_scope_p (context_die)); 12033 12034 if (origin != NULL) 12035 add_abstract_origin_attribute (var_die, origin); 12036 12037 /* Loop unrolling can create multiple blocks that refer to the same 12038 static variable, so we must test for the DW_AT_declaration flag. 12039 12040 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to 12041 copy decls and set the DECL_ABSTRACT flag on them instead of 12042 sharing them. 12043 12044 ??? Duplicated blocks have been rewritten to use .debug_ranges. 12045 12046 ??? The declare_in_namespace support causes us to get two DIEs for one 12047 variable, both of which are declarations. We want to avoid considering 12048 one to be a specification, so we must test that this DIE is not a 12049 declaration. */ 12050 else if (old_die && TREE_STATIC (decl) && ! declaration 12051 && get_AT_flag (old_die, DW_AT_declaration) == 1) 12052 { 12053 /* This is a definition of a C++ class level static. */ 12054 add_AT_specification (var_die, old_die); 12055 if (DECL_NAME (decl)) 12056 { 12057 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl)); 12058 struct dwarf_file_data * file_index = lookup_filename (s.file); 12059 12060 if (get_AT_file (old_die, DW_AT_decl_file) != file_index) 12061 add_AT_file (var_die, DW_AT_decl_file, file_index); 12062 12063 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line) 12064 12065 add_AT_unsigned (var_die, DW_AT_decl_line, s.line); 12066 } 12067 } 12068 else 12069 { 12070 add_name_and_src_coords_attributes (var_die, decl); 12071 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl), 12072 TREE_THIS_VOLATILE (decl), context_die); 12073 12074 if (TREE_PUBLIC (decl)) 12075 add_AT_flag (var_die, DW_AT_external, 1); 12076 12077 if (DECL_ARTIFICIAL (decl)) 12078 add_AT_flag (var_die, DW_AT_artificial, 1); 12079 12080 if (TREE_PROTECTED (decl)) 12081 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected); 12082 else if (TREE_PRIVATE (decl)) 12083 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private); 12084 } 12085 12086 if (declaration) 12087 add_AT_flag (var_die, DW_AT_declaration, 1); 12088 12089 if (DECL_ABSTRACT (decl) || declaration) 12090 equate_decl_number_to_die (decl, var_die); 12091 12092 if (! declaration && ! DECL_ABSTRACT (decl)) 12093 { 12094 add_location_or_const_value_attribute (var_die, decl, DW_AT_location); 12095 add_pubname (decl, var_die); 12096 } 12097 else 12098 tree_add_const_value_attribute (var_die, decl); 12099} 12100 12101/* Generate a DIE to represent a label identifier. */ 12102 12103static void 12104gen_label_die (tree decl, dw_die_ref context_die) 12105{ 12106 tree origin = decl_ultimate_origin (decl); 12107 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl); 12108 rtx insn; 12109 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 12110 12111 if (origin != NULL) 12112 add_abstract_origin_attribute (lbl_die, origin); 12113 else 12114 add_name_and_src_coords_attributes (lbl_die, decl); 12115 12116 if (DECL_ABSTRACT (decl)) 12117 equate_decl_number_to_die (decl, lbl_die); 12118 else 12119 { 12120 insn = DECL_RTL_IF_SET (decl); 12121 12122 /* Deleted labels are programmer specified labels which have been 12123 eliminated because of various optimizations. We still emit them 12124 here so that it is possible to put breakpoints on them. */ 12125 if (insn 12126 && (LABEL_P (insn) 12127 || ((NOTE_P (insn) 12128 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL)))) 12129 { 12130 /* When optimization is enabled (via -O) some parts of the compiler 12131 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which 12132 represent source-level labels which were explicitly declared by 12133 the user. This really shouldn't be happening though, so catch 12134 it if it ever does happen. */ 12135 gcc_assert (!INSN_DELETED_P (insn)); 12136 12137 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn)); 12138 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label); 12139 } 12140 } 12141} 12142 12143/* A helper function for gen_inlined_subroutine_die. Add source coordinate 12144 attributes to the DIE for a block STMT, to describe where the inlined 12145 function was called from. This is similar to add_src_coords_attributes. */ 12146 12147static inline void 12148add_call_src_coords_attributes (tree stmt, dw_die_ref die) 12149{ 12150 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt)); 12151 12152 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file)); 12153 add_AT_unsigned (die, DW_AT_call_line, s.line); 12154} 12155 12156/* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die. 12157 Add low_pc and high_pc attributes to the DIE for a block STMT. */ 12158 12159static inline void 12160add_high_low_attributes (tree stmt, dw_die_ref die) 12161{ 12162 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 12163 12164 if (BLOCK_FRAGMENT_CHAIN (stmt)) 12165 { 12166 tree chain; 12167 12168 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt)); 12169 12170 chain = BLOCK_FRAGMENT_CHAIN (stmt); 12171 do 12172 { 12173 add_ranges (chain); 12174 chain = BLOCK_FRAGMENT_CHAIN (chain); 12175 } 12176 while (chain); 12177 add_ranges (NULL); 12178 } 12179 else 12180 { 12181 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL, 12182 BLOCK_NUMBER (stmt)); 12183 add_AT_lbl_id (die, DW_AT_low_pc, label); 12184 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, 12185 BLOCK_NUMBER (stmt)); 12186 add_AT_lbl_id (die, DW_AT_high_pc, label); 12187 } 12188} 12189 12190/* Generate a DIE for a lexical block. */ 12191 12192static void 12193gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth) 12194{ 12195 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt); 12196 12197 if (! BLOCK_ABSTRACT (stmt)) 12198 add_high_low_attributes (stmt, stmt_die); 12199 12200 decls_for_scope (stmt, stmt_die, depth); 12201} 12202 12203/* Generate a DIE for an inlined subprogram. */ 12204 12205static void 12206gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth) 12207{ 12208 tree decl = block_ultimate_origin (stmt); 12209 12210 /* Emit info for the abstract instance first, if we haven't yet. We 12211 must emit this even if the block is abstract, otherwise when we 12212 emit the block below (or elsewhere), we may end up trying to emit 12213 a die whose origin die hasn't been emitted, and crashing. */ 12214 dwarf2out_abstract_function (decl); 12215 12216 if (! BLOCK_ABSTRACT (stmt)) 12217 { 12218 dw_die_ref subr_die 12219 = new_die (DW_TAG_inlined_subroutine, context_die, stmt); 12220 12221 add_abstract_origin_attribute (subr_die, decl); 12222 add_high_low_attributes (stmt, subr_die); 12223 add_call_src_coords_attributes (stmt, subr_die); 12224 12225 decls_for_scope (stmt, subr_die, depth); 12226 current_function_has_inlines = 1; 12227 } 12228 else 12229 /* We may get here if we're the outer block of function A that was 12230 inlined into function B that was inlined into function C. When 12231 generating debugging info for C, dwarf2out_abstract_function(B) 12232 would mark all inlined blocks as abstract, including this one. 12233 So, we wouldn't (and shouldn't) expect labels to be generated 12234 for this one. Instead, just emit debugging info for 12235 declarations within the block. This is particularly important 12236 in the case of initializers of arguments passed from B to us: 12237 if they're statement expressions containing declarations, we 12238 wouldn't generate dies for their abstract variables, and then, 12239 when generating dies for the real variables, we'd die (pun 12240 intended :-) */ 12241 gen_lexical_block_die (stmt, context_die, depth); 12242} 12243 12244/* Generate a DIE for a field in a record, or structure. */ 12245 12246static void 12247gen_field_die (tree decl, dw_die_ref context_die) 12248{ 12249 dw_die_ref decl_die; 12250 12251 if (TREE_TYPE (decl) == error_mark_node) 12252 return; 12253 12254 decl_die = new_die (DW_TAG_member, context_die, decl); 12255 add_name_and_src_coords_attributes (decl_die, decl); 12256 add_type_attribute (decl_die, member_declared_type (decl), 12257 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl), 12258 context_die); 12259 12260 if (DECL_BIT_FIELD_TYPE (decl)) 12261 { 12262 add_byte_size_attribute (decl_die, decl); 12263 add_bit_size_attribute (decl_die, decl); 12264 add_bit_offset_attribute (decl_die, decl); 12265 } 12266 12267 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE) 12268 add_data_member_location_attribute (decl_die, decl); 12269 12270 if (DECL_ARTIFICIAL (decl)) 12271 add_AT_flag (decl_die, DW_AT_artificial, 1); 12272 12273 if (TREE_PROTECTED (decl)) 12274 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected); 12275 else if (TREE_PRIVATE (decl)) 12276 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private); 12277 12278 /* Equate decl number to die, so that we can look up this decl later on. */ 12279 equate_decl_number_to_die (decl, decl_die); 12280} 12281 12282#if 0 12283/* Don't generate either pointer_type DIEs or reference_type DIEs here. 12284 Use modified_type_die instead. 12285 We keep this code here just in case these types of DIEs may be needed to 12286 represent certain things in other languages (e.g. Pascal) someday. */ 12287 12288static void 12289gen_pointer_type_die (tree type, dw_die_ref context_die) 12290{ 12291 dw_die_ref ptr_die 12292 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type); 12293 12294 equate_type_number_to_die (type, ptr_die); 12295 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die); 12296 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); 12297} 12298 12299/* Don't generate either pointer_type DIEs or reference_type DIEs here. 12300 Use modified_type_die instead. 12301 We keep this code here just in case these types of DIEs may be needed to 12302 represent certain things in other languages (e.g. Pascal) someday. */ 12303 12304static void 12305gen_reference_type_die (tree type, dw_die_ref context_die) 12306{ 12307 dw_die_ref ref_die 12308 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type); 12309 12310 equate_type_number_to_die (type, ref_die); 12311 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die); 12312 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); 12313} 12314#endif 12315 12316/* Generate a DIE for a pointer to a member type. */ 12317 12318static void 12319gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die) 12320{ 12321 dw_die_ref ptr_die 12322 = new_die (DW_TAG_ptr_to_member_type, 12323 scope_die_for (type, context_die), type); 12324 12325 equate_type_number_to_die (type, ptr_die); 12326 add_AT_die_ref (ptr_die, DW_AT_containing_type, 12327 lookup_type_die (TYPE_OFFSET_BASETYPE (type))); 12328 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die); 12329} 12330 12331/* Generate the DIE for the compilation unit. */ 12332 12333static dw_die_ref 12334gen_compile_unit_die (const char *filename) 12335{ 12336 dw_die_ref die; 12337 char producer[250]; 12338 const char *language_string = lang_hooks.name; 12339 int language; 12340 12341 die = new_die (DW_TAG_compile_unit, NULL, NULL); 12342 12343 if (filename) 12344 { 12345 add_name_attribute (die, filename); 12346 /* Don't add cwd for <built-in>. */ 12347 if (filename[0] != DIR_SEPARATOR && filename[0] != '<') 12348 add_comp_dir_attribute (die); 12349 } 12350 12351 sprintf (producer, "%s %s", language_string, version_string); 12352 12353#ifdef MIPS_DEBUGGING_INFO 12354 /* The MIPS/SGI compilers place the 'cc' command line options in the producer 12355 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do 12356 not appear in the producer string, the debugger reaches the conclusion 12357 that the object file is stripped and has no debugging information. 12358 To get the MIPS/SGI debugger to believe that there is debugging 12359 information in the object file, we add a -g to the producer string. */ 12360 if (debug_info_level > DINFO_LEVEL_TERSE) 12361 strcat (producer, " -g"); 12362#endif 12363 12364 add_AT_string (die, DW_AT_producer, producer); 12365 12366 if (strcmp (language_string, "GNU C++") == 0) 12367 language = DW_LANG_C_plus_plus; 12368 else if (strcmp (language_string, "GNU Ada") == 0) 12369 language = DW_LANG_Ada95; 12370 else if (strcmp (language_string, "GNU F77") == 0) 12371 language = DW_LANG_Fortran77; 12372 else if (strcmp (language_string, "GNU F95") == 0) 12373 language = DW_LANG_Fortran95; 12374 else if (strcmp (language_string, "GNU Pascal") == 0) 12375 language = DW_LANG_Pascal83; 12376 else if (strcmp (language_string, "GNU Java") == 0) 12377 language = DW_LANG_Java; 12378 else if (strcmp (language_string, "GNU Objective-C") == 0) 12379 language = DW_LANG_ObjC; 12380 else if (strcmp (language_string, "GNU Objective-C++") == 0) 12381 language = DW_LANG_ObjC_plus_plus; 12382 else 12383 language = DW_LANG_C89; 12384 12385 add_AT_unsigned (die, DW_AT_language, language); 12386 return die; 12387} 12388 12389/* Generate the DIE for a base class. */ 12390 12391static void 12392gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die) 12393{ 12394 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo); 12395 12396 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die); 12397 add_data_member_location_attribute (die, binfo); 12398 12399 if (BINFO_VIRTUAL_P (binfo)) 12400 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual); 12401 12402 if (access == access_public_node) 12403 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public); 12404 else if (access == access_protected_node) 12405 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected); 12406} 12407 12408/* Generate a DIE for a class member. */ 12409 12410static void 12411gen_member_die (tree type, dw_die_ref context_die) 12412{ 12413 tree member; 12414 tree binfo = TYPE_BINFO (type); 12415 dw_die_ref child; 12416 12417 /* If this is not an incomplete type, output descriptions of each of its 12418 members. Note that as we output the DIEs necessary to represent the 12419 members of this record or union type, we will also be trying to output 12420 DIEs to represent the *types* of those members. However the `type' 12421 function (above) will specifically avoid generating type DIEs for member 12422 types *within* the list of member DIEs for this (containing) type except 12423 for those types (of members) which are explicitly marked as also being 12424 members of this (containing) type themselves. The g++ front- end can 12425 force any given type to be treated as a member of some other (containing) 12426 type by setting the TYPE_CONTEXT of the given (member) type to point to 12427 the TREE node representing the appropriate (containing) type. */ 12428 12429 /* First output info about the base classes. */ 12430 if (binfo) 12431 { 12432 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo); 12433 int i; 12434 tree base; 12435 12436 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++) 12437 gen_inheritance_die (base, 12438 (accesses ? VEC_index (tree, accesses, i) 12439 : access_public_node), context_die); 12440 } 12441 12442 /* Now output info about the data members and type members. */ 12443 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member)) 12444 { 12445 /* If we thought we were generating minimal debug info for TYPE 12446 and then changed our minds, some of the member declarations 12447 may have already been defined. Don't define them again, but 12448 do put them in the right order. */ 12449 12450 child = lookup_decl_die (member); 12451 if (child) 12452 splice_child_die (context_die, child); 12453 else 12454 gen_decl_die (member, context_die); 12455 } 12456 12457 /* Now output info about the function members (if any). */ 12458 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member)) 12459 { 12460 /* Don't include clones in the member list. */ 12461 if (DECL_ABSTRACT_ORIGIN (member)) 12462 continue; 12463 12464 child = lookup_decl_die (member); 12465 if (child) 12466 splice_child_die (context_die, child); 12467 else 12468 gen_decl_die (member, context_die); 12469 } 12470} 12471 12472/* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG 12473 is set, we pretend that the type was never defined, so we only get the 12474 member DIEs needed by later specification DIEs. */ 12475 12476static void 12477gen_struct_or_union_type_die (tree type, dw_die_ref context_die, 12478 enum debug_info_usage usage) 12479{ 12480 dw_die_ref type_die = lookup_type_die (type); 12481 dw_die_ref scope_die = 0; 12482 int nested = 0; 12483 int complete = (TYPE_SIZE (type) 12484 && (! TYPE_STUB_DECL (type) 12485 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type)))); 12486 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace); 12487 complete = complete && should_emit_struct_debug (type, usage); 12488 12489 if (type_die && ! complete) 12490 return; 12491 12492 if (TYPE_CONTEXT (type) != NULL_TREE 12493 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type)) 12494 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL)) 12495 nested = 1; 12496 12497 scope_die = scope_die_for (type, context_die); 12498 12499 if (! type_die || (nested && scope_die == comp_unit_die)) 12500 /* First occurrence of type or toplevel definition of nested class. */ 12501 { 12502 dw_die_ref old_die = type_die; 12503 12504 type_die = new_die (TREE_CODE (type) == RECORD_TYPE 12505 ? DW_TAG_structure_type : DW_TAG_union_type, 12506 scope_die, type); 12507 equate_type_number_to_die (type, type_die); 12508 if (old_die) 12509 add_AT_specification (type_die, old_die); 12510 else 12511 add_name_attribute (type_die, type_tag (type)); 12512 } 12513 else 12514 remove_AT (type_die, DW_AT_declaration); 12515 12516 /* If this type has been completed, then give it a byte_size attribute and 12517 then give a list of members. */ 12518 if (complete && !ns_decl) 12519 { 12520 /* Prevent infinite recursion in cases where the type of some member of 12521 this type is expressed in terms of this type itself. */ 12522 TREE_ASM_WRITTEN (type) = 1; 12523 add_byte_size_attribute (type_die, type); 12524 if (TYPE_STUB_DECL (type) != NULL_TREE) 12525 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type)); 12526 12527 /* If the first reference to this type was as the return type of an 12528 inline function, then it may not have a parent. Fix this now. */ 12529 if (type_die->die_parent == NULL) 12530 add_child_die (scope_die, type_die); 12531 12532 push_decl_scope (type); 12533 gen_member_die (type, type_die); 12534 pop_decl_scope (); 12535 12536 /* GNU extension: Record what type our vtable lives in. */ 12537 if (TYPE_VFIELD (type)) 12538 { 12539 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type)); 12540 12541 gen_type_die (vtype, context_die); 12542 add_AT_die_ref (type_die, DW_AT_containing_type, 12543 lookup_type_die (vtype)); 12544 } 12545 } 12546 else 12547 { 12548 add_AT_flag (type_die, DW_AT_declaration, 1); 12549 12550 /* We don't need to do this for function-local types. */ 12551 if (TYPE_STUB_DECL (type) 12552 && ! decl_function_context (TYPE_STUB_DECL (type))) 12553 VEC_safe_push (tree, gc, incomplete_types, type); 12554 } 12555} 12556 12557/* Generate a DIE for a subroutine _type_. */ 12558 12559static void 12560gen_subroutine_type_die (tree type, dw_die_ref context_die) 12561{ 12562 tree return_type = TREE_TYPE (type); 12563 dw_die_ref subr_die 12564 = new_die (DW_TAG_subroutine_type, 12565 scope_die_for (type, context_die), type); 12566 12567 equate_type_number_to_die (type, subr_die); 12568 add_prototyped_attribute (subr_die, type); 12569 add_type_attribute (subr_die, return_type, 0, 0, context_die); 12570 gen_formal_types_die (type, subr_die); 12571} 12572 12573/* Generate a DIE for a type definition. */ 12574 12575static void 12576gen_typedef_die (tree decl, dw_die_ref context_die) 12577{ 12578 dw_die_ref type_die; 12579 tree origin; 12580 12581 if (TREE_ASM_WRITTEN (decl)) 12582 return; 12583 12584 TREE_ASM_WRITTEN (decl) = 1; 12585 type_die = new_die (DW_TAG_typedef, context_die, decl); 12586 origin = decl_ultimate_origin (decl); 12587 if (origin != NULL) 12588 add_abstract_origin_attribute (type_die, origin); 12589 else 12590 { 12591 tree type; 12592 12593 add_name_and_src_coords_attributes (type_die, decl); 12594 if (DECL_ORIGINAL_TYPE (decl)) 12595 { 12596 type = DECL_ORIGINAL_TYPE (decl); 12597 12598 gcc_assert (type != TREE_TYPE (decl)); 12599 equate_type_number_to_die (TREE_TYPE (decl), type_die); 12600 } 12601 else 12602 type = TREE_TYPE (decl); 12603 12604 add_type_attribute (type_die, type, TREE_READONLY (decl), 12605 TREE_THIS_VOLATILE (decl), context_die); 12606 } 12607 12608 if (DECL_ABSTRACT (decl)) 12609 equate_decl_number_to_die (decl, type_die); 12610} 12611 12612/* Generate a type description DIE. */ 12613 12614static void 12615gen_type_die_with_usage (tree type, dw_die_ref context_die, 12616 enum debug_info_usage usage) 12617{ 12618 int need_pop; 12619 12620 if (type == NULL_TREE || type == error_mark_node) 12621 return; 12622 12623 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 12624 && DECL_ORIGINAL_TYPE (TYPE_NAME (type))) 12625 { 12626 if (TREE_ASM_WRITTEN (type)) 12627 return; 12628 12629 /* Prevent broken recursion; we can't hand off to the same type. */ 12630 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type); 12631 12632 TREE_ASM_WRITTEN (type) = 1; 12633 gen_decl_die (TYPE_NAME (type), context_die); 12634 return; 12635 } 12636 12637 /* We are going to output a DIE to represent the unqualified version 12638 of this type (i.e. without any const or volatile qualifiers) so 12639 get the main variant (i.e. the unqualified version) of this type 12640 now. (Vectors are special because the debugging info is in the 12641 cloned type itself). */ 12642 if (TREE_CODE (type) != VECTOR_TYPE) 12643 type = type_main_variant (type); 12644 12645 if (TREE_ASM_WRITTEN (type)) 12646 return; 12647 12648 switch (TREE_CODE (type)) 12649 { 12650 case ERROR_MARK: 12651 break; 12652 12653 case POINTER_TYPE: 12654 case REFERENCE_TYPE: 12655 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This 12656 ensures that the gen_type_die recursion will terminate even if the 12657 type is recursive. Recursive types are possible in Ada. */ 12658 /* ??? We could perhaps do this for all types before the switch 12659 statement. */ 12660 TREE_ASM_WRITTEN (type) = 1; 12661 12662 /* For these types, all that is required is that we output a DIE (or a 12663 set of DIEs) to represent the "basis" type. */ 12664 gen_type_die_with_usage (TREE_TYPE (type), context_die, 12665 DINFO_USAGE_IND_USE); 12666 break; 12667 12668 case OFFSET_TYPE: 12669 /* This code is used for C++ pointer-to-data-member types. 12670 Output a description of the relevant class type. */ 12671 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die, 12672 DINFO_USAGE_IND_USE); 12673 12674 /* Output a description of the type of the object pointed to. */ 12675 gen_type_die_with_usage (TREE_TYPE (type), context_die, 12676 DINFO_USAGE_IND_USE); 12677 12678 /* Now output a DIE to represent this pointer-to-data-member type 12679 itself. */ 12680 gen_ptr_to_mbr_type_die (type, context_die); 12681 break; 12682 12683 case FUNCTION_TYPE: 12684 /* Force out return type (in case it wasn't forced out already). */ 12685 gen_type_die_with_usage (TREE_TYPE (type), context_die, 12686 DINFO_USAGE_DIR_USE); 12687 gen_subroutine_type_die (type, context_die); 12688 break; 12689 12690 case METHOD_TYPE: 12691 /* Force out return type (in case it wasn't forced out already). */ 12692 gen_type_die_with_usage (TREE_TYPE (type), context_die, 12693 DINFO_USAGE_DIR_USE); 12694 gen_subroutine_type_die (type, context_die); 12695 break; 12696 12697 case ARRAY_TYPE: 12698 gen_array_type_die (type, context_die); 12699 break; 12700 12701 case VECTOR_TYPE: 12702 gen_array_type_die (type, context_die); 12703 break; 12704 12705 case ENUMERAL_TYPE: 12706 case RECORD_TYPE: 12707 case UNION_TYPE: 12708 case QUAL_UNION_TYPE: 12709 /* If this is a nested type whose containing class hasn't been written 12710 out yet, writing it out will cover this one, too. This does not apply 12711 to instantiations of member class templates; they need to be added to 12712 the containing class as they are generated. FIXME: This hurts the 12713 idea of combining type decls from multiple TUs, since we can't predict 12714 what set of template instantiations we'll get. */ 12715 if (TYPE_CONTEXT (type) 12716 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)) 12717 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type))) 12718 { 12719 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage); 12720 12721 if (TREE_ASM_WRITTEN (type)) 12722 return; 12723 12724 /* If that failed, attach ourselves to the stub. */ 12725 push_decl_scope (TYPE_CONTEXT (type)); 12726 context_die = lookup_type_die (TYPE_CONTEXT (type)); 12727 need_pop = 1; 12728 } 12729 else 12730 { 12731 declare_in_namespace (type, context_die); 12732 need_pop = 0; 12733 } 12734 12735 if (TREE_CODE (type) == ENUMERAL_TYPE) 12736 { 12737 /* This might have been written out by the call to 12738 declare_in_namespace. */ 12739 if (!TREE_ASM_WRITTEN (type)) 12740 gen_enumeration_type_die (type, context_die); 12741 } 12742 else 12743 gen_struct_or_union_type_die (type, context_die, usage); 12744 12745 if (need_pop) 12746 pop_decl_scope (); 12747 12748 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix 12749 it up if it is ever completed. gen_*_type_die will set it for us 12750 when appropriate. */ 12751 return; 12752 12753 case VOID_TYPE: 12754 case INTEGER_TYPE: 12755 case REAL_TYPE: 12756 case COMPLEX_TYPE: 12757 case BOOLEAN_TYPE: 12758 /* No DIEs needed for fundamental types. */ 12759 break; 12760 12761 case LANG_TYPE: 12762 /* No Dwarf representation currently defined. */ 12763 break; 12764 12765 default: 12766 gcc_unreachable (); 12767 } 12768 12769 TREE_ASM_WRITTEN (type) = 1; 12770} 12771 12772static void 12773gen_type_die (tree type, dw_die_ref context_die) 12774{ 12775 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE); 12776} 12777 12778/* Generate a DIE for a tagged type instantiation. */ 12779 12780static void 12781gen_tagged_type_instantiation_die (tree type, dw_die_ref context_die) 12782{ 12783 if (type == NULL_TREE || type == error_mark_node) 12784 return; 12785 12786 /* We are going to output a DIE to represent the unqualified version of 12787 this type (i.e. without any const or volatile qualifiers) so make sure 12788 that we have the main variant (i.e. the unqualified version) of this 12789 type now. */ 12790 gcc_assert (type == type_main_variant (type)); 12791 12792 /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is 12793 an instance of an unresolved type. */ 12794 12795 switch (TREE_CODE (type)) 12796 { 12797 case ERROR_MARK: 12798 break; 12799 12800 case ENUMERAL_TYPE: 12801 gen_inlined_enumeration_type_die (type, context_die); 12802 break; 12803 12804 case RECORD_TYPE: 12805 gen_inlined_structure_type_die (type, context_die); 12806 break; 12807 12808 case UNION_TYPE: 12809 case QUAL_UNION_TYPE: 12810 gen_inlined_union_type_die (type, context_die); 12811 break; 12812 12813 default: 12814 gcc_unreachable (); 12815 } 12816} 12817 12818/* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the 12819 things which are local to the given block. */ 12820 12821static void 12822gen_block_die (tree stmt, dw_die_ref context_die, int depth) 12823{ 12824 int must_output_die = 0; 12825 tree origin; 12826 tree decl; 12827 enum tree_code origin_code; 12828 12829 /* Ignore blocks that are NULL. */ 12830 if (stmt == NULL_TREE) 12831 return; 12832 12833 /* If the block is one fragment of a non-contiguous block, do not 12834 process the variables, since they will have been done by the 12835 origin block. Do process subblocks. */ 12836 if (BLOCK_FRAGMENT_ORIGIN (stmt)) 12837 { 12838 tree sub; 12839 12840 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub)) 12841 gen_block_die (sub, context_die, depth + 1); 12842 12843 return; 12844 } 12845 12846 /* Determine the "ultimate origin" of this block. This block may be an 12847 inlined instance of an inlined instance of inline function, so we have 12848 to trace all of the way back through the origin chain to find out what 12849 sort of node actually served as the original seed for the creation of 12850 the current block. */ 12851 origin = block_ultimate_origin (stmt); 12852 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK; 12853 12854 /* Determine if we need to output any Dwarf DIEs at all to represent this 12855 block. */ 12856 if (origin_code == FUNCTION_DECL) 12857 /* The outer scopes for inlinings *must* always be represented. We 12858 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */ 12859 must_output_die = 1; 12860 else 12861 { 12862 /* In the case where the current block represents an inlining of the 12863 "body block" of an inline function, we must *NOT* output any DIE for 12864 this block because we have already output a DIE to represent the whole 12865 inlined function scope and the "body block" of any function doesn't 12866 really represent a different scope according to ANSI C rules. So we 12867 check here to make sure that this block does not represent a "body 12868 block inlining" before trying to set the MUST_OUTPUT_DIE flag. */ 12869 if (! is_body_block (origin ? origin : stmt)) 12870 { 12871 /* Determine if this block directly contains any "significant" 12872 local declarations which we will need to output DIEs for. */ 12873 if (debug_info_level > DINFO_LEVEL_TERSE) 12874 /* We are not in terse mode so *any* local declaration counts 12875 as being a "significant" one. */ 12876 must_output_die = (BLOCK_VARS (stmt) != NULL 12877 && (TREE_USED (stmt) 12878 || TREE_ASM_WRITTEN (stmt) 12879 || BLOCK_ABSTRACT (stmt))); 12880 else 12881 /* We are in terse mode, so only local (nested) function 12882 definitions count as "significant" local declarations. */ 12883 for (decl = BLOCK_VARS (stmt); 12884 decl != NULL; decl = TREE_CHAIN (decl)) 12885 if (TREE_CODE (decl) == FUNCTION_DECL 12886 && DECL_INITIAL (decl)) 12887 { 12888 must_output_die = 1; 12889 break; 12890 } 12891 } 12892 } 12893 12894 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block 12895 DIE for any block which contains no significant local declarations at 12896 all. Rather, in such cases we just call `decls_for_scope' so that any 12897 needed Dwarf info for any sub-blocks will get properly generated. Note 12898 that in terse mode, our definition of what constitutes a "significant" 12899 local declaration gets restricted to include only inlined function 12900 instances and local (nested) function definitions. */ 12901 if (must_output_die) 12902 { 12903 if (origin_code == FUNCTION_DECL) 12904 gen_inlined_subroutine_die (stmt, context_die, depth); 12905 else 12906 gen_lexical_block_die (stmt, context_die, depth); 12907 } 12908 else 12909 decls_for_scope (stmt, context_die, depth); 12910} 12911 12912/* Generate all of the decls declared within a given scope and (recursively) 12913 all of its sub-blocks. */ 12914 12915static void 12916decls_for_scope (tree stmt, dw_die_ref context_die, int depth) 12917{ 12918 tree decl; 12919 tree subblocks; 12920 12921 /* Ignore NULL blocks. */ 12922 if (stmt == NULL_TREE) 12923 return; 12924 12925 if (TREE_USED (stmt)) 12926 { 12927 /* Output the DIEs to represent all of the data objects and typedefs 12928 declared directly within this block but not within any nested 12929 sub-blocks. Also, nested function and tag DIEs have been 12930 generated with a parent of NULL; fix that up now. */ 12931 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl)) 12932 { 12933 dw_die_ref die; 12934 12935 if (TREE_CODE (decl) == FUNCTION_DECL) 12936 die = lookup_decl_die (decl); 12937 else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)) 12938 die = lookup_type_die (TREE_TYPE (decl)); 12939 else 12940 die = NULL; 12941 12942 if (die != NULL && die->die_parent == NULL) 12943 add_child_die (context_die, die); 12944 /* Do not produce debug information for static variables since 12945 these might be optimized out. We are called for these later 12946 in cgraph_varpool_analyze_pending_decls. */ 12947 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)) 12948 ; 12949 else 12950 gen_decl_die (decl, context_die); 12951 } 12952 } 12953 12954 /* If we're at -g1, we're not interested in subblocks. */ 12955 if (debug_info_level <= DINFO_LEVEL_TERSE) 12956 return; 12957 12958 /* Output the DIEs to represent all sub-blocks (and the items declared 12959 therein) of this block. */ 12960 for (subblocks = BLOCK_SUBBLOCKS (stmt); 12961 subblocks != NULL; 12962 subblocks = BLOCK_CHAIN (subblocks)) 12963 gen_block_die (subblocks, context_die, depth + 1); 12964} 12965 12966/* Is this a typedef we can avoid emitting? */ 12967 12968static inline int 12969is_redundant_typedef (tree decl) 12970{ 12971 if (TYPE_DECL_IS_STUB (decl)) 12972 return 1; 12973 12974 if (DECL_ARTIFICIAL (decl) 12975 && DECL_CONTEXT (decl) 12976 && is_tagged_type (DECL_CONTEXT (decl)) 12977 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL 12978 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))) 12979 /* Also ignore the artificial member typedef for the class name. */ 12980 return 1; 12981 12982 return 0; 12983} 12984 12985/* Returns the DIE for decl. A DIE will always be returned. */ 12986 12987static dw_die_ref 12988force_decl_die (tree decl) 12989{ 12990 dw_die_ref decl_die; 12991 unsigned saved_external_flag; 12992 tree save_fn = NULL_TREE; 12993 decl_die = lookup_decl_die (decl); 12994 if (!decl_die) 12995 { 12996 dw_die_ref context_die; 12997 tree decl_context = DECL_CONTEXT (decl); 12998 if (decl_context) 12999 { 13000 /* Find die that represents this context. */ 13001 if (TYPE_P (decl_context)) 13002 context_die = force_type_die (decl_context); 13003 else 13004 context_die = force_decl_die (decl_context); 13005 } 13006 else 13007 context_die = comp_unit_die; 13008 13009 decl_die = lookup_decl_die (decl); 13010 if (decl_die) 13011 return decl_die; 13012 13013 switch (TREE_CODE (decl)) 13014 { 13015 case FUNCTION_DECL: 13016 /* Clear current_function_decl, so that gen_subprogram_die thinks 13017 that this is a declaration. At this point, we just want to force 13018 declaration die. */ 13019 save_fn = current_function_decl; 13020 current_function_decl = NULL_TREE; 13021 gen_subprogram_die (decl, context_die); 13022 current_function_decl = save_fn; 13023 break; 13024 13025 case VAR_DECL: 13026 /* Set external flag to force declaration die. Restore it after 13027 gen_decl_die() call. */ 13028 saved_external_flag = DECL_EXTERNAL (decl); 13029 DECL_EXTERNAL (decl) = 1; 13030 gen_decl_die (decl, context_die); 13031 DECL_EXTERNAL (decl) = saved_external_flag; 13032 break; 13033 13034 case NAMESPACE_DECL: 13035 dwarf2out_decl (decl); 13036 break; 13037 13038 default: 13039 gcc_unreachable (); 13040 } 13041 13042 /* We should be able to find the DIE now. */ 13043 if (!decl_die) 13044 decl_die = lookup_decl_die (decl); 13045 gcc_assert (decl_die); 13046 } 13047 13048 return decl_die; 13049} 13050 13051/* Returns the DIE for TYPE, that must not be a base type. A DIE is 13052 always returned. */ 13053 13054static dw_die_ref 13055force_type_die (tree type) 13056{ 13057 dw_die_ref type_die; 13058 13059 type_die = lookup_type_die (type); 13060 if (!type_die) 13061 { 13062 dw_die_ref context_die; 13063 if (TYPE_CONTEXT (type)) 13064 { 13065 if (TYPE_P (TYPE_CONTEXT (type))) 13066 context_die = force_type_die (TYPE_CONTEXT (type)); 13067 else 13068 context_die = force_decl_die (TYPE_CONTEXT (type)); 13069 } 13070 else 13071 context_die = comp_unit_die; 13072 13073 type_die = lookup_type_die (type); 13074 if (type_die) 13075 return type_die; 13076 gen_type_die (type, context_die); 13077 type_die = lookup_type_die (type); 13078 gcc_assert (type_die); 13079 } 13080 return type_die; 13081} 13082 13083/* Force out any required namespaces to be able to output DECL, 13084 and return the new context_die for it, if it's changed. */ 13085 13086static dw_die_ref 13087setup_namespace_context (tree thing, dw_die_ref context_die) 13088{ 13089 tree context = (DECL_P (thing) 13090 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing)); 13091 if (context && TREE_CODE (context) == NAMESPACE_DECL) 13092 /* Force out the namespace. */ 13093 context_die = force_decl_die (context); 13094 13095 return context_die; 13096} 13097 13098/* Emit a declaration DIE for THING (which is either a DECL or a tagged 13099 type) within its namespace, if appropriate. 13100 13101 For compatibility with older debuggers, namespace DIEs only contain 13102 declarations; all definitions are emitted at CU scope. */ 13103 13104static void 13105declare_in_namespace (tree thing, dw_die_ref context_die) 13106{ 13107 dw_die_ref ns_context; 13108 13109 if (debug_info_level <= DINFO_LEVEL_TERSE) 13110 return; 13111 13112 /* If this decl is from an inlined function, then don't try to emit it in its 13113 namespace, as we will get confused. It would have already been emitted 13114 when the abstract instance of the inline function was emitted anyways. */ 13115 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing)) 13116 return; 13117 13118 ns_context = setup_namespace_context (thing, context_die); 13119 13120 if (ns_context != context_die) 13121 { 13122 if (DECL_P (thing)) 13123 gen_decl_die (thing, ns_context); 13124 else 13125 gen_type_die (thing, ns_context); 13126 } 13127} 13128 13129/* Generate a DIE for a namespace or namespace alias. */ 13130 13131static void 13132gen_namespace_die (tree decl) 13133{ 13134 dw_die_ref context_die = setup_namespace_context (decl, comp_unit_die); 13135 13136 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace 13137 they are an alias of. */ 13138 if (DECL_ABSTRACT_ORIGIN (decl) == NULL) 13139 { 13140 /* Output a real namespace. */ 13141 dw_die_ref namespace_die 13142 = new_die (DW_TAG_namespace, context_die, decl); 13143 add_name_and_src_coords_attributes (namespace_die, decl); 13144 equate_decl_number_to_die (decl, namespace_die); 13145 } 13146 else 13147 { 13148 /* Output a namespace alias. */ 13149 13150 /* Force out the namespace we are an alias of, if necessary. */ 13151 dw_die_ref origin_die 13152 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl)); 13153 13154 /* Now create the namespace alias DIE. */ 13155 dw_die_ref namespace_die 13156 = new_die (DW_TAG_imported_declaration, context_die, decl); 13157 add_name_and_src_coords_attributes (namespace_die, decl); 13158 add_AT_die_ref (namespace_die, DW_AT_import, origin_die); 13159 equate_decl_number_to_die (decl, namespace_die); 13160 } 13161} 13162 13163/* Generate Dwarf debug information for a decl described by DECL. */ 13164 13165static void 13166gen_decl_die (tree decl, dw_die_ref context_die) 13167{ 13168 tree origin; 13169 13170 if (DECL_P (decl) && DECL_IGNORED_P (decl)) 13171 return; 13172 13173 switch (TREE_CODE (decl)) 13174 { 13175 case ERROR_MARK: 13176 break; 13177 13178 case CONST_DECL: 13179 /* The individual enumerators of an enum type get output when we output 13180 the Dwarf representation of the relevant enum type itself. */ 13181 break; 13182 13183 case FUNCTION_DECL: 13184 /* Don't output any DIEs to represent mere function declarations, 13185 unless they are class members or explicit block externs. */ 13186 if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE 13187 && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl))) 13188 break; 13189 13190#if 0 13191 /* FIXME */ 13192 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN 13193 on local redeclarations of global functions. That seems broken. */ 13194 if (current_function_decl != decl) 13195 /* This is only a declaration. */; 13196#endif 13197 13198 /* If we're emitting a clone, emit info for the abstract instance. */ 13199 if (DECL_ORIGIN (decl) != decl) 13200 dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl)); 13201 13202 /* If we're emitting an out-of-line copy of an inline function, 13203 emit info for the abstract instance and set up to refer to it. */ 13204 else if (cgraph_function_possibly_inlined_p (decl) 13205 && ! DECL_ABSTRACT (decl) 13206 && ! class_or_namespace_scope_p (context_die) 13207 /* dwarf2out_abstract_function won't emit a die if this is just 13208 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in 13209 that case, because that works only if we have a die. */ 13210 && DECL_INITIAL (decl) != NULL_TREE) 13211 { 13212 dwarf2out_abstract_function (decl); 13213 set_decl_origin_self (decl); 13214 } 13215 13216 /* Otherwise we're emitting the primary DIE for this decl. */ 13217 else if (debug_info_level > DINFO_LEVEL_TERSE) 13218 { 13219 /* Before we describe the FUNCTION_DECL itself, make sure that we 13220 have described its return type. */ 13221 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die); 13222 13223 /* And its virtual context. */ 13224 if (DECL_VINDEX (decl) != NULL_TREE) 13225 gen_type_die (DECL_CONTEXT (decl), context_die); 13226 13227 /* And its containing type. */ 13228 origin = decl_class_context (decl); 13229 if (origin != NULL_TREE) 13230 gen_type_die_for_member (origin, decl, context_die); 13231 13232 /* And its containing namespace. */ 13233 declare_in_namespace (decl, context_die); 13234 } 13235 13236 /* Now output a DIE to represent the function itself. */ 13237 gen_subprogram_die (decl, context_die); 13238 break; 13239 13240 case TYPE_DECL: 13241 /* If we are in terse mode, don't generate any DIEs to represent any 13242 actual typedefs. */ 13243 if (debug_info_level <= DINFO_LEVEL_TERSE) 13244 break; 13245 13246 /* In the special case of a TYPE_DECL node representing the declaration 13247 of some type tag, if the given TYPE_DECL is marked as having been 13248 instantiated from some other (original) TYPE_DECL node (e.g. one which 13249 was generated within the original definition of an inline function) we 13250 have to generate a special (abbreviated) DW_TAG_structure_type, 13251 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. */ 13252 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE 13253 && is_tagged_type (TREE_TYPE (decl))) 13254 { 13255 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die); 13256 break; 13257 } 13258 13259 if (is_redundant_typedef (decl)) 13260 gen_type_die (TREE_TYPE (decl), context_die); 13261 else 13262 /* Output a DIE to represent the typedef itself. */ 13263 gen_typedef_die (decl, context_die); 13264 break; 13265 13266 case LABEL_DECL: 13267 if (debug_info_level >= DINFO_LEVEL_NORMAL) 13268 gen_label_die (decl, context_die); 13269 break; 13270 13271 case VAR_DECL: 13272 case RESULT_DECL: 13273 /* If we are in terse mode, don't generate any DIEs to represent any 13274 variable declarations or definitions. */ 13275 if (debug_info_level <= DINFO_LEVEL_TERSE) 13276 break; 13277 13278 /* Output any DIEs that are needed to specify the type of this data 13279 object. */ 13280 gen_type_die (TREE_TYPE (decl), context_die); 13281 13282 /* And its containing type. */ 13283 origin = decl_class_context (decl); 13284 if (origin != NULL_TREE) 13285 gen_type_die_for_member (origin, decl, context_die); 13286 13287 /* And its containing namespace. */ 13288 declare_in_namespace (decl, context_die); 13289 13290 /* Now output the DIE to represent the data object itself. This gets 13291 complicated because of the possibility that the VAR_DECL really 13292 represents an inlined instance of a formal parameter for an inline 13293 function. */ 13294 origin = decl_ultimate_origin (decl); 13295 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL) 13296 gen_formal_parameter_die (decl, context_die); 13297 else 13298 gen_variable_die (decl, context_die); 13299 break; 13300 13301 case FIELD_DECL: 13302 /* Ignore the nameless fields that are used to skip bits but handle C++ 13303 anonymous unions and structs. */ 13304 if (DECL_NAME (decl) != NULL_TREE 13305 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE 13306 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE) 13307 { 13308 gen_type_die (member_declared_type (decl), context_die); 13309 gen_field_die (decl, context_die); 13310 } 13311 break; 13312 13313 case PARM_DECL: 13314 gen_type_die (TREE_TYPE (decl), context_die); 13315 gen_formal_parameter_die (decl, context_die); 13316 break; 13317 13318 case NAMESPACE_DECL: 13319 gen_namespace_die (decl); 13320 break; 13321 13322 default: 13323 /* Probably some frontend-internal decl. Assume we don't care. */ 13324 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES); 13325 break; 13326 } 13327} 13328 13329/* Output debug information for global decl DECL. Called from toplev.c after 13330 compilation proper has finished. */ 13331 13332static void 13333dwarf2out_global_decl (tree decl) 13334{ 13335 /* Output DWARF2 information for file-scope tentative data object 13336 declarations, file-scope (extern) function declarations (which had no 13337 corresponding body) and file-scope tagged type declarations and 13338 definitions which have not yet been forced out. */ 13339 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl)) 13340 dwarf2out_decl (decl); 13341} 13342 13343/* Output debug information for type decl DECL. Called from toplev.c 13344 and from language front ends (to record built-in types). */ 13345static void 13346dwarf2out_type_decl (tree decl, int local) 13347{ 13348 if (!local) 13349 dwarf2out_decl (decl); 13350} 13351 13352/* Output debug information for imported module or decl. */ 13353 13354static void 13355dwarf2out_imported_module_or_decl (tree decl, tree context) 13356{ 13357 dw_die_ref imported_die, at_import_die; 13358 dw_die_ref scope_die; 13359 expanded_location xloc; 13360 13361 if (debug_info_level <= DINFO_LEVEL_TERSE) 13362 return; 13363 13364 gcc_assert (decl); 13365 13366 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs. 13367 We need decl DIE for reference and scope die. First, get DIE for the decl 13368 itself. */ 13369 13370 /* Get the scope die for decl context. Use comp_unit_die for global module 13371 or decl. If die is not found for non globals, force new die. */ 13372 if (!context) 13373 scope_die = comp_unit_die; 13374 else if (TYPE_P (context)) 13375 { 13376 if (!should_emit_struct_debug (context, DINFO_USAGE_DIR_USE)) 13377 return; 13378 scope_die = force_type_die (context); 13379 } 13380 else 13381 scope_die = force_decl_die (context); 13382 13383 /* For TYPE_DECL or CONST_DECL, lookup TREE_TYPE. */ 13384 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL) 13385 { 13386 if (is_base_type (TREE_TYPE (decl))) 13387 at_import_die = base_type_die (TREE_TYPE (decl)); 13388 else 13389 at_import_die = force_type_die (TREE_TYPE (decl)); 13390 } 13391 else 13392 { 13393 at_import_die = lookup_decl_die (decl); 13394 if (!at_import_die) 13395 { 13396 /* If we're trying to avoid duplicate debug info, we may not have 13397 emitted the member decl for this field. Emit it now. */ 13398 if (TREE_CODE (decl) == FIELD_DECL) 13399 { 13400 tree type = DECL_CONTEXT (decl); 13401 dw_die_ref type_context_die; 13402 13403 if (TYPE_CONTEXT (type)) 13404 if (TYPE_P (TYPE_CONTEXT (type))) 13405 { 13406 if (!should_emit_struct_debug (TYPE_CONTEXT (type), 13407 DINFO_USAGE_DIR_USE)) 13408 return; 13409 type_context_die = force_type_die (TYPE_CONTEXT (type)); 13410 } 13411 else 13412 type_context_die = force_decl_die (TYPE_CONTEXT (type)); 13413 else 13414 type_context_die = comp_unit_die; 13415 gen_type_die_for_member (type, decl, type_context_die); 13416 } 13417 at_import_die = force_decl_die (decl); 13418 } 13419 } 13420 13421 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */ 13422 if (TREE_CODE (decl) == NAMESPACE_DECL) 13423 imported_die = new_die (DW_TAG_imported_module, scope_die, context); 13424 else 13425 imported_die = new_die (DW_TAG_imported_declaration, scope_die, context); 13426 13427 xloc = expand_location (input_location); 13428 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file)); 13429 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line); 13430 add_AT_die_ref (imported_die, DW_AT_import, at_import_die); 13431} 13432 13433/* Write the debugging output for DECL. */ 13434 13435void 13436dwarf2out_decl (tree decl) 13437{ 13438 dw_die_ref context_die = comp_unit_die; 13439 13440 switch (TREE_CODE (decl)) 13441 { 13442 case ERROR_MARK: 13443 return; 13444 13445 case FUNCTION_DECL: 13446 /* What we would really like to do here is to filter out all mere 13447 file-scope declarations of file-scope functions which are never 13448 referenced later within this translation unit (and keep all of ones 13449 that *are* referenced later on) but we aren't clairvoyant, so we have 13450 no idea which functions will be referenced in the future (i.e. later 13451 on within the current translation unit). So here we just ignore all 13452 file-scope function declarations which are not also definitions. If 13453 and when the debugger needs to know something about these functions, 13454 it will have to hunt around and find the DWARF information associated 13455 with the definition of the function. 13456 13457 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL 13458 nodes represent definitions and which ones represent mere 13459 declarations. We have to check DECL_INITIAL instead. That's because 13460 the C front-end supports some weird semantics for "extern inline" 13461 function definitions. These can get inlined within the current 13462 translation unit (and thus, we need to generate Dwarf info for their 13463 abstract instances so that the Dwarf info for the concrete inlined 13464 instances can have something to refer to) but the compiler never 13465 generates any out-of-lines instances of such things (despite the fact 13466 that they *are* definitions). 13467 13468 The important point is that the C front-end marks these "extern 13469 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for 13470 them anyway. Note that the C++ front-end also plays some similar games 13471 for inline function definitions appearing within include files which 13472 also contain `#pragma interface' pragmas. */ 13473 if (DECL_INITIAL (decl) == NULL_TREE) 13474 return; 13475 13476 /* If we're a nested function, initially use a parent of NULL; if we're 13477 a plain function, this will be fixed up in decls_for_scope. If 13478 we're a method, it will be ignored, since we already have a DIE. */ 13479 if (decl_function_context (decl) 13480 /* But if we're in terse mode, we don't care about scope. */ 13481 && debug_info_level > DINFO_LEVEL_TERSE) 13482 context_die = NULL; 13483 break; 13484 13485 case VAR_DECL: 13486 /* Ignore this VAR_DECL if it refers to a file-scope extern data object 13487 declaration and if the declaration was never even referenced from 13488 within this entire compilation unit. We suppress these DIEs in 13489 order to save space in the .debug section (by eliminating entries 13490 which are probably useless). Note that we must not suppress 13491 block-local extern declarations (whether used or not) because that 13492 would screw-up the debugger's name lookup mechanism and cause it to 13493 miss things which really ought to be in scope at a given point. */ 13494 if (DECL_EXTERNAL (decl) && !TREE_USED (decl)) 13495 return; 13496 13497 /* For local statics lookup proper context die. */ 13498 if (TREE_STATIC (decl) && decl_function_context (decl)) 13499 context_die = lookup_decl_die (DECL_CONTEXT (decl)); 13500 13501 /* If we are in terse mode, don't generate any DIEs to represent any 13502 variable declarations or definitions. */ 13503 if (debug_info_level <= DINFO_LEVEL_TERSE) 13504 return; 13505 break; 13506 13507 case NAMESPACE_DECL: 13508 if (debug_info_level <= DINFO_LEVEL_TERSE) 13509 return; 13510 if (lookup_decl_die (decl) != NULL) 13511 return; 13512 break; 13513 13514 case TYPE_DECL: 13515 /* Don't emit stubs for types unless they are needed by other DIEs. */ 13516 if (TYPE_DECL_SUPPRESS_DEBUG (decl)) 13517 return; 13518 13519 /* Don't bother trying to generate any DIEs to represent any of the 13520 normal built-in types for the language we are compiling. */ 13521 if (DECL_IS_BUILTIN (decl)) 13522 { 13523 /* OK, we need to generate one for `bool' so GDB knows what type 13524 comparisons have. */ 13525 if (is_cxx () 13526 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE 13527 && ! DECL_IGNORED_P (decl)) 13528 modified_type_die (TREE_TYPE (decl), 0, 0, NULL); 13529 13530 return; 13531 } 13532 13533 /* If we are in terse mode, don't generate any DIEs for types. */ 13534 if (debug_info_level <= DINFO_LEVEL_TERSE) 13535 return; 13536 13537 /* If we're a function-scope tag, initially use a parent of NULL; 13538 this will be fixed up in decls_for_scope. */ 13539 if (decl_function_context (decl)) 13540 context_die = NULL; 13541 13542 break; 13543 13544 default: 13545 return; 13546 } 13547 13548 gen_decl_die (decl, context_die); 13549} 13550 13551/* Output a marker (i.e. a label) for the beginning of the generated code for 13552 a lexical block. */ 13553 13554static void 13555dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED, 13556 unsigned int blocknum) 13557{ 13558 switch_to_section (current_function_section ()); 13559 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum); 13560} 13561 13562/* Output a marker (i.e. a label) for the end of the generated code for a 13563 lexical block. */ 13564 13565static void 13566dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum) 13567{ 13568 switch_to_section (current_function_section ()); 13569 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum); 13570} 13571 13572/* Returns nonzero if it is appropriate not to emit any debugging 13573 information for BLOCK, because it doesn't contain any instructions. 13574 13575 Don't allow this for blocks with nested functions or local classes 13576 as we would end up with orphans, and in the presence of scheduling 13577 we may end up calling them anyway. */ 13578 13579static bool 13580dwarf2out_ignore_block (tree block) 13581{ 13582 tree decl; 13583 13584 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl)) 13585 if (TREE_CODE (decl) == FUNCTION_DECL 13586 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))) 13587 return 0; 13588 13589 return 1; 13590} 13591 13592/* Hash table routines for file_hash. */ 13593 13594static int 13595file_table_eq (const void *p1_p, const void *p2_p) 13596{ 13597 const struct dwarf_file_data * p1 = p1_p; 13598 const char * p2 = p2_p; 13599 return strcmp (p1->filename, p2) == 0; 13600} 13601 13602static hashval_t 13603file_table_hash (const void *p_p) 13604{ 13605 const struct dwarf_file_data * p = p_p; 13606 return htab_hash_string (p->filename); 13607} 13608 13609/* Lookup FILE_NAME (in the list of filenames that we know about here in 13610 dwarf2out.c) and return its "index". The index of each (known) filename is 13611 just a unique number which is associated with only that one filename. We 13612 need such numbers for the sake of generating labels (in the .debug_sfnames 13613 section) and references to those files numbers (in the .debug_srcinfo 13614 and.debug_macinfo sections). If the filename given as an argument is not 13615 found in our current list, add it to the list and assign it the next 13616 available unique index number. In order to speed up searches, we remember 13617 the index of the filename was looked up last. This handles the majority of 13618 all searches. */ 13619 13620static struct dwarf_file_data * 13621lookup_filename (const char *file_name) 13622{ 13623 void ** slot; 13624 struct dwarf_file_data * created; 13625 13626 /* Check to see if the file name that was searched on the previous 13627 call matches this file name. If so, return the index. */ 13628 if (file_table_last_lookup 13629 && (file_name == file_table_last_lookup->filename 13630 || strcmp (file_table_last_lookup->filename, file_name) == 0)) 13631 return file_table_last_lookup; 13632 13633 /* Didn't match the previous lookup, search the table. */ 13634 slot = htab_find_slot_with_hash (file_table, file_name, 13635 htab_hash_string (file_name), INSERT); 13636 if (*slot) 13637 return *slot; 13638 13639 created = ggc_alloc (sizeof (struct dwarf_file_data)); 13640 created->filename = file_name; 13641 created->emitted_number = 0; 13642 *slot = created; 13643 return created; 13644} 13645 13646/* If the assembler will construct the file table, then translate the compiler 13647 internal file table number into the assembler file table number, and emit 13648 a .file directive if we haven't already emitted one yet. The file table 13649 numbers are different because we prune debug info for unused variables and 13650 types, which may include filenames. */ 13651 13652static int 13653maybe_emit_file (struct dwarf_file_data * fd) 13654{ 13655 if (! fd->emitted_number) 13656 { 13657 if (last_emitted_file) 13658 fd->emitted_number = last_emitted_file->emitted_number + 1; 13659 else 13660 fd->emitted_number = 1; 13661 last_emitted_file = fd; 13662 13663 if (DWARF2_ASM_LINE_DEBUG_INFO) 13664 { 13665 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number); 13666 output_quoted_string (asm_out_file, fd->filename); 13667 fputc ('\n', asm_out_file); 13668 } 13669 } 13670 13671 return fd->emitted_number; 13672} 13673 13674/* Called by the final INSN scan whenever we see a var location. We 13675 use it to drop labels in the right places, and throw the location in 13676 our lookup table. */ 13677 13678static void 13679dwarf2out_var_location (rtx loc_note) 13680{ 13681 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES]; 13682 struct var_loc_node *newloc; 13683 rtx prev_insn; 13684 static rtx last_insn; 13685 static const char *last_label; 13686 tree decl; 13687 13688 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note))) 13689 return; 13690 prev_insn = PREV_INSN (loc_note); 13691 13692 newloc = ggc_alloc_cleared (sizeof (struct var_loc_node)); 13693 /* If the insn we processed last time is the previous insn 13694 and it is also a var location note, use the label we emitted 13695 last time. */ 13696 if (last_insn != NULL_RTX 13697 && last_insn == prev_insn 13698 && NOTE_P (prev_insn) 13699 && NOTE_LINE_NUMBER (prev_insn) == NOTE_INSN_VAR_LOCATION) 13700 { 13701 newloc->label = last_label; 13702 } 13703 else 13704 { 13705 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num); 13706 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num); 13707 loclabel_num++; 13708 newloc->label = ggc_strdup (loclabel); 13709 } 13710 newloc->var_loc_note = loc_note; 13711 newloc->next = NULL; 13712 13713 if (cfun && in_cold_section_p) 13714 newloc->section_label = cfun->cold_section_label; 13715 else 13716 newloc->section_label = text_section_label; 13717 13718 last_insn = loc_note; 13719 last_label = newloc->label; 13720 decl = NOTE_VAR_LOCATION_DECL (loc_note); 13721 add_var_loc_to_decl (decl, newloc); 13722} 13723 13724/* We need to reset the locations at the beginning of each 13725 function. We can't do this in the end_function hook, because the 13726 declarations that use the locations won't have been output when 13727 that hook is called. Also compute have_multiple_function_sections here. */ 13728 13729static void 13730dwarf2out_begin_function (tree fun) 13731{ 13732 htab_empty (decl_loc_table); 13733 13734 if (function_section (fun) != text_section) 13735 have_multiple_function_sections = true; 13736} 13737 13738/* Output a label to mark the beginning of a source code line entry 13739 and record information relating to this source line, in 13740 'line_info_table' for later output of the .debug_line section. */ 13741 13742static void 13743dwarf2out_source_line (unsigned int line, const char *filename) 13744{ 13745 if (debug_info_level >= DINFO_LEVEL_NORMAL 13746 && line != 0) 13747 { 13748 int file_num = maybe_emit_file (lookup_filename (filename)); 13749 13750 switch_to_section (current_function_section ()); 13751 13752 /* If requested, emit something human-readable. */ 13753 if (flag_debug_asm) 13754 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START, 13755 filename, line); 13756 13757 if (DWARF2_ASM_LINE_DEBUG_INFO) 13758 { 13759 /* Emit the .loc directive understood by GNU as. */ 13760 fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line); 13761 13762 /* Indicate that line number info exists. */ 13763 line_info_table_in_use++; 13764 } 13765 else if (function_section (current_function_decl) != text_section) 13766 { 13767 dw_separate_line_info_ref line_info; 13768 targetm.asm_out.internal_label (asm_out_file, 13769 SEPARATE_LINE_CODE_LABEL, 13770 separate_line_info_table_in_use); 13771 13772 /* Expand the line info table if necessary. */ 13773 if (separate_line_info_table_in_use 13774 == separate_line_info_table_allocated) 13775 { 13776 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT; 13777 separate_line_info_table 13778 = ggc_realloc (separate_line_info_table, 13779 separate_line_info_table_allocated 13780 * sizeof (dw_separate_line_info_entry)); 13781 memset (separate_line_info_table 13782 + separate_line_info_table_in_use, 13783 0, 13784 (LINE_INFO_TABLE_INCREMENT 13785 * sizeof (dw_separate_line_info_entry))); 13786 } 13787 13788 /* Add the new entry at the end of the line_info_table. */ 13789 line_info 13790 = &separate_line_info_table[separate_line_info_table_in_use++]; 13791 line_info->dw_file_num = file_num; 13792 line_info->dw_line_num = line; 13793 line_info->function = current_function_funcdef_no; 13794 } 13795 else 13796 { 13797 dw_line_info_ref line_info; 13798 13799 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL, 13800 line_info_table_in_use); 13801 13802 /* Expand the line info table if necessary. */ 13803 if (line_info_table_in_use == line_info_table_allocated) 13804 { 13805 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT; 13806 line_info_table 13807 = ggc_realloc (line_info_table, 13808 (line_info_table_allocated 13809 * sizeof (dw_line_info_entry))); 13810 memset (line_info_table + line_info_table_in_use, 0, 13811 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry)); 13812 } 13813 13814 /* Add the new entry at the end of the line_info_table. */ 13815 line_info = &line_info_table[line_info_table_in_use++]; 13816 line_info->dw_file_num = file_num; 13817 line_info->dw_line_num = line; 13818 } 13819 } 13820} 13821 13822/* Record the beginning of a new source file. */ 13823 13824static void 13825dwarf2out_start_source_file (unsigned int lineno, const char *filename) 13826{ 13827 if (flag_eliminate_dwarf2_dups) 13828 { 13829 /* Record the beginning of the file for break_out_includes. */ 13830 dw_die_ref bincl_die; 13831 13832 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL); 13833 add_AT_string (bincl_die, DW_AT_name, filename); 13834 } 13835 13836 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 13837 { 13838 int file_num = maybe_emit_file (lookup_filename (filename)); 13839 13840 switch_to_section (debug_macinfo_section); 13841 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file"); 13842 dw2_asm_output_data_uleb128 (lineno, "Included from line number %d", 13843 lineno); 13844 13845 dw2_asm_output_data_uleb128 (file_num, "file %s", filename); 13846 } 13847} 13848 13849/* Record the end of a source file. */ 13850 13851static void 13852dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED) 13853{ 13854 if (flag_eliminate_dwarf2_dups) 13855 /* Record the end of the file for break_out_includes. */ 13856 new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL); 13857 13858 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 13859 { 13860 switch_to_section (debug_macinfo_section); 13861 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file"); 13862 } 13863} 13864 13865/* Called from debug_define in toplev.c. The `buffer' parameter contains 13866 the tail part of the directive line, i.e. the part which is past the 13867 initial whitespace, #, whitespace, directive-name, whitespace part. */ 13868 13869static void 13870dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED, 13871 const char *buffer ATTRIBUTE_UNUSED) 13872{ 13873 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 13874 { 13875 switch_to_section (debug_macinfo_section); 13876 dw2_asm_output_data (1, DW_MACINFO_define, "Define macro"); 13877 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno); 13878 dw2_asm_output_nstring (buffer, -1, "The macro"); 13879 } 13880} 13881 13882/* Called from debug_undef in toplev.c. The `buffer' parameter contains 13883 the tail part of the directive line, i.e. the part which is past the 13884 initial whitespace, #, whitespace, directive-name, whitespace part. */ 13885 13886static void 13887dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED, 13888 const char *buffer ATTRIBUTE_UNUSED) 13889{ 13890 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 13891 { 13892 switch_to_section (debug_macinfo_section); 13893 dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro"); 13894 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno); 13895 dw2_asm_output_nstring (buffer, -1, "The macro"); 13896 } 13897} 13898 13899/* Set up for Dwarf output at the start of compilation. */ 13900 13901static void 13902dwarf2out_init (const char *filename ATTRIBUTE_UNUSED) 13903{ 13904 /* Allocate the file_table. */ 13905 file_table = htab_create_ggc (50, file_table_hash, 13906 file_table_eq, NULL); 13907 13908 /* Allocate the decl_die_table. */ 13909 decl_die_table = htab_create_ggc (10, decl_die_table_hash, 13910 decl_die_table_eq, NULL); 13911 13912 /* Allocate the decl_loc_table. */ 13913 decl_loc_table = htab_create_ggc (10, decl_loc_table_hash, 13914 decl_loc_table_eq, NULL); 13915 13916 /* Allocate the initial hunk of the decl_scope_table. */ 13917 decl_scope_table = VEC_alloc (tree, gc, 256); 13918 13919 /* Allocate the initial hunk of the abbrev_die_table. */ 13920 abbrev_die_table = ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT 13921 * sizeof (dw_die_ref)); 13922 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT; 13923 /* Zero-th entry is allocated, but unused. */ 13924 abbrev_die_table_in_use = 1; 13925 13926 /* Allocate the initial hunk of the line_info_table. */ 13927 line_info_table = ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT 13928 * sizeof (dw_line_info_entry)); 13929 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT; 13930 13931 /* Zero-th entry is allocated, but unused. */ 13932 line_info_table_in_use = 1; 13933 13934 /* Generate the initial DIE for the .debug section. Note that the (string) 13935 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE 13936 will (typically) be a relative pathname and that this pathname should be 13937 taken as being relative to the directory from which the compiler was 13938 invoked when the given (base) source file was compiled. We will fill 13939 in this value in dwarf2out_finish. */ 13940 comp_unit_die = gen_compile_unit_die (NULL); 13941 13942 incomplete_types = VEC_alloc (tree, gc, 64); 13943 13944 used_rtx_array = VEC_alloc (rtx, gc, 32); 13945 13946 debug_info_section = get_section (DEBUG_INFO_SECTION, 13947 SECTION_DEBUG, NULL); 13948 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION, 13949 SECTION_DEBUG, NULL); 13950 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION, 13951 SECTION_DEBUG, NULL); 13952 debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION, 13953 SECTION_DEBUG, NULL); 13954 debug_line_section = get_section (DEBUG_LINE_SECTION, 13955 SECTION_DEBUG, NULL); 13956 debug_loc_section = get_section (DEBUG_LOC_SECTION, 13957 SECTION_DEBUG, NULL); 13958 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION, 13959 SECTION_DEBUG, NULL); 13960 debug_str_section = get_section (DEBUG_STR_SECTION, 13961 DEBUG_STR_SECTION_FLAGS, NULL); 13962 debug_ranges_section = get_section (DEBUG_RANGES_SECTION, 13963 SECTION_DEBUG, NULL); 13964 debug_frame_section = get_section (DEBUG_FRAME_SECTION, 13965 SECTION_DEBUG, NULL); 13966 13967 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0); 13968 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label, 13969 DEBUG_ABBREV_SECTION_LABEL, 0); 13970 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0); 13971 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label, 13972 COLD_TEXT_SECTION_LABEL, 0); 13973 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0); 13974 13975 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label, 13976 DEBUG_INFO_SECTION_LABEL, 0); 13977 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label, 13978 DEBUG_LINE_SECTION_LABEL, 0); 13979 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label, 13980 DEBUG_RANGES_SECTION_LABEL, 0); 13981 switch_to_section (debug_abbrev_section); 13982 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label); 13983 switch_to_section (debug_info_section); 13984 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label); 13985 switch_to_section (debug_line_section); 13986 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label); 13987 13988 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 13989 { 13990 switch_to_section (debug_macinfo_section); 13991 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label, 13992 DEBUG_MACINFO_SECTION_LABEL, 0); 13993 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label); 13994 } 13995 13996 switch_to_section (text_section); 13997 ASM_OUTPUT_LABEL (asm_out_file, text_section_label); 13998 if (flag_reorder_blocks_and_partition) 13999 { 14000 switch_to_section (unlikely_text_section ()); 14001 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label); 14002 } 14003} 14004 14005/* A helper function for dwarf2out_finish called through 14006 ht_forall. Emit one queued .debug_str string. */ 14007 14008static int 14009output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED) 14010{ 14011 struct indirect_string_node *node = (struct indirect_string_node *) *h; 14012 14013 if (node->form == DW_FORM_strp) 14014 { 14015 switch_to_section (debug_str_section); 14016 ASM_OUTPUT_LABEL (asm_out_file, node->label); 14017 assemble_string (node->str, strlen (node->str) + 1); 14018 } 14019 14020 return 1; 14021} 14022 14023#if ENABLE_ASSERT_CHECKING 14024/* Verify that all marks are clear. */ 14025 14026static void 14027verify_marks_clear (dw_die_ref die) 14028{ 14029 dw_die_ref c; 14030 14031 gcc_assert (! die->die_mark); 14032 FOR_EACH_CHILD (die, c, verify_marks_clear (c)); 14033} 14034#endif /* ENABLE_ASSERT_CHECKING */ 14035 14036/* Clear the marks for a die and its children. 14037 Be cool if the mark isn't set. */ 14038 14039static void 14040prune_unmark_dies (dw_die_ref die) 14041{ 14042 dw_die_ref c; 14043 14044 if (die->die_mark) 14045 die->die_mark = 0; 14046 FOR_EACH_CHILD (die, c, prune_unmark_dies (c)); 14047} 14048 14049/* Given DIE that we're marking as used, find any other dies 14050 it references as attributes and mark them as used. */ 14051 14052static void 14053prune_unused_types_walk_attribs (dw_die_ref die) 14054{ 14055 dw_attr_ref a; 14056 unsigned ix; 14057 14058 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 14059 { 14060 if (a->dw_attr_val.val_class == dw_val_class_die_ref) 14061 { 14062 /* A reference to another DIE. 14063 Make sure that it will get emitted. */ 14064 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1); 14065 } 14066 /* Set the string's refcount to 0 so that prune_unused_types_mark 14067 accounts properly for it. */ 14068 if (AT_class (a) == dw_val_class_str) 14069 a->dw_attr_val.v.val_str->refcount = 0; 14070 } 14071} 14072 14073 14074/* Mark DIE as being used. If DOKIDS is true, then walk down 14075 to DIE's children. */ 14076 14077static void 14078prune_unused_types_mark (dw_die_ref die, int dokids) 14079{ 14080 dw_die_ref c; 14081 14082 if (die->die_mark == 0) 14083 { 14084 /* We haven't done this node yet. Mark it as used. */ 14085 die->die_mark = 1; 14086 14087 /* We also have to mark its parents as used. 14088 (But we don't want to mark our parents' kids due to this.) */ 14089 if (die->die_parent) 14090 prune_unused_types_mark (die->die_parent, 0); 14091 14092 /* Mark any referenced nodes. */ 14093 prune_unused_types_walk_attribs (die); 14094 14095 /* If this node is a specification, 14096 also mark the definition, if it exists. */ 14097 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition) 14098 prune_unused_types_mark (die->die_definition, 1); 14099 } 14100 14101 if (dokids && die->die_mark != 2) 14102 { 14103 /* We need to walk the children, but haven't done so yet. 14104 Remember that we've walked the kids. */ 14105 die->die_mark = 2; 14106 14107 /* If this is an array type, we need to make sure our 14108 kids get marked, even if they're types. */ 14109 if (die->die_tag == DW_TAG_array_type) 14110 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1)); 14111 else 14112 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c)); 14113 } 14114} 14115 14116 14117/* Walk the tree DIE and mark types that we actually use. */ 14118 14119static void 14120prune_unused_types_walk (dw_die_ref die) 14121{ 14122 dw_die_ref c; 14123 14124 /* Don't do anything if this node is already marked. */ 14125 if (die->die_mark) 14126 return; 14127 14128 switch (die->die_tag) { 14129 case DW_TAG_const_type: 14130 case DW_TAG_packed_type: 14131 case DW_TAG_pointer_type: 14132 case DW_TAG_reference_type: 14133 case DW_TAG_volatile_type: 14134 case DW_TAG_typedef: 14135 case DW_TAG_array_type: 14136 case DW_TAG_structure_type: 14137 case DW_TAG_union_type: 14138 case DW_TAG_class_type: 14139 case DW_TAG_friend: 14140 case DW_TAG_variant_part: 14141 case DW_TAG_enumeration_type: 14142 case DW_TAG_subroutine_type: 14143 case DW_TAG_string_type: 14144 case DW_TAG_set_type: 14145 case DW_TAG_subrange_type: 14146 case DW_TAG_ptr_to_member_type: 14147 case DW_TAG_file_type: 14148 if (die->die_perennial_p) 14149 break; 14150 14151 /* It's a type node --- don't mark it. */ 14152 return; 14153 14154 default: 14155 /* Mark everything else. */ 14156 break; 14157 } 14158 14159 die->die_mark = 1; 14160 14161 /* Now, mark any dies referenced from here. */ 14162 prune_unused_types_walk_attribs (die); 14163 14164 /* Mark children. */ 14165 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c)); 14166} 14167 14168/* Increment the string counts on strings referred to from DIE's 14169 attributes. */ 14170 14171static void 14172prune_unused_types_update_strings (dw_die_ref die) 14173{ 14174 dw_attr_ref a; 14175 unsigned ix; 14176 14177 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 14178 if (AT_class (a) == dw_val_class_str) 14179 { 14180 struct indirect_string_node *s = a->dw_attr_val.v.val_str; 14181 s->refcount++; 14182 /* Avoid unnecessarily putting strings that are used less than 14183 twice in the hash table. */ 14184 if (s->refcount 14185 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2)) 14186 { 14187 void ** slot; 14188 slot = htab_find_slot_with_hash (debug_str_hash, s->str, 14189 htab_hash_string (s->str), 14190 INSERT); 14191 gcc_assert (*slot == NULL); 14192 *slot = s; 14193 } 14194 } 14195} 14196 14197/* Remove from the tree DIE any dies that aren't marked. */ 14198 14199static void 14200prune_unused_types_prune (dw_die_ref die) 14201{ 14202 dw_die_ref c; 14203 14204 gcc_assert (die->die_mark); 14205 prune_unused_types_update_strings (die); 14206 14207 if (! die->die_child) 14208 return; 14209 14210 c = die->die_child; 14211 do { 14212 dw_die_ref prev = c; 14213 for (c = c->die_sib; ! c->die_mark; c = c->die_sib) 14214 if (c == die->die_child) 14215 { 14216 /* No marked children between 'prev' and the end of the list. */ 14217 if (prev == c) 14218 /* No marked children at all. */ 14219 die->die_child = NULL; 14220 else 14221 { 14222 prev->die_sib = c->die_sib; 14223 die->die_child = prev; 14224 } 14225 return; 14226 } 14227 14228 if (c != prev->die_sib) 14229 prev->die_sib = c; 14230 prune_unused_types_prune (c); 14231 } while (c != die->die_child); 14232} 14233 14234 14235/* Remove dies representing declarations that we never use. */ 14236 14237static void 14238prune_unused_types (void) 14239{ 14240 unsigned int i; 14241 limbo_die_node *node; 14242 14243#if ENABLE_ASSERT_CHECKING 14244 /* All the marks should already be clear. */ 14245 verify_marks_clear (comp_unit_die); 14246 for (node = limbo_die_list; node; node = node->next) 14247 verify_marks_clear (node->die); 14248#endif /* ENABLE_ASSERT_CHECKING */ 14249 14250 /* Set the mark on nodes that are actually used. */ 14251 prune_unused_types_walk (comp_unit_die); 14252 for (node = limbo_die_list; node; node = node->next) 14253 prune_unused_types_walk (node->die); 14254 14255 /* Also set the mark on nodes referenced from the 14256 pubname_table or arange_table. */ 14257 for (i = 0; i < pubname_table_in_use; i++) 14258 prune_unused_types_mark (pubname_table[i].die, 1); 14259 for (i = 0; i < arange_table_in_use; i++) 14260 prune_unused_types_mark (arange_table[i], 1); 14261 14262 /* Get rid of nodes that aren't marked; and update the string counts. */ 14263 if (debug_str_hash) 14264 htab_empty (debug_str_hash); 14265 prune_unused_types_prune (comp_unit_die); 14266 for (node = limbo_die_list; node; node = node->next) 14267 prune_unused_types_prune (node->die); 14268 14269 /* Leave the marks clear. */ 14270 prune_unmark_dies (comp_unit_die); 14271 for (node = limbo_die_list; node; node = node->next) 14272 prune_unmark_dies (node->die); 14273} 14274 14275/* Set the parameter to true if there are any relative pathnames in 14276 the file table. */ 14277static int 14278file_table_relative_p (void ** slot, void *param) 14279{ 14280 bool *p = param; 14281 struct dwarf_file_data *d = *slot; 14282 if (d->emitted_number && d->filename[0] != DIR_SEPARATOR) 14283 { 14284 *p = true; 14285 return 0; 14286 } 14287 return 1; 14288} 14289 14290/* Output stuff that dwarf requires at the end of every file, 14291 and generate the DWARF-2 debugging info. */ 14292 14293static void 14294dwarf2out_finish (const char *filename) 14295{ 14296 limbo_die_node *node, *next_node; 14297 dw_die_ref die = 0; 14298 14299 /* Add the name for the main input file now. We delayed this from 14300 dwarf2out_init to avoid complications with PCH. */ 14301 add_name_attribute (comp_unit_die, filename); 14302 if (filename[0] != DIR_SEPARATOR) 14303 add_comp_dir_attribute (comp_unit_die); 14304 else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL) 14305 { 14306 bool p = false; 14307 htab_traverse (file_table, file_table_relative_p, &p); 14308 if (p) 14309 add_comp_dir_attribute (comp_unit_die); 14310 } 14311 14312 /* Traverse the limbo die list, and add parent/child links. The only 14313 dies without parents that should be here are concrete instances of 14314 inline functions, and the comp_unit_die. We can ignore the comp_unit_die. 14315 For concrete instances, we can get the parent die from the abstract 14316 instance. */ 14317 for (node = limbo_die_list; node; node = next_node) 14318 { 14319 next_node = node->next; 14320 die = node->die; 14321 14322 if (die->die_parent == NULL) 14323 { 14324 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin); 14325 14326 if (origin) 14327 add_child_die (origin->die_parent, die); 14328 else if (die == comp_unit_die) 14329 ; 14330 else if (errorcount > 0 || sorrycount > 0) 14331 /* It's OK to be confused by errors in the input. */ 14332 add_child_die (comp_unit_die, die); 14333 else 14334 { 14335 /* In certain situations, the lexical block containing a 14336 nested function can be optimized away, which results 14337 in the nested function die being orphaned. Likewise 14338 with the return type of that nested function. Force 14339 this to be a child of the containing function. 14340 14341 It may happen that even the containing function got fully 14342 inlined and optimized out. In that case we are lost and 14343 assign the empty child. This should not be big issue as 14344 the function is likely unreachable too. */ 14345 tree context = NULL_TREE; 14346 14347 gcc_assert (node->created_for); 14348 14349 if (DECL_P (node->created_for)) 14350 context = DECL_CONTEXT (node->created_for); 14351 else if (TYPE_P (node->created_for)) 14352 context = TYPE_CONTEXT (node->created_for); 14353 14354 gcc_assert (context 14355 && (TREE_CODE (context) == FUNCTION_DECL 14356 || TREE_CODE (context) == NAMESPACE_DECL)); 14357 14358 origin = lookup_decl_die (context); 14359 if (origin) 14360 add_child_die (origin, die); 14361 else 14362 add_child_die (comp_unit_die, die); 14363 } 14364 } 14365 } 14366 14367 limbo_die_list = NULL; 14368 14369 /* Walk through the list of incomplete types again, trying once more to 14370 emit full debugging info for them. */ 14371 retry_incomplete_types (); 14372 14373 if (flag_eliminate_unused_debug_types) 14374 prune_unused_types (); 14375 14376 /* Generate separate CUs for each of the include files we've seen. 14377 They will go into limbo_die_list. */ 14378 if (flag_eliminate_dwarf2_dups) 14379 break_out_includes (comp_unit_die); 14380 14381 /* Traverse the DIE's and add add sibling attributes to those DIE's 14382 that have children. */ 14383 add_sibling_attributes (comp_unit_die); 14384 for (node = limbo_die_list; node; node = node->next) 14385 add_sibling_attributes (node->die); 14386 14387 /* Output a terminator label for the .text section. */ 14388 switch_to_section (text_section); 14389 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0); 14390 if (flag_reorder_blocks_and_partition) 14391 { 14392 switch_to_section (unlikely_text_section ()); 14393 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0); 14394 } 14395 14396 /* We can only use the low/high_pc attributes if all of the code was 14397 in .text. */ 14398 if (!have_multiple_function_sections) 14399 { 14400 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label); 14401 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label); 14402 } 14403 14404 /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate 14405 "base address". Use zero so that these addresses become absolute. */ 14406 else if (have_location_lists || ranges_table_in_use) 14407 add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx); 14408 14409 /* Output location list section if necessary. */ 14410 if (have_location_lists) 14411 { 14412 /* Output the location lists info. */ 14413 switch_to_section (debug_loc_section); 14414 ASM_GENERATE_INTERNAL_LABEL (loc_section_label, 14415 DEBUG_LOC_SECTION_LABEL, 0); 14416 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label); 14417 output_location_lists (die); 14418 } 14419 14420 if (debug_info_level >= DINFO_LEVEL_NORMAL) 14421 add_AT_lineptr (comp_unit_die, DW_AT_stmt_list, 14422 debug_line_section_label); 14423 14424 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 14425 add_AT_macptr (comp_unit_die, DW_AT_macro_info, macinfo_section_label); 14426 14427 /* Output all of the compilation units. We put the main one last so that 14428 the offsets are available to output_pubnames. */ 14429 for (node = limbo_die_list; node; node = node->next) 14430 output_comp_unit (node->die, 0); 14431 14432 output_comp_unit (comp_unit_die, 0); 14433 14434 /* Output the abbreviation table. */ 14435 switch_to_section (debug_abbrev_section); 14436 output_abbrev_section (); 14437 14438 /* Output public names table if necessary. */ 14439 if (pubname_table_in_use) 14440 { 14441 switch_to_section (debug_pubnames_section); 14442 output_pubnames (); 14443 } 14444 14445 /* Output the address range information. We only put functions in the arange 14446 table, so don't write it out if we don't have any. */ 14447 if (fde_table_in_use) 14448 { 14449 switch_to_section (debug_aranges_section); 14450 output_aranges (); 14451 } 14452 14453 /* Output ranges section if necessary. */ 14454 if (ranges_table_in_use) 14455 { 14456 switch_to_section (debug_ranges_section); 14457 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label); 14458 output_ranges (); 14459 } 14460 14461 /* Output the source line correspondence table. We must do this 14462 even if there is no line information. Otherwise, on an empty 14463 translation unit, we will generate a present, but empty, 14464 .debug_info section. IRIX 6.5 `nm' will then complain when 14465 examining the file. This is done late so that any filenames 14466 used by the debug_info section are marked as 'used'. */ 14467 if (! DWARF2_ASM_LINE_DEBUG_INFO) 14468 { 14469 switch_to_section (debug_line_section); 14470 output_line_info (); 14471 } 14472 14473 /* Have to end the macro section. */ 14474 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 14475 { 14476 switch_to_section (debug_macinfo_section); 14477 dw2_asm_output_data (1, 0, "End compilation unit"); 14478 } 14479 14480 /* If we emitted any DW_FORM_strp form attribute, output the string 14481 table too. */ 14482 if (debug_str_hash) 14483 htab_traverse (debug_str_hash, output_indirect_string, NULL); 14484} 14485#else 14486 14487/* This should never be used, but its address is needed for comparisons. */ 14488const struct gcc_debug_hooks dwarf2_debug_hooks; 14489 14490#endif /* DWARF2_DEBUGGING_INFO */ 14491 14492#include "gt-dwarf2out.h" 14493