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_pubtypes_section; 160static GTY(()) section *debug_str_section; 161static GTY(()) section *debug_ranges_section; 162static GTY(()) section *debug_frame_section; 163 164/* How to start an assembler comment. */ 165#ifndef ASM_COMMENT_START 166#define ASM_COMMENT_START ";#" 167#endif 168 169typedef struct dw_cfi_struct *dw_cfi_ref; 170typedef struct dw_fde_struct *dw_fde_ref; 171typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref; 172 173/* Call frames are described using a sequence of Call Frame 174 Information instructions. The register number, offset 175 and address fields are provided as possible operands; 176 their use is selected by the opcode field. */ 177 178enum dw_cfi_oprnd_type { 179 dw_cfi_oprnd_unused, 180 dw_cfi_oprnd_reg_num, 181 dw_cfi_oprnd_offset, 182 dw_cfi_oprnd_addr, 183 dw_cfi_oprnd_loc 184}; 185 186typedef union dw_cfi_oprnd_struct GTY(()) 187{ 188 unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num; 189 HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset; 190 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr; 191 struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc; 192} 193dw_cfi_oprnd; 194 195typedef struct dw_cfi_struct GTY(()) 196{ 197 dw_cfi_ref dw_cfi_next; 198 enum dwarf_call_frame_info dw_cfi_opc; 199 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)"))) 200 dw_cfi_oprnd1; 201 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)"))) 202 dw_cfi_oprnd2; 203} 204dw_cfi_node; 205 206/* This is how we define the location of the CFA. We use to handle it 207 as REG + OFFSET all the time, but now it can be more complex. 208 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET. 209 Instead of passing around REG and OFFSET, we pass a copy 210 of this structure. */ 211typedef struct cfa_loc GTY(()) 212{ 213 HOST_WIDE_INT offset; 214 HOST_WIDE_INT base_offset; 215 unsigned int reg; 216 int indirect; /* 1 if CFA is accessed via a dereference. */ 217} dw_cfa_location; 218 219/* All call frame descriptions (FDE's) in the GCC generated DWARF 220 refer to a single Common Information Entry (CIE), defined at 221 the beginning of the .debug_frame section. This use of a single 222 CIE obviates the need to keep track of multiple CIE's 223 in the DWARF generation routines below. */ 224 225typedef struct dw_fde_struct GTY(()) 226{ 227 tree decl; 228 const char *dw_fde_begin; 229 const char *dw_fde_current_label; 230 const char *dw_fde_end; 231 const char *dw_fde_hot_section_label; 232 const char *dw_fde_hot_section_end_label; 233 const char *dw_fde_unlikely_section_label; 234 const char *dw_fde_unlikely_section_end_label; 235 bool dw_fde_switched_sections; 236 dw_cfi_ref dw_fde_cfi; 237 unsigned funcdef_number; 238 unsigned all_throwers_are_sibcalls : 1; 239 unsigned nothrow : 1; 240 unsigned uses_eh_lsda : 1; 241} 242dw_fde_node; 243 244/* Maximum size (in bytes) of an artificially generated label. */ 245#define MAX_ARTIFICIAL_LABEL_BYTES 30 246 247/* The size of addresses as they appear in the Dwarf 2 data. 248 Some architectures use word addresses to refer to code locations, 249 but Dwarf 2 info always uses byte addresses. On such machines, 250 Dwarf 2 addresses need to be larger than the architecture's 251 pointers. */ 252#ifndef DWARF2_ADDR_SIZE 253#define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT) 254#endif 255 256/* The size in bytes of a DWARF field indicating an offset or length 257 relative to a debug info section, specified to be 4 bytes in the 258 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same 259 as PTR_SIZE. */ 260 261#ifndef DWARF_OFFSET_SIZE 262#define DWARF_OFFSET_SIZE 4 263#endif 264 265/* According to the (draft) DWARF 3 specification, the initial length 266 should either be 4 or 12 bytes. When it's 12 bytes, the first 4 267 bytes are 0xffffffff, followed by the length stored in the next 8 268 bytes. 269 270 However, the SGI/MIPS ABI uses an initial length which is equal to 271 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */ 272 273#ifndef DWARF_INITIAL_LENGTH_SIZE 274#define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12) 275#endif 276 277#define DWARF_VERSION 2 278 279/* Round SIZE up to the nearest BOUNDARY. */ 280#define DWARF_ROUND(SIZE,BOUNDARY) \ 281 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY)) 282 283/* Offsets recorded in opcodes are a multiple of this alignment factor. */ 284#ifndef DWARF_CIE_DATA_ALIGNMENT 285#ifdef STACK_GROWS_DOWNWARD 286#define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD)) 287#else 288#define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD) 289#endif 290#endif 291 292/* CIE identifier. */ 293#if HOST_BITS_PER_WIDE_INT >= 64 294#define DWARF_CIE_ID \ 295 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID) 296#else 297#define DWARF_CIE_ID DW_CIE_ID 298#endif 299 300/* A pointer to the base of a table that contains frame description 301 information for each routine. */ 302static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table; 303 304/* Number of elements currently allocated for fde_table. */ 305static GTY(()) unsigned fde_table_allocated; 306 307/* Number of elements in fde_table currently in use. */ 308static GTY(()) unsigned fde_table_in_use; 309 310/* Size (in elements) of increments by which we may expand the 311 fde_table. */ 312#define FDE_TABLE_INCREMENT 256 313 314/* A list of call frame insns for the CIE. */ 315static GTY(()) dw_cfi_ref cie_cfi_head; 316 317#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 318/* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram 319 attribute that accelerates the lookup of the FDE associated 320 with the subprogram. This variable holds the table index of the FDE 321 associated with the current function (body) definition. */ 322static unsigned current_funcdef_fde; 323#endif 324 325struct indirect_string_node GTY(()) 326{ 327 const char *str; 328 unsigned int refcount; 329 unsigned int form; 330 char *label; 331}; 332 333static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash; 334 335static GTY(()) int dw2_string_counter; 336static GTY(()) unsigned long dwarf2out_cfi_label_num; 337 338#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 339 340/* Forward declarations for functions defined in this file. */ 341 342static char *stripattributes (const char *); 343static const char *dwarf_cfi_name (unsigned); 344static dw_cfi_ref new_cfi (void); 345static void add_cfi (dw_cfi_ref *, dw_cfi_ref); 346static void add_fde_cfi (const char *, dw_cfi_ref); 347static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *); 348static void lookup_cfa (dw_cfa_location *); 349static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT); 350static void initial_return_save (rtx); 351static HOST_WIDE_INT stack_adjust_offset (rtx); 352static void output_cfi (dw_cfi_ref, dw_fde_ref, int); 353static void output_call_frame_info (int); 354static void dwarf2out_stack_adjust (rtx, bool); 355static void flush_queued_reg_saves (void); 356static bool clobbers_queued_reg_save (rtx); 357static void dwarf2out_frame_debug_expr (rtx, const char *); 358 359/* Support for complex CFA locations. */ 360static void output_cfa_loc (dw_cfi_ref); 361static void get_cfa_from_loc_descr (dw_cfa_location *, 362 struct dw_loc_descr_struct *); 363static struct dw_loc_descr_struct *build_cfa_loc 364 (dw_cfa_location *, HOST_WIDE_INT); 365static void def_cfa_1 (const char *, dw_cfa_location *); 366 367/* How to start an assembler comment. */ 368#ifndef ASM_COMMENT_START 369#define ASM_COMMENT_START ";#" 370#endif 371 372/* Data and reference forms for relocatable data. */ 373#define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4) 374#define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4) 375 376#ifndef DEBUG_FRAME_SECTION 377#define DEBUG_FRAME_SECTION ".debug_frame" 378#endif 379 380#ifndef FUNC_BEGIN_LABEL 381#define FUNC_BEGIN_LABEL "LFB" 382#endif 383 384#ifndef FUNC_END_LABEL 385#define FUNC_END_LABEL "LFE" 386#endif 387 388#ifndef FRAME_BEGIN_LABEL 389#define FRAME_BEGIN_LABEL "Lframe" 390#endif 391#define CIE_AFTER_SIZE_LABEL "LSCIE" 392#define CIE_END_LABEL "LECIE" 393#define FDE_LABEL "LSFDE" 394#define FDE_AFTER_SIZE_LABEL "LASFDE" 395#define FDE_END_LABEL "LEFDE" 396#define LINE_NUMBER_BEGIN_LABEL "LSLT" 397#define LINE_NUMBER_END_LABEL "LELT" 398#define LN_PROLOG_AS_LABEL "LASLTP" 399#define LN_PROLOG_END_LABEL "LELTP" 400#define DIE_LABEL_PREFIX "DW" 401 402/* The DWARF 2 CFA column which tracks the return address. Normally this 403 is the column for PC, or the first column after all of the hard 404 registers. */ 405#ifndef DWARF_FRAME_RETURN_COLUMN 406#ifdef PC_REGNUM 407#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM) 408#else 409#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS 410#endif 411#endif 412 413/* The mapping from gcc register number to DWARF 2 CFA column number. By 414 default, we just provide columns for all registers. */ 415#ifndef DWARF_FRAME_REGNUM 416#define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG) 417#endif 418 419/* Hook used by __throw. */ 420 421rtx 422expand_builtin_dwarf_sp_column (void) 423{ 424 unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM); 425 return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1)); 426} 427 428/* Return a pointer to a copy of the section string name S with all 429 attributes stripped off, and an asterisk prepended (for assemble_name). */ 430 431static inline char * 432stripattributes (const char *s) 433{ 434 char *stripped = XNEWVEC (char, strlen (s) + 2); 435 char *p = stripped; 436 437 *p++ = '*'; 438 439 while (*s && *s != ',') 440 *p++ = *s++; 441 442 *p = '\0'; 443 return stripped; 444} 445 446/* Generate code to initialize the register size table. */ 447 448void 449expand_builtin_init_dwarf_reg_sizes (tree address) 450{ 451 unsigned int i; 452 enum machine_mode mode = TYPE_MODE (char_type_node); 453 rtx addr = expand_normal (address); 454 rtx mem = gen_rtx_MEM (BLKmode, addr); 455 bool wrote_return_column = false; 456 457 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) 458 { 459 int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1); 460 461 if (rnum < DWARF_FRAME_REGISTERS) 462 { 463 HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode); 464 enum machine_mode save_mode = reg_raw_mode[i]; 465 HOST_WIDE_INT size; 466 467 if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode)) 468 save_mode = choose_hard_reg_mode (i, 1, true); 469 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN) 470 { 471 if (save_mode == VOIDmode) 472 continue; 473 wrote_return_column = true; 474 } 475 size = GET_MODE_SIZE (save_mode); 476 if (offset < 0) 477 continue; 478 479 emit_move_insn (adjust_address (mem, mode, offset), 480 gen_int_mode (size, mode)); 481 } 482 } 483 484#ifdef DWARF_ALT_FRAME_RETURN_COLUMN 485 gcc_assert (wrote_return_column); 486 i = DWARF_ALT_FRAME_RETURN_COLUMN; 487 wrote_return_column = false; 488#else 489 i = DWARF_FRAME_RETURN_COLUMN; 490#endif 491 492 if (! wrote_return_column) 493 { 494 enum machine_mode save_mode = Pmode; 495 HOST_WIDE_INT offset = i * GET_MODE_SIZE (mode); 496 HOST_WIDE_INT size = GET_MODE_SIZE (save_mode); 497 emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size)); 498 } 499} 500 501/* Convert a DWARF call frame info. operation to its string name */ 502 503static const char * 504dwarf_cfi_name (unsigned int cfi_opc) 505{ 506 switch (cfi_opc) 507 { 508 case DW_CFA_advance_loc: 509 return "DW_CFA_advance_loc"; 510 case DW_CFA_offset: 511 return "DW_CFA_offset"; 512 case DW_CFA_restore: 513 return "DW_CFA_restore"; 514 case DW_CFA_nop: 515 return "DW_CFA_nop"; 516 case DW_CFA_set_loc: 517 return "DW_CFA_set_loc"; 518 case DW_CFA_advance_loc1: 519 return "DW_CFA_advance_loc1"; 520 case DW_CFA_advance_loc2: 521 return "DW_CFA_advance_loc2"; 522 case DW_CFA_advance_loc4: 523 return "DW_CFA_advance_loc4"; 524 case DW_CFA_offset_extended: 525 return "DW_CFA_offset_extended"; 526 case DW_CFA_restore_extended: 527 return "DW_CFA_restore_extended"; 528 case DW_CFA_undefined: 529 return "DW_CFA_undefined"; 530 case DW_CFA_same_value: 531 return "DW_CFA_same_value"; 532 case DW_CFA_register: 533 return "DW_CFA_register"; 534 case DW_CFA_remember_state: 535 return "DW_CFA_remember_state"; 536 case DW_CFA_restore_state: 537 return "DW_CFA_restore_state"; 538 case DW_CFA_def_cfa: 539 return "DW_CFA_def_cfa"; 540 case DW_CFA_def_cfa_register: 541 return "DW_CFA_def_cfa_register"; 542 case DW_CFA_def_cfa_offset: 543 return "DW_CFA_def_cfa_offset"; 544 545 /* DWARF 3 */ 546 case DW_CFA_def_cfa_expression: 547 return "DW_CFA_def_cfa_expression"; 548 case DW_CFA_expression: 549 return "DW_CFA_expression"; 550 case DW_CFA_offset_extended_sf: 551 return "DW_CFA_offset_extended_sf"; 552 case DW_CFA_def_cfa_sf: 553 return "DW_CFA_def_cfa_sf"; 554 case DW_CFA_def_cfa_offset_sf: 555 return "DW_CFA_def_cfa_offset_sf"; 556 557 /* SGI/MIPS specific */ 558 case DW_CFA_MIPS_advance_loc8: 559 return "DW_CFA_MIPS_advance_loc8"; 560 561 /* GNU extensions */ 562 case DW_CFA_GNU_window_save: 563 return "DW_CFA_GNU_window_save"; 564 case DW_CFA_GNU_args_size: 565 return "DW_CFA_GNU_args_size"; 566 case DW_CFA_GNU_negative_offset_extended: 567 return "DW_CFA_GNU_negative_offset_extended"; 568 569 default: 570 return "DW_CFA_<unknown>"; 571 } 572} 573 574/* Return a pointer to a newly allocated Call Frame Instruction. */ 575 576static inline dw_cfi_ref 577new_cfi (void) 578{ 579 dw_cfi_ref cfi = ggc_alloc (sizeof (dw_cfi_node)); 580 581 cfi->dw_cfi_next = NULL; 582 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0; 583 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0; 584 585 return cfi; 586} 587 588/* Add a Call Frame Instruction to list of instructions. */ 589 590static inline void 591add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi) 592{ 593 dw_cfi_ref *p; 594 595 /* Find the end of the chain. */ 596 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next) 597 ; 598 599 *p = cfi; 600} 601 602/* Generate a new label for the CFI info to refer to. */ 603 604char * 605dwarf2out_cfi_label (void) 606{ 607 static char label[20]; 608 609 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++); 610 ASM_OUTPUT_LABEL (asm_out_file, label); 611 return label; 612} 613 614/* Add CFI to the current fde at the PC value indicated by LABEL if specified, 615 or to the CIE if LABEL is NULL. */ 616 617static void 618add_fde_cfi (const char *label, dw_cfi_ref cfi) 619{ 620 if (label) 621 { 622 dw_fde_ref fde = &fde_table[fde_table_in_use - 1]; 623 624 if (*label == 0) 625 label = dwarf2out_cfi_label (); 626 627 if (fde->dw_fde_current_label == NULL 628 || strcmp (label, fde->dw_fde_current_label) != 0) 629 { 630 dw_cfi_ref xcfi; 631 632 label = xstrdup (label); 633 634 /* Set the location counter to the new label. */ 635 xcfi = new_cfi (); 636 /* If we have a current label, advance from there, otherwise 637 set the location directly using set_loc. */ 638 xcfi->dw_cfi_opc = fde->dw_fde_current_label 639 ? DW_CFA_advance_loc4 640 : DW_CFA_set_loc; 641 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label; 642 add_cfi (&fde->dw_fde_cfi, xcfi); 643 644 fde->dw_fde_current_label = label; 645 } 646 647 add_cfi (&fde->dw_fde_cfi, cfi); 648 } 649 650 else 651 add_cfi (&cie_cfi_head, cfi); 652} 653 654/* Subroutine of lookup_cfa. */ 655 656static void 657lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc) 658{ 659 switch (cfi->dw_cfi_opc) 660 { 661 case DW_CFA_def_cfa_offset: 662 loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset; 663 break; 664 case DW_CFA_def_cfa_offset_sf: 665 loc->offset 666 = cfi->dw_cfi_oprnd1.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT; 667 break; 668 case DW_CFA_def_cfa_register: 669 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num; 670 break; 671 case DW_CFA_def_cfa: 672 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num; 673 loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset; 674 break; 675 case DW_CFA_def_cfa_sf: 676 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num; 677 loc->offset 678 = cfi->dw_cfi_oprnd2.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT; 679 break; 680 case DW_CFA_def_cfa_expression: 681 get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc); 682 break; 683 default: 684 break; 685 } 686} 687 688/* Find the previous value for the CFA. */ 689 690static void 691lookup_cfa (dw_cfa_location *loc) 692{ 693 dw_cfi_ref cfi; 694 695 loc->reg = INVALID_REGNUM; 696 loc->offset = 0; 697 loc->indirect = 0; 698 loc->base_offset = 0; 699 700 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next) 701 lookup_cfa_1 (cfi, loc); 702 703 if (fde_table_in_use) 704 { 705 dw_fde_ref fde = &fde_table[fde_table_in_use - 1]; 706 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next) 707 lookup_cfa_1 (cfi, loc); 708 } 709} 710 711/* The current rule for calculating the DWARF2 canonical frame address. */ 712static dw_cfa_location cfa; 713 714/* The register used for saving registers to the stack, and its offset 715 from the CFA. */ 716static dw_cfa_location cfa_store; 717 718/* The running total of the size of arguments pushed onto the stack. */ 719static HOST_WIDE_INT args_size; 720 721/* The last args_size we actually output. */ 722static HOST_WIDE_INT old_args_size; 723 724/* Entry point to update the canonical frame address (CFA). 725 LABEL is passed to add_fde_cfi. The value of CFA is now to be 726 calculated from REG+OFFSET. */ 727 728void 729dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset) 730{ 731 dw_cfa_location loc; 732 loc.indirect = 0; 733 loc.base_offset = 0; 734 loc.reg = reg; 735 loc.offset = offset; 736 def_cfa_1 (label, &loc); 737} 738 739/* Determine if two dw_cfa_location structures define the same data. */ 740 741static bool 742cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2) 743{ 744 return (loc1->reg == loc2->reg 745 && loc1->offset == loc2->offset 746 && loc1->indirect == loc2->indirect 747 && (loc1->indirect == 0 748 || loc1->base_offset == loc2->base_offset)); 749} 750 751/* This routine does the actual work. The CFA is now calculated from 752 the dw_cfa_location structure. */ 753 754static void 755def_cfa_1 (const char *label, dw_cfa_location *loc_p) 756{ 757 dw_cfi_ref cfi; 758 dw_cfa_location old_cfa, loc; 759 760 cfa = *loc_p; 761 loc = *loc_p; 762 763 if (cfa_store.reg == loc.reg && loc.indirect == 0) 764 cfa_store.offset = loc.offset; 765 766 loc.reg = DWARF_FRAME_REGNUM (loc.reg); 767 lookup_cfa (&old_cfa); 768 769 /* If nothing changed, no need to issue any call frame instructions. */ 770 if (cfa_equal_p (&loc, &old_cfa)) 771 return; 772 773 cfi = new_cfi (); 774 775 if (loc.reg == old_cfa.reg && !loc.indirect) 776 { 777 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating 778 the CFA register did not change but the offset did. */ 779 if (loc.offset < 0) 780 { 781 HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT; 782 gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset); 783 784 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf; 785 cfi->dw_cfi_oprnd1.dw_cfi_offset = f_offset; 786 } 787 else 788 { 789 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset; 790 cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset; 791 } 792 } 793 794#ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */ 795 else if (loc.offset == old_cfa.offset 796 && old_cfa.reg != INVALID_REGNUM 797 && !loc.indirect) 798 { 799 /* Construct a "DW_CFA_def_cfa_register <register>" instruction, 800 indicating the CFA register has changed to <register> but the 801 offset has not changed. */ 802 cfi->dw_cfi_opc = DW_CFA_def_cfa_register; 803 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg; 804 } 805#endif 806 807 else if (loc.indirect == 0) 808 { 809 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction, 810 indicating the CFA register has changed to <register> with 811 the specified offset. */ 812 if (loc.offset < 0) 813 { 814 HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT; 815 gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset); 816 817 cfi->dw_cfi_opc = DW_CFA_def_cfa_sf; 818 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg; 819 cfi->dw_cfi_oprnd2.dw_cfi_offset = f_offset; 820 } 821 else 822 { 823 cfi->dw_cfi_opc = DW_CFA_def_cfa; 824 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg; 825 cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset; 826 } 827 } 828 else 829 { 830 /* Construct a DW_CFA_def_cfa_expression instruction to 831 calculate the CFA using a full location expression since no 832 register-offset pair is available. */ 833 struct dw_loc_descr_struct *loc_list; 834 835 cfi->dw_cfi_opc = DW_CFA_def_cfa_expression; 836 loc_list = build_cfa_loc (&loc, 0); 837 cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list; 838 } 839 840 add_fde_cfi (label, cfi); 841} 842 843/* Add the CFI for saving a register. REG is the CFA column number. 844 LABEL is passed to add_fde_cfi. 845 If SREG is -1, the register is saved at OFFSET from the CFA; 846 otherwise it is saved in SREG. */ 847 848static void 849reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset) 850{ 851 dw_cfi_ref cfi = new_cfi (); 852 853 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg; 854 855 if (sreg == INVALID_REGNUM) 856 { 857 if (reg & ~0x3f) 858 /* The register number won't fit in 6 bits, so we have to use 859 the long form. */ 860 cfi->dw_cfi_opc = DW_CFA_offset_extended; 861 else 862 cfi->dw_cfi_opc = DW_CFA_offset; 863 864#ifdef ENABLE_CHECKING 865 { 866 /* If we get an offset that is not a multiple of 867 DWARF_CIE_DATA_ALIGNMENT, there is either a bug in the 868 definition of DWARF_CIE_DATA_ALIGNMENT, or a bug in the machine 869 description. */ 870 HOST_WIDE_INT check_offset = offset / DWARF_CIE_DATA_ALIGNMENT; 871 872 gcc_assert (check_offset * DWARF_CIE_DATA_ALIGNMENT == offset); 873 } 874#endif 875 offset /= DWARF_CIE_DATA_ALIGNMENT; 876 if (offset < 0) 877 cfi->dw_cfi_opc = DW_CFA_offset_extended_sf; 878 879 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset; 880 } 881 else if (sreg == reg) 882 cfi->dw_cfi_opc = DW_CFA_same_value; 883 else 884 { 885 cfi->dw_cfi_opc = DW_CFA_register; 886 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg; 887 } 888 889 add_fde_cfi (label, cfi); 890} 891 892/* Add the CFI for saving a register window. LABEL is passed to reg_save. 893 This CFI tells the unwinder that it needs to restore the window registers 894 from the previous frame's window save area. 895 896 ??? Perhaps we should note in the CIE where windows are saved (instead of 897 assuming 0(cfa)) and what registers are in the window. */ 898 899void 900dwarf2out_window_save (const char *label) 901{ 902 dw_cfi_ref cfi = new_cfi (); 903 904 cfi->dw_cfi_opc = DW_CFA_GNU_window_save; 905 add_fde_cfi (label, cfi); 906} 907 908/* Add a CFI to update the running total of the size of arguments 909 pushed onto the stack. */ 910 911void 912dwarf2out_args_size (const char *label, HOST_WIDE_INT size) 913{ 914 dw_cfi_ref cfi; 915 916 if (size == old_args_size) 917 return; 918 919 old_args_size = size; 920 921 cfi = new_cfi (); 922 cfi->dw_cfi_opc = DW_CFA_GNU_args_size; 923 cfi->dw_cfi_oprnd1.dw_cfi_offset = size; 924 add_fde_cfi (label, cfi); 925} 926 927/* Entry point for saving a register to the stack. REG is the GCC register 928 number. LABEL and OFFSET are passed to reg_save. */ 929 930void 931dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset) 932{ 933 reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset); 934} 935 936/* Entry point for saving the return address in the stack. 937 LABEL and OFFSET are passed to reg_save. */ 938 939void 940dwarf2out_return_save (const char *label, HOST_WIDE_INT offset) 941{ 942 reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset); 943} 944 945/* Entry point for saving the return address in a register. 946 LABEL and SREG are passed to reg_save. */ 947 948void 949dwarf2out_return_reg (const char *label, unsigned int sreg) 950{ 951 reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0); 952} 953 954/* Record the initial position of the return address. RTL is 955 INCOMING_RETURN_ADDR_RTX. */ 956 957static void 958initial_return_save (rtx rtl) 959{ 960 unsigned int reg = INVALID_REGNUM; 961 HOST_WIDE_INT offset = 0; 962 963 switch (GET_CODE (rtl)) 964 { 965 case REG: 966 /* RA is in a register. */ 967 reg = DWARF_FRAME_REGNUM (REGNO (rtl)); 968 break; 969 970 case MEM: 971 /* RA is on the stack. */ 972 rtl = XEXP (rtl, 0); 973 switch (GET_CODE (rtl)) 974 { 975 case REG: 976 gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM); 977 offset = 0; 978 break; 979 980 case PLUS: 981 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM); 982 offset = INTVAL (XEXP (rtl, 1)); 983 break; 984 985 case MINUS: 986 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM); 987 offset = -INTVAL (XEXP (rtl, 1)); 988 break; 989 990 default: 991 gcc_unreachable (); 992 } 993 994 break; 995 996 case PLUS: 997 /* The return address is at some offset from any value we can 998 actually load. For instance, on the SPARC it is in %i7+8. Just 999 ignore the offset for now; it doesn't matter for unwinding frames. */ 1000 gcc_assert (GET_CODE (XEXP (rtl, 1)) == CONST_INT); 1001 initial_return_save (XEXP (rtl, 0)); 1002 return; 1003 1004 default: 1005 gcc_unreachable (); 1006 } 1007 1008 if (reg != DWARF_FRAME_RETURN_COLUMN) 1009 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset); 1010} 1011 1012/* Given a SET, calculate the amount of stack adjustment it 1013 contains. */ 1014 1015static HOST_WIDE_INT 1016stack_adjust_offset (rtx pattern) 1017{ 1018 rtx src = SET_SRC (pattern); 1019 rtx dest = SET_DEST (pattern); 1020 HOST_WIDE_INT offset = 0; 1021 enum rtx_code code; 1022 1023 if (dest == stack_pointer_rtx) 1024 { 1025 /* (set (reg sp) (plus (reg sp) (const_int))) */ 1026 code = GET_CODE (src); 1027 if (! (code == PLUS || code == MINUS) 1028 || XEXP (src, 0) != stack_pointer_rtx 1029 || GET_CODE (XEXP (src, 1)) != CONST_INT) 1030 return 0; 1031 1032 offset = INTVAL (XEXP (src, 1)); 1033 if (code == PLUS) 1034 offset = -offset; 1035 } 1036 else if (MEM_P (dest)) 1037 { 1038 /* (set (mem (pre_dec (reg sp))) (foo)) */ 1039 src = XEXP (dest, 0); 1040 code = GET_CODE (src); 1041 1042 switch (code) 1043 { 1044 case PRE_MODIFY: 1045 case POST_MODIFY: 1046 if (XEXP (src, 0) == stack_pointer_rtx) 1047 { 1048 rtx val = XEXP (XEXP (src, 1), 1); 1049 /* We handle only adjustments by constant amount. */ 1050 gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS 1051 && GET_CODE (val) == CONST_INT); 1052 offset = -INTVAL (val); 1053 break; 1054 } 1055 return 0; 1056 1057 case PRE_DEC: 1058 case POST_DEC: 1059 if (XEXP (src, 0) == stack_pointer_rtx) 1060 { 1061 offset = GET_MODE_SIZE (GET_MODE (dest)); 1062 break; 1063 } 1064 return 0; 1065 1066 case PRE_INC: 1067 case POST_INC: 1068 if (XEXP (src, 0) == stack_pointer_rtx) 1069 { 1070 offset = -GET_MODE_SIZE (GET_MODE (dest)); 1071 break; 1072 } 1073 return 0; 1074 1075 default: 1076 return 0; 1077 } 1078 } 1079 else 1080 return 0; 1081 1082 return offset; 1083} 1084 1085/* Check INSN to see if it looks like a push or a stack adjustment, and 1086 make a note of it if it does. EH uses this information to find out how 1087 much extra space it needs to pop off the stack. */ 1088 1089static void 1090dwarf2out_stack_adjust (rtx insn, bool after_p) 1091{ 1092 HOST_WIDE_INT offset; 1093 const char *label; 1094 int i; 1095 1096 /* Don't handle epilogues at all. Certainly it would be wrong to do so 1097 with this function. Proper support would require all frame-related 1098 insns to be marked, and to be able to handle saving state around 1099 epilogues textually in the middle of the function. */ 1100 if (prologue_epilogue_contains (insn) || sibcall_epilogue_contains (insn)) 1101 return; 1102 1103 /* If only calls can throw, and we have a frame pointer, 1104 save up adjustments until we see the CALL_INSN. */ 1105 if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM) 1106 { 1107 if (CALL_P (insn) && !after_p) 1108 { 1109 /* Extract the size of the args from the CALL rtx itself. */ 1110 insn = PATTERN (insn); 1111 if (GET_CODE (insn) == PARALLEL) 1112 insn = XVECEXP (insn, 0, 0); 1113 if (GET_CODE (insn) == SET) 1114 insn = SET_SRC (insn); 1115 gcc_assert (GET_CODE (insn) == CALL); 1116 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1))); 1117 } 1118 return; 1119 } 1120 1121 if (CALL_P (insn) && !after_p) 1122 { 1123 if (!flag_asynchronous_unwind_tables) 1124 dwarf2out_args_size ("", args_size); 1125 return; 1126 } 1127 else if (BARRIER_P (insn)) 1128 { 1129 /* When we see a BARRIER, we know to reset args_size to 0. Usually 1130 the compiler will have already emitted a stack adjustment, but 1131 doesn't bother for calls to noreturn functions. */ 1132#ifdef STACK_GROWS_DOWNWARD 1133 offset = -args_size; 1134#else 1135 offset = args_size; 1136#endif 1137 } 1138 else if (GET_CODE (PATTERN (insn)) == SET) 1139 offset = stack_adjust_offset (PATTERN (insn)); 1140 else if (GET_CODE (PATTERN (insn)) == PARALLEL 1141 || GET_CODE (PATTERN (insn)) == SEQUENCE) 1142 { 1143 /* There may be stack adjustments inside compound insns. Search 1144 for them. */ 1145 for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--) 1146 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET) 1147 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i)); 1148 } 1149 else 1150 return; 1151 1152 if (offset == 0) 1153 return; 1154 1155 if (cfa.reg == STACK_POINTER_REGNUM) 1156 cfa.offset += offset; 1157 1158#ifndef STACK_GROWS_DOWNWARD 1159 offset = -offset; 1160#endif 1161 1162 args_size += offset; 1163 if (args_size < 0) 1164 args_size = 0; 1165 1166 label = dwarf2out_cfi_label (); 1167 def_cfa_1 (label, &cfa); 1168 if (flag_asynchronous_unwind_tables) 1169 dwarf2out_args_size (label, args_size); 1170} 1171 1172#endif 1173 1174/* We delay emitting a register save until either (a) we reach the end 1175 of the prologue or (b) the register is clobbered. This clusters 1176 register saves so that there are fewer pc advances. */ 1177 1178struct queued_reg_save GTY(()) 1179{ 1180 struct queued_reg_save *next; 1181 rtx reg; 1182 HOST_WIDE_INT cfa_offset; 1183 rtx saved_reg; 1184}; 1185 1186static GTY(()) struct queued_reg_save *queued_reg_saves; 1187 1188/* The caller's ORIG_REG is saved in SAVED_IN_REG. */ 1189struct reg_saved_in_data GTY(()) { 1190 rtx orig_reg; 1191 rtx saved_in_reg; 1192}; 1193 1194/* A list of registers saved in other registers. 1195 The list intentionally has a small maximum capacity of 4; if your 1196 port needs more than that, you might consider implementing a 1197 more efficient data structure. */ 1198static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4]; 1199static GTY(()) size_t num_regs_saved_in_regs; 1200 1201#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 1202static const char *last_reg_save_label; 1203 1204/* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at 1205 SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */ 1206 1207static void 1208queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset) 1209{ 1210 struct queued_reg_save *q; 1211 1212 /* Duplicates waste space, but it's also necessary to remove them 1213 for correctness, since the queue gets output in reverse 1214 order. */ 1215 for (q = queued_reg_saves; q != NULL; q = q->next) 1216 if (REGNO (q->reg) == REGNO (reg)) 1217 break; 1218 1219 if (q == NULL) 1220 { 1221 q = ggc_alloc (sizeof (*q)); 1222 q->next = queued_reg_saves; 1223 queued_reg_saves = q; 1224 } 1225 1226 q->reg = reg; 1227 q->cfa_offset = offset; 1228 q->saved_reg = sreg; 1229 1230 last_reg_save_label = label; 1231} 1232 1233/* Output all the entries in QUEUED_REG_SAVES. */ 1234 1235static void 1236flush_queued_reg_saves (void) 1237{ 1238 struct queued_reg_save *q; 1239 1240 for (q = queued_reg_saves; q; q = q->next) 1241 { 1242 size_t i; 1243 unsigned int reg, sreg; 1244 1245 for (i = 0; i < num_regs_saved_in_regs; i++) 1246 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg)) 1247 break; 1248 if (q->saved_reg && i == num_regs_saved_in_regs) 1249 { 1250 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs)); 1251 num_regs_saved_in_regs++; 1252 } 1253 if (i != num_regs_saved_in_regs) 1254 { 1255 regs_saved_in_regs[i].orig_reg = q->reg; 1256 regs_saved_in_regs[i].saved_in_reg = q->saved_reg; 1257 } 1258 1259 reg = DWARF_FRAME_REGNUM (REGNO (q->reg)); 1260 if (q->saved_reg) 1261 sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg)); 1262 else 1263 sreg = INVALID_REGNUM; 1264 reg_save (last_reg_save_label, reg, sreg, q->cfa_offset); 1265 } 1266 1267 queued_reg_saves = NULL; 1268 last_reg_save_label = NULL; 1269} 1270 1271/* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved 1272 location for? Or, does it clobber a register which we've previously 1273 said that some other register is saved in, and for which we now 1274 have a new location for? */ 1275 1276static bool 1277clobbers_queued_reg_save (rtx insn) 1278{ 1279 struct queued_reg_save *q; 1280 1281 for (q = queued_reg_saves; q; q = q->next) 1282 { 1283 size_t i; 1284 if (modified_in_p (q->reg, insn)) 1285 return true; 1286 for (i = 0; i < num_regs_saved_in_regs; i++) 1287 if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg) 1288 && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn)) 1289 return true; 1290 } 1291 1292 return false; 1293} 1294 1295/* Entry point for saving the first register into the second. */ 1296 1297void 1298dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg) 1299{ 1300 size_t i; 1301 unsigned int regno, sregno; 1302 1303 for (i = 0; i < num_regs_saved_in_regs; i++) 1304 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg)) 1305 break; 1306 if (i == num_regs_saved_in_regs) 1307 { 1308 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs)); 1309 num_regs_saved_in_regs++; 1310 } 1311 regs_saved_in_regs[i].orig_reg = reg; 1312 regs_saved_in_regs[i].saved_in_reg = sreg; 1313 1314 regno = DWARF_FRAME_REGNUM (REGNO (reg)); 1315 sregno = DWARF_FRAME_REGNUM (REGNO (sreg)); 1316 reg_save (label, regno, sregno, 0); 1317} 1318 1319/* What register, if any, is currently saved in REG? */ 1320 1321static rtx 1322reg_saved_in (rtx reg) 1323{ 1324 unsigned int regn = REGNO (reg); 1325 size_t i; 1326 struct queued_reg_save *q; 1327 1328 for (q = queued_reg_saves; q; q = q->next) 1329 if (q->saved_reg && regn == REGNO (q->saved_reg)) 1330 return q->reg; 1331 1332 for (i = 0; i < num_regs_saved_in_regs; i++) 1333 if (regs_saved_in_regs[i].saved_in_reg 1334 && regn == REGNO (regs_saved_in_regs[i].saved_in_reg)) 1335 return regs_saved_in_regs[i].orig_reg; 1336 1337 return NULL_RTX; 1338} 1339 1340 1341/* A temporary register holding an integral value used in adjusting SP 1342 or setting up the store_reg. The "offset" field holds the integer 1343 value, not an offset. */ 1344static dw_cfa_location cfa_temp; 1345 1346/* Record call frame debugging information for an expression EXPR, 1347 which either sets SP or FP (adjusting how we calculate the frame 1348 address) or saves a register to the stack or another register. 1349 LABEL indicates the address of EXPR. 1350 1351 This function encodes a state machine mapping rtxes to actions on 1352 cfa, cfa_store, and cfa_temp.reg. We describe these rules so 1353 users need not read the source code. 1354 1355 The High-Level Picture 1356 1357 Changes in the register we use to calculate the CFA: Currently we 1358 assume that if you copy the CFA register into another register, we 1359 should take the other one as the new CFA register; this seems to 1360 work pretty well. If it's wrong for some target, it's simple 1361 enough not to set RTX_FRAME_RELATED_P on the insn in question. 1362 1363 Changes in the register we use for saving registers to the stack: 1364 This is usually SP, but not always. Again, we deduce that if you 1365 copy SP into another register (and SP is not the CFA register), 1366 then the new register is the one we will be using for register 1367 saves. This also seems to work. 1368 1369 Register saves: There's not much guesswork about this one; if 1370 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a 1371 register save, and the register used to calculate the destination 1372 had better be the one we think we're using for this purpose. 1373 It's also assumed that a copy from a call-saved register to another 1374 register is saving that register if RTX_FRAME_RELATED_P is set on 1375 that instruction. If the copy is from a call-saved register to 1376 the *same* register, that means that the register is now the same 1377 value as in the caller. 1378 1379 Except: If the register being saved is the CFA register, and the 1380 offset is nonzero, we are saving the CFA, so we assume we have to 1381 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that 1382 the intent is to save the value of SP from the previous frame. 1383 1384 In addition, if a register has previously been saved to a different 1385 register, 1386 1387 Invariants / Summaries of Rules 1388 1389 cfa current rule for calculating the CFA. It usually 1390 consists of a register and an offset. 1391 cfa_store register used by prologue code to save things to the stack 1392 cfa_store.offset is the offset from the value of 1393 cfa_store.reg to the actual CFA 1394 cfa_temp register holding an integral value. cfa_temp.offset 1395 stores the value, which will be used to adjust the 1396 stack pointer. cfa_temp is also used like cfa_store, 1397 to track stores to the stack via fp or a temp reg. 1398 1399 Rules 1- 4: Setting a register's value to cfa.reg or an expression 1400 with cfa.reg as the first operand changes the cfa.reg and its 1401 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and 1402 cfa_temp.offset. 1403 1404 Rules 6- 9: Set a non-cfa.reg register value to a constant or an 1405 expression yielding a constant. This sets cfa_temp.reg 1406 and cfa_temp.offset. 1407 1408 Rule 5: Create a new register cfa_store used to save items to the 1409 stack. 1410 1411 Rules 10-14: Save a register to the stack. Define offset as the 1412 difference of the original location and cfa_store's 1413 location (or cfa_temp's location if cfa_temp is used). 1414 1415 The Rules 1416 1417 "{a,b}" indicates a choice of a xor b. 1418 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg. 1419 1420 Rule 1: 1421 (set <reg1> <reg2>:cfa.reg) 1422 effects: cfa.reg = <reg1> 1423 cfa.offset unchanged 1424 cfa_temp.reg = <reg1> 1425 cfa_temp.offset = cfa.offset 1426 1427 Rule 2: 1428 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg 1429 {<const_int>,<reg>:cfa_temp.reg})) 1430 effects: cfa.reg = sp if fp used 1431 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp 1432 cfa_store.offset += {+/- <const_int>, cfa_temp.offset} 1433 if cfa_store.reg==sp 1434 1435 Rule 3: 1436 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>)) 1437 effects: cfa.reg = fp 1438 cfa_offset += +/- <const_int> 1439 1440 Rule 4: 1441 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>)) 1442 constraints: <reg1> != fp 1443 <reg1> != sp 1444 effects: cfa.reg = <reg1> 1445 cfa_temp.reg = <reg1> 1446 cfa_temp.offset = cfa.offset 1447 1448 Rule 5: 1449 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg)) 1450 constraints: <reg1> != fp 1451 <reg1> != sp 1452 effects: cfa_store.reg = <reg1> 1453 cfa_store.offset = cfa.offset - cfa_temp.offset 1454 1455 Rule 6: 1456 (set <reg> <const_int>) 1457 effects: cfa_temp.reg = <reg> 1458 cfa_temp.offset = <const_int> 1459 1460 Rule 7: 1461 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>)) 1462 effects: cfa_temp.reg = <reg1> 1463 cfa_temp.offset |= <const_int> 1464 1465 Rule 8: 1466 (set <reg> (high <exp>)) 1467 effects: none 1468 1469 Rule 9: 1470 (set <reg> (lo_sum <exp> <const_int>)) 1471 effects: cfa_temp.reg = <reg> 1472 cfa_temp.offset = <const_int> 1473 1474 Rule 10: 1475 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>) 1476 effects: cfa_store.offset -= <const_int> 1477 cfa.offset = cfa_store.offset if cfa.reg == sp 1478 cfa.reg = sp 1479 cfa.base_offset = -cfa_store.offset 1480 1481 Rule 11: 1482 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>) 1483 effects: cfa_store.offset += -/+ mode_size(mem) 1484 cfa.offset = cfa_store.offset if cfa.reg == sp 1485 cfa.reg = sp 1486 cfa.base_offset = -cfa_store.offset 1487 1488 Rule 12: 1489 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>)) 1490 1491 <reg2>) 1492 effects: cfa.reg = <reg1> 1493 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset 1494 1495 Rule 13: 1496 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>) 1497 effects: cfa.reg = <reg1> 1498 cfa.base_offset = -{cfa_store,cfa_temp}.offset 1499 1500 Rule 14: 1501 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>) 1502 effects: cfa.reg = <reg1> 1503 cfa.base_offset = -cfa_temp.offset 1504 cfa_temp.offset -= mode_size(mem) 1505 1506 Rule 15: 1507 (set <reg> {unspec, unspec_volatile}) 1508 effects: target-dependent */ 1509 1510static void 1511dwarf2out_frame_debug_expr (rtx expr, const char *label) 1512{ 1513 rtx src, dest; 1514 HOST_WIDE_INT offset; 1515 1516 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of 1517 the PARALLEL independently. The first element is always processed if 1518 it is a SET. This is for backward compatibility. Other elements 1519 are processed only if they are SETs and the RTX_FRAME_RELATED_P 1520 flag is set in them. */ 1521 if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE) 1522 { 1523 int par_index; 1524 int limit = XVECLEN (expr, 0); 1525 1526 for (par_index = 0; par_index < limit; par_index++) 1527 if (GET_CODE (XVECEXP (expr, 0, par_index)) == SET 1528 && (RTX_FRAME_RELATED_P (XVECEXP (expr, 0, par_index)) 1529 || par_index == 0)) 1530 dwarf2out_frame_debug_expr (XVECEXP (expr, 0, par_index), label); 1531 1532 return; 1533 } 1534 1535 gcc_assert (GET_CODE (expr) == SET); 1536 1537 src = SET_SRC (expr); 1538 dest = SET_DEST (expr); 1539 1540 if (REG_P (src)) 1541 { 1542 rtx rsi = reg_saved_in (src); 1543 if (rsi) 1544 src = rsi; 1545 } 1546 1547 switch (GET_CODE (dest)) 1548 { 1549 case REG: 1550 switch (GET_CODE (src)) 1551 { 1552 /* Setting FP from SP. */ 1553 case REG: 1554 if (cfa.reg == (unsigned) REGNO (src)) 1555 { 1556 /* Rule 1 */ 1557 /* Update the CFA rule wrt SP or FP. Make sure src is 1558 relative to the current CFA register. 1559 1560 We used to require that dest be either SP or FP, but the 1561 ARM copies SP to a temporary register, and from there to 1562 FP. So we just rely on the backends to only set 1563 RTX_FRAME_RELATED_P on appropriate insns. */ 1564 cfa.reg = REGNO (dest); 1565 cfa_temp.reg = cfa.reg; 1566 cfa_temp.offset = cfa.offset; 1567 } 1568 else 1569 { 1570 /* Saving a register in a register. */ 1571 gcc_assert (!fixed_regs [REGNO (dest)] 1572 /* For the SPARC and its register window. */ 1573 || (DWARF_FRAME_REGNUM (REGNO (src)) 1574 == DWARF_FRAME_RETURN_COLUMN)); 1575 queue_reg_save (label, src, dest, 0); 1576 } 1577 break; 1578 1579 case PLUS: 1580 case MINUS: 1581 case LO_SUM: 1582 if (dest == stack_pointer_rtx) 1583 { 1584 /* Rule 2 */ 1585 /* Adjusting SP. */ 1586 switch (GET_CODE (XEXP (src, 1))) 1587 { 1588 case CONST_INT: 1589 offset = INTVAL (XEXP (src, 1)); 1590 break; 1591 case REG: 1592 gcc_assert ((unsigned) REGNO (XEXP (src, 1)) 1593 == cfa_temp.reg); 1594 offset = cfa_temp.offset; 1595 break; 1596 default: 1597 gcc_unreachable (); 1598 } 1599 1600 if (XEXP (src, 0) == hard_frame_pointer_rtx) 1601 { 1602 /* Restoring SP from FP in the epilogue. */ 1603 gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM); 1604 cfa.reg = STACK_POINTER_REGNUM; 1605 } 1606 else if (GET_CODE (src) == LO_SUM) 1607 /* Assume we've set the source reg of the LO_SUM from sp. */ 1608 ; 1609 else 1610 gcc_assert (XEXP (src, 0) == stack_pointer_rtx); 1611 1612 if (GET_CODE (src) != MINUS) 1613 offset = -offset; 1614 if (cfa.reg == STACK_POINTER_REGNUM) 1615 cfa.offset += offset; 1616 if (cfa_store.reg == STACK_POINTER_REGNUM) 1617 cfa_store.offset += offset; 1618 } 1619 else if (dest == hard_frame_pointer_rtx) 1620 { 1621 /* Rule 3 */ 1622 /* Either setting the FP from an offset of the SP, 1623 or adjusting the FP */ 1624 gcc_assert (frame_pointer_needed); 1625 1626 gcc_assert (REG_P (XEXP (src, 0)) 1627 && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg 1628 && GET_CODE (XEXP (src, 1)) == CONST_INT); 1629 offset = INTVAL (XEXP (src, 1)); 1630 if (GET_CODE (src) != MINUS) 1631 offset = -offset; 1632 cfa.offset += offset; 1633 cfa.reg = HARD_FRAME_POINTER_REGNUM; 1634 } 1635 else 1636 { 1637 gcc_assert (GET_CODE (src) != MINUS); 1638 1639 /* Rule 4 */ 1640 if (REG_P (XEXP (src, 0)) 1641 && REGNO (XEXP (src, 0)) == cfa.reg 1642 && GET_CODE (XEXP (src, 1)) == CONST_INT) 1643 { 1644 /* Setting a temporary CFA register that will be copied 1645 into the FP later on. */ 1646 offset = - INTVAL (XEXP (src, 1)); 1647 cfa.offset += offset; 1648 cfa.reg = REGNO (dest); 1649 /* Or used to save regs to the stack. */ 1650 cfa_temp.reg = cfa.reg; 1651 cfa_temp.offset = cfa.offset; 1652 } 1653 1654 /* Rule 5 */ 1655 else if (REG_P (XEXP (src, 0)) 1656 && REGNO (XEXP (src, 0)) == cfa_temp.reg 1657 && XEXP (src, 1) == stack_pointer_rtx) 1658 { 1659 /* Setting a scratch register that we will use instead 1660 of SP for saving registers to the stack. */ 1661 gcc_assert (cfa.reg == STACK_POINTER_REGNUM); 1662 cfa_store.reg = REGNO (dest); 1663 cfa_store.offset = cfa.offset - cfa_temp.offset; 1664 } 1665 1666 /* Rule 9 */ 1667 else if (GET_CODE (src) == LO_SUM 1668 && GET_CODE (XEXP (src, 1)) == CONST_INT) 1669 { 1670 cfa_temp.reg = REGNO (dest); 1671 cfa_temp.offset = INTVAL (XEXP (src, 1)); 1672 } 1673 else 1674 gcc_unreachable (); 1675 } 1676 break; 1677 1678 /* Rule 6 */ 1679 case CONST_INT: 1680 cfa_temp.reg = REGNO (dest); 1681 cfa_temp.offset = INTVAL (src); 1682 break; 1683 1684 /* Rule 7 */ 1685 case IOR: 1686 gcc_assert (REG_P (XEXP (src, 0)) 1687 && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg 1688 && GET_CODE (XEXP (src, 1)) == CONST_INT); 1689 1690 if ((unsigned) REGNO (dest) != cfa_temp.reg) 1691 cfa_temp.reg = REGNO (dest); 1692 cfa_temp.offset |= INTVAL (XEXP (src, 1)); 1693 break; 1694 1695 /* Skip over HIGH, assuming it will be followed by a LO_SUM, 1696 which will fill in all of the bits. */ 1697 /* Rule 8 */ 1698 case HIGH: 1699 break; 1700 1701 /* Rule 15 */ 1702 case UNSPEC: 1703 case UNSPEC_VOLATILE: 1704 gcc_assert (targetm.dwarf_handle_frame_unspec); 1705 targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1)); 1706 return; 1707 1708 default: 1709 gcc_unreachable (); 1710 } 1711 1712 def_cfa_1 (label, &cfa); 1713 break; 1714 1715 case MEM: 1716 gcc_assert (REG_P (src)); 1717 1718 /* Saving a register to the stack. Make sure dest is relative to the 1719 CFA register. */ 1720 switch (GET_CODE (XEXP (dest, 0))) 1721 { 1722 /* Rule 10 */ 1723 /* With a push. */ 1724 case PRE_MODIFY: 1725 /* We can't handle variable size modifications. */ 1726 gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1)) 1727 == CONST_INT); 1728 offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1)); 1729 1730 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM 1731 && cfa_store.reg == STACK_POINTER_REGNUM); 1732 1733 cfa_store.offset += offset; 1734 if (cfa.reg == STACK_POINTER_REGNUM) 1735 cfa.offset = cfa_store.offset; 1736 1737 offset = -cfa_store.offset; 1738 break; 1739 1740 /* Rule 11 */ 1741 case PRE_INC: 1742 case PRE_DEC: 1743 offset = GET_MODE_SIZE (GET_MODE (dest)); 1744 if (GET_CODE (XEXP (dest, 0)) == PRE_INC) 1745 offset = -offset; 1746 1747 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM 1748 && cfa_store.reg == STACK_POINTER_REGNUM); 1749 1750 cfa_store.offset += offset; 1751 if (cfa.reg == STACK_POINTER_REGNUM) 1752 cfa.offset = cfa_store.offset; 1753 1754 offset = -cfa_store.offset; 1755 break; 1756 1757 /* Rule 12 */ 1758 /* With an offset. */ 1759 case PLUS: 1760 case MINUS: 1761 case LO_SUM: 1762 { 1763 int regno; 1764 1765 gcc_assert (GET_CODE (XEXP (XEXP (dest, 0), 1)) == CONST_INT 1766 && REG_P (XEXP (XEXP (dest, 0), 0))); 1767 offset = INTVAL (XEXP (XEXP (dest, 0), 1)); 1768 if (GET_CODE (XEXP (dest, 0)) == MINUS) 1769 offset = -offset; 1770 1771 regno = REGNO (XEXP (XEXP (dest, 0), 0)); 1772 1773 if (cfa_store.reg == (unsigned) regno) 1774 offset -= cfa_store.offset; 1775 else 1776 { 1777 gcc_assert (cfa_temp.reg == (unsigned) regno); 1778 offset -= cfa_temp.offset; 1779 } 1780 } 1781 break; 1782 1783 /* Rule 13 */ 1784 /* Without an offset. */ 1785 case REG: 1786 { 1787 int regno = REGNO (XEXP (dest, 0)); 1788 1789 if (cfa_store.reg == (unsigned) regno) 1790 offset = -cfa_store.offset; 1791 else 1792 { 1793 gcc_assert (cfa_temp.reg == (unsigned) regno); 1794 offset = -cfa_temp.offset; 1795 } 1796 } 1797 break; 1798 1799 /* Rule 14 */ 1800 case POST_INC: 1801 gcc_assert (cfa_temp.reg 1802 == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0))); 1803 offset = -cfa_temp.offset; 1804 cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest)); 1805 break; 1806 1807 default: 1808 gcc_unreachable (); 1809 } 1810 1811 if (REGNO (src) != STACK_POINTER_REGNUM 1812 && REGNO (src) != HARD_FRAME_POINTER_REGNUM 1813 && (unsigned) REGNO (src) == cfa.reg) 1814 { 1815 /* We're storing the current CFA reg into the stack. */ 1816 1817 if (cfa.offset == 0) 1818 { 1819 /* If the source register is exactly the CFA, assume 1820 we're saving SP like any other register; this happens 1821 on the ARM. */ 1822 def_cfa_1 (label, &cfa); 1823 queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset); 1824 break; 1825 } 1826 else 1827 { 1828 /* Otherwise, we'll need to look in the stack to 1829 calculate the CFA. */ 1830 rtx x = XEXP (dest, 0); 1831 1832 if (!REG_P (x)) 1833 x = XEXP (x, 0); 1834 gcc_assert (REG_P (x)); 1835 1836 cfa.reg = REGNO (x); 1837 cfa.base_offset = offset; 1838 cfa.indirect = 1; 1839 def_cfa_1 (label, &cfa); 1840 break; 1841 } 1842 } 1843 1844 def_cfa_1 (label, &cfa); 1845 queue_reg_save (label, src, NULL_RTX, offset); 1846 break; 1847 1848 default: 1849 gcc_unreachable (); 1850 } 1851} 1852 1853/* Record call frame debugging information for INSN, which either 1854 sets SP or FP (adjusting how we calculate the frame address) or saves a 1855 register to the stack. If INSN is NULL_RTX, initialize our state. 1856 1857 If AFTER_P is false, we're being called before the insn is emitted, 1858 otherwise after. Call instructions get invoked twice. */ 1859 1860void 1861dwarf2out_frame_debug (rtx insn, bool after_p) 1862{ 1863 const char *label; 1864 rtx src; 1865 1866 if (insn == NULL_RTX) 1867 { 1868 size_t i; 1869 1870 /* Flush any queued register saves. */ 1871 flush_queued_reg_saves (); 1872 1873 /* Set up state for generating call frame debug info. */ 1874 lookup_cfa (&cfa); 1875 gcc_assert (cfa.reg 1876 == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM)); 1877 1878 cfa.reg = STACK_POINTER_REGNUM; 1879 cfa_store = cfa; 1880 cfa_temp.reg = -1; 1881 cfa_temp.offset = 0; 1882 1883 for (i = 0; i < num_regs_saved_in_regs; i++) 1884 { 1885 regs_saved_in_regs[i].orig_reg = NULL_RTX; 1886 regs_saved_in_regs[i].saved_in_reg = NULL_RTX; 1887 } 1888 num_regs_saved_in_regs = 0; 1889 return; 1890 } 1891 1892 if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn)) 1893 flush_queued_reg_saves (); 1894 1895 if (! RTX_FRAME_RELATED_P (insn)) 1896 { 1897 if (!ACCUMULATE_OUTGOING_ARGS) 1898 dwarf2out_stack_adjust (insn, after_p); 1899 return; 1900 } 1901 1902 label = dwarf2out_cfi_label (); 1903 src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX); 1904 if (src) 1905 insn = XEXP (src, 0); 1906 else 1907 insn = PATTERN (insn); 1908 1909 dwarf2out_frame_debug_expr (insn, label); 1910} 1911 1912#endif 1913 1914/* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */ 1915static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc 1916 (enum dwarf_call_frame_info cfi); 1917 1918static enum dw_cfi_oprnd_type 1919dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi) 1920{ 1921 switch (cfi) 1922 { 1923 case DW_CFA_nop: 1924 case DW_CFA_GNU_window_save: 1925 return dw_cfi_oprnd_unused; 1926 1927 case DW_CFA_set_loc: 1928 case DW_CFA_advance_loc1: 1929 case DW_CFA_advance_loc2: 1930 case DW_CFA_advance_loc4: 1931 case DW_CFA_MIPS_advance_loc8: 1932 return dw_cfi_oprnd_addr; 1933 1934 case DW_CFA_offset: 1935 case DW_CFA_offset_extended: 1936 case DW_CFA_def_cfa: 1937 case DW_CFA_offset_extended_sf: 1938 case DW_CFA_def_cfa_sf: 1939 case DW_CFA_restore_extended: 1940 case DW_CFA_undefined: 1941 case DW_CFA_same_value: 1942 case DW_CFA_def_cfa_register: 1943 case DW_CFA_register: 1944 return dw_cfi_oprnd_reg_num; 1945 1946 case DW_CFA_def_cfa_offset: 1947 case DW_CFA_GNU_args_size: 1948 case DW_CFA_def_cfa_offset_sf: 1949 return dw_cfi_oprnd_offset; 1950 1951 case DW_CFA_def_cfa_expression: 1952 case DW_CFA_expression: 1953 return dw_cfi_oprnd_loc; 1954 1955 default: 1956 gcc_unreachable (); 1957 } 1958} 1959 1960/* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */ 1961static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc 1962 (enum dwarf_call_frame_info cfi); 1963 1964static enum dw_cfi_oprnd_type 1965dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi) 1966{ 1967 switch (cfi) 1968 { 1969 case DW_CFA_def_cfa: 1970 case DW_CFA_def_cfa_sf: 1971 case DW_CFA_offset: 1972 case DW_CFA_offset_extended_sf: 1973 case DW_CFA_offset_extended: 1974 return dw_cfi_oprnd_offset; 1975 1976 case DW_CFA_register: 1977 return dw_cfi_oprnd_reg_num; 1978 1979 default: 1980 return dw_cfi_oprnd_unused; 1981 } 1982} 1983 1984#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 1985 1986/* Switch to eh_frame_section. If we don't have an eh_frame_section, 1987 switch to the data section instead, and write out a synthetic label 1988 for collect2. */ 1989 1990static void 1991switch_to_eh_frame_section (void) 1992{ 1993 tree label; 1994 1995#ifdef EH_FRAME_SECTION_NAME 1996 if (eh_frame_section == 0) 1997 { 1998 int flags; 1999 2000 if (EH_TABLES_CAN_BE_READ_ONLY) 2001 { 2002 int fde_encoding; 2003 int per_encoding; 2004 int lsda_encoding; 2005 2006 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, 2007 /*global=*/0); 2008 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, 2009 /*global=*/1); 2010 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, 2011 /*global=*/0); 2012 flags = ((! flag_pic 2013 || ((fde_encoding & 0x70) != DW_EH_PE_absptr 2014 && (fde_encoding & 0x70) != DW_EH_PE_aligned 2015 && (per_encoding & 0x70) != DW_EH_PE_absptr 2016 && (per_encoding & 0x70) != DW_EH_PE_aligned 2017 && (lsda_encoding & 0x70) != DW_EH_PE_absptr 2018 && (lsda_encoding & 0x70) != DW_EH_PE_aligned)) 2019 ? 0 : SECTION_WRITE); 2020 } 2021 else 2022 flags = SECTION_WRITE; 2023 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL); 2024 } 2025#endif 2026 2027 if (eh_frame_section) 2028 switch_to_section (eh_frame_section); 2029 else 2030 { 2031 /* We have no special eh_frame section. Put the information in 2032 the data section and emit special labels to guide collect2. */ 2033 switch_to_section (data_section); 2034 label = get_file_function_name ("F"); 2035 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE)); 2036 targetm.asm_out.globalize_label (asm_out_file, 2037 IDENTIFIER_POINTER (label)); 2038 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label)); 2039 } 2040} 2041 2042/* Output a Call Frame Information opcode and its operand(s). */ 2043 2044static void 2045output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh) 2046{ 2047 unsigned long r; 2048 if (cfi->dw_cfi_opc == DW_CFA_advance_loc) 2049 dw2_asm_output_data (1, (cfi->dw_cfi_opc 2050 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)), 2051 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX, 2052 cfi->dw_cfi_oprnd1.dw_cfi_offset); 2053 else if (cfi->dw_cfi_opc == DW_CFA_offset) 2054 { 2055 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2056 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)), 2057 "DW_CFA_offset, column 0x%lx", r); 2058 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL); 2059 } 2060 else if (cfi->dw_cfi_opc == DW_CFA_restore) 2061 { 2062 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2063 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)), 2064 "DW_CFA_restore, column 0x%lx", r); 2065 } 2066 else 2067 { 2068 dw2_asm_output_data (1, cfi->dw_cfi_opc, 2069 "%s", dwarf_cfi_name (cfi->dw_cfi_opc)); 2070 2071 switch (cfi->dw_cfi_opc) 2072 { 2073 case DW_CFA_set_loc: 2074 if (for_eh) 2075 dw2_asm_output_encoded_addr_rtx ( 2076 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0), 2077 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr), 2078 false, NULL); 2079 else 2080 dw2_asm_output_addr (DWARF2_ADDR_SIZE, 2081 cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL); 2082 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 2083 break; 2084 2085 case DW_CFA_advance_loc1: 2086 dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr, 2087 fde->dw_fde_current_label, NULL); 2088 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 2089 break; 2090 2091 case DW_CFA_advance_loc2: 2092 dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr, 2093 fde->dw_fde_current_label, NULL); 2094 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 2095 break; 2096 2097 case DW_CFA_advance_loc4: 2098 dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr, 2099 fde->dw_fde_current_label, NULL); 2100 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 2101 break; 2102 2103 case DW_CFA_MIPS_advance_loc8: 2104 dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr, 2105 fde->dw_fde_current_label, NULL); 2106 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 2107 break; 2108 2109 case DW_CFA_offset_extended: 2110 case DW_CFA_def_cfa: 2111 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2112 dw2_asm_output_data_uleb128 (r, NULL); 2113 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL); 2114 break; 2115 2116 case DW_CFA_offset_extended_sf: 2117 case DW_CFA_def_cfa_sf: 2118 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2119 dw2_asm_output_data_uleb128 (r, NULL); 2120 dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL); 2121 break; 2122 2123 case DW_CFA_restore_extended: 2124 case DW_CFA_undefined: 2125 case DW_CFA_same_value: 2126 case DW_CFA_def_cfa_register: 2127 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2128 dw2_asm_output_data_uleb128 (r, NULL); 2129 break; 2130 2131 case DW_CFA_register: 2132 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2133 dw2_asm_output_data_uleb128 (r, NULL); 2134 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh); 2135 dw2_asm_output_data_uleb128 (r, NULL); 2136 break; 2137 2138 case DW_CFA_def_cfa_offset: 2139 case DW_CFA_GNU_args_size: 2140 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL); 2141 break; 2142 2143 case DW_CFA_def_cfa_offset_sf: 2144 dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL); 2145 break; 2146 2147 case DW_CFA_GNU_window_save: 2148 break; 2149 2150 case DW_CFA_def_cfa_expression: 2151 case DW_CFA_expression: 2152 output_cfa_loc (cfi); 2153 break; 2154 2155 case DW_CFA_GNU_negative_offset_extended: 2156 /* Obsoleted by DW_CFA_offset_extended_sf. */ 2157 gcc_unreachable (); 2158 2159 default: 2160 break; 2161 } 2162 } 2163} 2164 2165/* Output the call frame information used to record information 2166 that relates to calculating the frame pointer, and records the 2167 location of saved registers. */ 2168 2169static void 2170output_call_frame_info (int for_eh) 2171{ 2172 unsigned int i; 2173 dw_fde_ref fde; 2174 dw_cfi_ref cfi; 2175 char l1[20], l2[20], section_start_label[20]; 2176 bool any_lsda_needed = false; 2177 char augmentation[6]; 2178 int augmentation_size; 2179 int fde_encoding = DW_EH_PE_absptr; 2180 int per_encoding = DW_EH_PE_absptr; 2181 int lsda_encoding = DW_EH_PE_absptr; 2182 int return_reg; 2183 2184 /* Don't emit a CIE if there won't be any FDEs. */ 2185 if (fde_table_in_use == 0) 2186 return; 2187 2188 /* If we make FDEs linkonce, we may have to emit an empty label for 2189 an FDE that wouldn't otherwise be emitted. We want to avoid 2190 having an FDE kept around when the function it refers to is 2191 discarded. Example where this matters: a primary function 2192 template in C++ requires EH information, but an explicit 2193 specialization doesn't. */ 2194 if (TARGET_USES_WEAK_UNWIND_INFO 2195 && ! flag_asynchronous_unwind_tables 2196/* APPLE LOCAL begin for-fsf-4_4 5480287 */ \ 2197 && flag_exceptions 2198/* APPLE LOCAL end for-fsf-4_4 5480287 */ \ 2199 && for_eh) 2200 for (i = 0; i < fde_table_in_use; i++) 2201 if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls) 2202 && !fde_table[i].uses_eh_lsda 2203 && ! DECL_WEAK (fde_table[i].decl)) 2204 targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl, 2205 for_eh, /* empty */ 1); 2206 2207 /* If we don't have any functions we'll want to unwind out of, don't 2208 emit any EH unwind information. Note that if exceptions aren't 2209 enabled, we won't have collected nothrow information, and if we 2210 asked for asynchronous tables, we always want this info. */ 2211 if (for_eh) 2212 { 2213 bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables; 2214 2215 for (i = 0; i < fde_table_in_use; i++) 2216 if (fde_table[i].uses_eh_lsda) 2217 any_eh_needed = any_lsda_needed = true; 2218 else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl)) 2219 any_eh_needed = true; 2220 else if (! fde_table[i].nothrow 2221 && ! fde_table[i].all_throwers_are_sibcalls) 2222 any_eh_needed = true; 2223 2224 if (! any_eh_needed) 2225 return; 2226 } 2227 2228 /* We're going to be generating comments, so turn on app. */ 2229 if (flag_debug_asm) 2230 app_enable (); 2231 2232 if (for_eh) 2233 switch_to_eh_frame_section (); 2234 else 2235 { 2236 if (!debug_frame_section) 2237 debug_frame_section = get_section (DEBUG_FRAME_SECTION, 2238 SECTION_DEBUG, NULL); 2239 switch_to_section (debug_frame_section); 2240 } 2241 2242 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh); 2243 ASM_OUTPUT_LABEL (asm_out_file, section_start_label); 2244 2245 /* Output the CIE. */ 2246 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh); 2247 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh); 2248 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh) 2249 dw2_asm_output_data (4, 0xffffffff, 2250 "Initial length escape value indicating 64-bit DWARF extension"); 2251 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1, 2252 "Length of Common Information Entry"); 2253 ASM_OUTPUT_LABEL (asm_out_file, l1); 2254 2255 /* Now that the CIE pointer is PC-relative for EH, 2256 use 0 to identify the CIE. */ 2257 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE), 2258 (for_eh ? 0 : DWARF_CIE_ID), 2259 "CIE Identifier Tag"); 2260 2261 dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version"); 2262 2263 augmentation[0] = 0; 2264 augmentation_size = 0; 2265 if (for_eh) 2266 { 2267 char *p; 2268 2269 /* Augmentation: 2270 z Indicates that a uleb128 is present to size the 2271 augmentation section. 2272 L Indicates the encoding (and thus presence) of 2273 an LSDA pointer in the FDE augmentation. 2274 R Indicates a non-default pointer encoding for 2275 FDE code pointers. 2276 P Indicates the presence of an encoding + language 2277 personality routine in the CIE augmentation. */ 2278 2279 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0); 2280 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1); 2281 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0); 2282 2283 p = augmentation + 1; 2284 if (eh_personality_libfunc) 2285 { 2286 *p++ = 'P'; 2287 augmentation_size += 1 + size_of_encoded_value (per_encoding); 2288 } 2289 if (any_lsda_needed) 2290 { 2291 *p++ = 'L'; 2292 augmentation_size += 1; 2293 } 2294 if (fde_encoding != DW_EH_PE_absptr) 2295 { 2296 *p++ = 'R'; 2297 augmentation_size += 1; 2298 } 2299 if (p > augmentation + 1) 2300 { 2301 augmentation[0] = 'z'; 2302 *p = '\0'; 2303 } 2304 2305 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */ 2306 if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned) 2307 { 2308 int offset = ( 4 /* Length */ 2309 + 4 /* CIE Id */ 2310 + 1 /* CIE version */ 2311 + strlen (augmentation) + 1 /* Augmentation */ 2312 + size_of_uleb128 (1) /* Code alignment */ 2313 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT) 2314 + 1 /* RA column */ 2315 + 1 /* Augmentation size */ 2316 + 1 /* Personality encoding */ ); 2317 int pad = -offset & (PTR_SIZE - 1); 2318 2319 augmentation_size += pad; 2320 2321 /* Augmentations should be small, so there's scarce need to 2322 iterate for a solution. Die if we exceed one uleb128 byte. */ 2323 gcc_assert (size_of_uleb128 (augmentation_size) == 1); 2324 } 2325 } 2326 2327 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation"); 2328 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor"); 2329 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT, 2330 "CIE Data Alignment Factor"); 2331 2332 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh); 2333 if (DW_CIE_VERSION == 1) 2334 dw2_asm_output_data (1, return_reg, "CIE RA Column"); 2335 else 2336 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column"); 2337 2338 if (augmentation[0]) 2339 { 2340 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size"); 2341 if (eh_personality_libfunc) 2342 { 2343 dw2_asm_output_data (1, per_encoding, "Personality (%s)", 2344 eh_data_format_name (per_encoding)); 2345 dw2_asm_output_encoded_addr_rtx (per_encoding, 2346 eh_personality_libfunc, 2347 true, NULL); 2348 } 2349 2350 if (any_lsda_needed) 2351 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)", 2352 eh_data_format_name (lsda_encoding)); 2353 2354 if (fde_encoding != DW_EH_PE_absptr) 2355 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)", 2356 eh_data_format_name (fde_encoding)); 2357 } 2358 2359 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next) 2360 output_cfi (cfi, NULL, for_eh); 2361 2362 /* Pad the CIE out to an address sized boundary. */ 2363 ASM_OUTPUT_ALIGN (asm_out_file, 2364 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)); 2365 ASM_OUTPUT_LABEL (asm_out_file, l2); 2366 2367 /* Loop through all of the FDE's. */ 2368 for (i = 0; i < fde_table_in_use; i++) 2369 { 2370 fde = &fde_table[i]; 2371 2372 /* Don't emit EH unwind info for leaf functions that don't need it. */ 2373 if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions 2374 && (fde->nothrow || fde->all_throwers_are_sibcalls) 2375 && ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl)) 2376 && !fde->uses_eh_lsda) 2377 continue; 2378 2379 targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh, /* empty */ 0); 2380 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL, for_eh + i * 2); 2381 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2); 2382 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2); 2383 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh) 2384 dw2_asm_output_data (4, 0xffffffff, 2385 "Initial length escape value indicating 64-bit DWARF extension"); 2386 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1, 2387 "FDE Length"); 2388 ASM_OUTPUT_LABEL (asm_out_file, l1); 2389 2390 if (for_eh) 2391 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset"); 2392 else 2393 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label, 2394 debug_frame_section, "FDE CIE offset"); 2395 2396 if (for_eh) 2397 { 2398 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin); 2399 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL; 2400 dw2_asm_output_encoded_addr_rtx (fde_encoding, 2401 sym_ref, 2402 false, 2403 "FDE initial location"); 2404 if (fde->dw_fde_switched_sections) 2405 { 2406 rtx sym_ref2 = gen_rtx_SYMBOL_REF (Pmode, 2407 fde->dw_fde_unlikely_section_label); 2408 rtx sym_ref3= gen_rtx_SYMBOL_REF (Pmode, 2409 fde->dw_fde_hot_section_label); 2410 SYMBOL_REF_FLAGS (sym_ref2) |= SYMBOL_FLAG_LOCAL; 2411 SYMBOL_REF_FLAGS (sym_ref3) |= SYMBOL_FLAG_LOCAL; 2412 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref3, false, 2413 "FDE initial location"); 2414 dw2_asm_output_delta (size_of_encoded_value (fde_encoding), 2415 fde->dw_fde_hot_section_end_label, 2416 fde->dw_fde_hot_section_label, 2417 "FDE address range"); 2418 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref2, false, 2419 "FDE initial location"); 2420 dw2_asm_output_delta (size_of_encoded_value (fde_encoding), 2421 fde->dw_fde_unlikely_section_end_label, 2422 fde->dw_fde_unlikely_section_label, 2423 "FDE address range"); 2424 } 2425 else 2426 dw2_asm_output_delta (size_of_encoded_value (fde_encoding), 2427 fde->dw_fde_end, fde->dw_fde_begin, 2428 "FDE address range"); 2429 } 2430 else 2431 { 2432 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin, 2433 "FDE initial location"); 2434 if (fde->dw_fde_switched_sections) 2435 { 2436 dw2_asm_output_addr (DWARF2_ADDR_SIZE, 2437 fde->dw_fde_hot_section_label, 2438 "FDE initial location"); 2439 dw2_asm_output_delta (DWARF2_ADDR_SIZE, 2440 fde->dw_fde_hot_section_end_label, 2441 fde->dw_fde_hot_section_label, 2442 "FDE address range"); 2443 dw2_asm_output_addr (DWARF2_ADDR_SIZE, 2444 fde->dw_fde_unlikely_section_label, 2445 "FDE initial location"); 2446 dw2_asm_output_delta (DWARF2_ADDR_SIZE, 2447 fde->dw_fde_unlikely_section_end_label, 2448 fde->dw_fde_unlikely_section_label, 2449 "FDE address range"); 2450 } 2451 else 2452 dw2_asm_output_delta (DWARF2_ADDR_SIZE, 2453 fde->dw_fde_end, fde->dw_fde_begin, 2454 "FDE address range"); 2455 } 2456 2457 if (augmentation[0]) 2458 { 2459 if (any_lsda_needed) 2460 { 2461 int size = size_of_encoded_value (lsda_encoding); 2462 2463 if (lsda_encoding == DW_EH_PE_aligned) 2464 { 2465 int offset = ( 4 /* Length */ 2466 + 4 /* CIE offset */ 2467 + 2 * size_of_encoded_value (fde_encoding) 2468 + 1 /* Augmentation size */ ); 2469 int pad = -offset & (PTR_SIZE - 1); 2470 2471 size += pad; 2472 gcc_assert (size_of_uleb128 (size) == 1); 2473 } 2474 2475 dw2_asm_output_data_uleb128 (size, "Augmentation size"); 2476 2477 if (fde->uses_eh_lsda) 2478 { 2479 ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA", 2480 fde->funcdef_number); 2481 dw2_asm_output_encoded_addr_rtx ( 2482 lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1), 2483 false, "Language Specific Data Area"); 2484 } 2485 else 2486 { 2487 if (lsda_encoding == DW_EH_PE_aligned) 2488 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE)); 2489 dw2_asm_output_data 2490 (size_of_encoded_value (lsda_encoding), 0, 2491 "Language Specific Data Area (none)"); 2492 } 2493 } 2494 else 2495 dw2_asm_output_data_uleb128 (0, "Augmentation size"); 2496 } 2497 2498 /* Loop through the Call Frame Instructions associated with 2499 this FDE. */ 2500 fde->dw_fde_current_label = fde->dw_fde_begin; 2501 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next) 2502 output_cfi (cfi, fde, for_eh); 2503 2504 /* Pad the FDE out to an address sized boundary. */ 2505 ASM_OUTPUT_ALIGN (asm_out_file, 2506 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE))); 2507 ASM_OUTPUT_LABEL (asm_out_file, l2); 2508 } 2509 2510 if (for_eh && targetm.terminate_dw2_eh_frame_info) 2511 dw2_asm_output_data (4, 0, "End of Table"); 2512#ifdef MIPS_DEBUGGING_INFO 2513 /* Work around Irix 6 assembler bug whereby labels at the end of a section 2514 get a value of 0. Putting .align 0 after the label fixes it. */ 2515 ASM_OUTPUT_ALIGN (asm_out_file, 0); 2516#endif 2517 2518 /* Turn off app to make assembly quicker. */ 2519 if (flag_debug_asm) 2520 app_disable (); 2521} 2522 2523/* Output a marker (i.e. a label) for the beginning of a function, before 2524 the prologue. */ 2525 2526void 2527dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED, 2528 const char *file ATTRIBUTE_UNUSED) 2529{ 2530 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 2531 char * dup_label; 2532 dw_fde_ref fde; 2533 2534 current_function_func_begin_label = NULL; 2535 2536#ifdef TARGET_UNWIND_INFO 2537 /* ??? current_function_func_begin_label is also used by except.c 2538 for call-site information. We must emit this label if it might 2539 be used. */ 2540 if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS) 2541 && ! dwarf2out_do_frame ()) 2542 return; 2543#else 2544 if (! dwarf2out_do_frame ()) 2545 return; 2546#endif 2547 2548 switch_to_section (function_section (current_function_decl)); 2549 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL, 2550 current_function_funcdef_no); 2551 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL, 2552 current_function_funcdef_no); 2553 dup_label = xstrdup (label); 2554 current_function_func_begin_label = dup_label; 2555 2556#ifdef TARGET_UNWIND_INFO 2557 /* We can elide the fde allocation if we're not emitting debug info. */ 2558 if (! dwarf2out_do_frame ()) 2559 return; 2560#endif 2561 2562 /* Expand the fde table if necessary. */ 2563 if (fde_table_in_use == fde_table_allocated) 2564 { 2565 fde_table_allocated += FDE_TABLE_INCREMENT; 2566 fde_table = ggc_realloc (fde_table, 2567 fde_table_allocated * sizeof (dw_fde_node)); 2568 memset (fde_table + fde_table_in_use, 0, 2569 FDE_TABLE_INCREMENT * sizeof (dw_fde_node)); 2570 } 2571 2572 /* Record the FDE associated with this function. */ 2573 current_funcdef_fde = fde_table_in_use; 2574 2575 /* Add the new FDE at the end of the fde_table. */ 2576 fde = &fde_table[fde_table_in_use++]; 2577 fde->decl = current_function_decl; 2578 fde->dw_fde_begin = dup_label; 2579 fde->dw_fde_current_label = dup_label; 2580 fde->dw_fde_hot_section_label = NULL; 2581 fde->dw_fde_hot_section_end_label = NULL; 2582 fde->dw_fde_unlikely_section_label = NULL; 2583 fde->dw_fde_unlikely_section_end_label = NULL; 2584 fde->dw_fde_switched_sections = false; 2585 fde->dw_fde_end = NULL; 2586 fde->dw_fde_cfi = NULL; 2587 fde->funcdef_number = current_function_funcdef_no; 2588 fde->nothrow = TREE_NOTHROW (current_function_decl); 2589 fde->uses_eh_lsda = cfun->uses_eh_lsda; 2590 fde->all_throwers_are_sibcalls = cfun->all_throwers_are_sibcalls; 2591 2592 args_size = old_args_size = 0; 2593 2594 /* We only want to output line number information for the genuine dwarf2 2595 prologue case, not the eh frame case. */ 2596#ifdef DWARF2_DEBUGGING_INFO 2597 if (file) 2598 dwarf2out_source_line (line, file); 2599#endif 2600} 2601 2602/* Output a marker (i.e. a label) for the absolute end of the generated code 2603 for a function definition. This gets called *after* the epilogue code has 2604 been generated. */ 2605 2606void 2607dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED, 2608 const char *file ATTRIBUTE_UNUSED) 2609{ 2610 dw_fde_ref fde; 2611 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 2612 2613 /* Output a label to mark the endpoint of the code generated for this 2614 function. */ 2615 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL, 2616 current_function_funcdef_no); 2617 ASM_OUTPUT_LABEL (asm_out_file, label); 2618 fde = &fde_table[fde_table_in_use - 1]; 2619 fde->dw_fde_end = xstrdup (label); 2620} 2621 2622void 2623dwarf2out_frame_init (void) 2624{ 2625 /* Allocate the initial hunk of the fde_table. */ 2626 fde_table = ggc_alloc_cleared (FDE_TABLE_INCREMENT * sizeof (dw_fde_node)); 2627 fde_table_allocated = FDE_TABLE_INCREMENT; 2628 fde_table_in_use = 0; 2629 2630 /* Generate the CFA instructions common to all FDE's. Do it now for the 2631 sake of lookup_cfa. */ 2632 2633 /* On entry, the Canonical Frame Address is at SP. */ 2634 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET); 2635 2636#ifdef DWARF2_UNWIND_INFO 2637 if (DWARF2_UNWIND_INFO) 2638 initial_return_save (INCOMING_RETURN_ADDR_RTX); 2639#endif 2640} 2641 2642void 2643dwarf2out_frame_finish (void) 2644{ 2645 /* Output call frame information. */ 2646 if (DWARF2_FRAME_INFO) 2647 output_call_frame_info (0); 2648 2649#ifndef TARGET_UNWIND_INFO 2650 /* Output another copy for the unwinder. */ 2651 if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions)) 2652 output_call_frame_info (1); 2653#endif 2654} 2655#endif 2656 2657/* And now, the subset of the debugging information support code necessary 2658 for emitting location expressions. */ 2659 2660/* Data about a single source file. */ 2661struct dwarf_file_data GTY(()) 2662{ 2663 const char * filename; 2664 int emitted_number; 2665}; 2666 2667/* We need some way to distinguish DW_OP_addr with a direct symbol 2668 relocation from DW_OP_addr with a dtp-relative symbol relocation. */ 2669#define INTERNAL_DW_OP_tls_addr (0x100 + DW_OP_addr) 2670 2671 2672typedef struct dw_val_struct *dw_val_ref; 2673typedef struct die_struct *dw_die_ref; 2674typedef struct dw_loc_descr_struct *dw_loc_descr_ref; 2675typedef struct dw_loc_list_struct *dw_loc_list_ref; 2676 2677/* Each DIE may have a series of attribute/value pairs. Values 2678 can take on several forms. The forms that are used in this 2679 implementation are listed below. */ 2680 2681enum dw_val_class 2682{ 2683 dw_val_class_addr, 2684 dw_val_class_offset, 2685 dw_val_class_loc, 2686 dw_val_class_loc_list, 2687 dw_val_class_range_list, 2688 dw_val_class_const, 2689 dw_val_class_unsigned_const, 2690 dw_val_class_long_long, 2691 dw_val_class_vec, 2692 dw_val_class_flag, 2693 dw_val_class_die_ref, 2694 dw_val_class_fde_ref, 2695 dw_val_class_lbl_id, 2696 dw_val_class_lineptr, 2697 dw_val_class_str, 2698 dw_val_class_macptr, 2699 dw_val_class_file 2700}; 2701 2702/* Describe a double word constant value. */ 2703/* ??? Every instance of long_long in the code really means CONST_DOUBLE. */ 2704 2705typedef struct dw_long_long_struct GTY(()) 2706{ 2707 unsigned long hi; 2708 unsigned long low; 2709} 2710dw_long_long_const; 2711 2712/* Describe a floating point constant value, or a vector constant value. */ 2713 2714typedef struct dw_vec_struct GTY(()) 2715{ 2716 unsigned char * GTY((length ("%h.length"))) array; 2717 unsigned length; 2718 unsigned elt_size; 2719} 2720dw_vec_const; 2721 2722/* The dw_val_node describes an attribute's value, as it is 2723 represented internally. */ 2724 2725typedef struct dw_val_struct GTY(()) 2726{ 2727 enum dw_val_class val_class; 2728 union dw_val_struct_union 2729 { 2730 rtx GTY ((tag ("dw_val_class_addr"))) val_addr; 2731 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset; 2732 dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list; 2733 dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc; 2734 HOST_WIDE_INT GTY ((default)) val_int; 2735 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned; 2736 dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long; 2737 dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec; 2738 struct dw_val_die_union 2739 { 2740 dw_die_ref die; 2741 int external; 2742 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref; 2743 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index; 2744 struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str; 2745 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id; 2746 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag; 2747 struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file; 2748 } 2749 GTY ((desc ("%1.val_class"))) v; 2750} 2751dw_val_node; 2752 2753/* Locations in memory are described using a sequence of stack machine 2754 operations. */ 2755 2756typedef struct dw_loc_descr_struct GTY(()) 2757{ 2758 dw_loc_descr_ref dw_loc_next; 2759 enum dwarf_location_atom dw_loc_opc; 2760 dw_val_node dw_loc_oprnd1; 2761 dw_val_node dw_loc_oprnd2; 2762 int dw_loc_addr; 2763} 2764dw_loc_descr_node; 2765 2766/* Location lists are ranges + location descriptions for that range, 2767 so you can track variables that are in different places over 2768 their entire life. */ 2769typedef struct dw_loc_list_struct GTY(()) 2770{ 2771 dw_loc_list_ref dw_loc_next; 2772 const char *begin; /* Label for begin address of range */ 2773 const char *end; /* Label for end address of range */ 2774 char *ll_symbol; /* Label for beginning of location list. 2775 Only on head of list */ 2776 const char *section; /* Section this loclist is relative to */ 2777 dw_loc_descr_ref expr; 2778} dw_loc_list_node; 2779 2780#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 2781 2782static const char *dwarf_stack_op_name (unsigned); 2783static dw_loc_descr_ref new_loc_descr (enum dwarf_location_atom, 2784 unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT); 2785static void add_loc_descr (dw_loc_descr_ref *, dw_loc_descr_ref); 2786static unsigned long size_of_loc_descr (dw_loc_descr_ref); 2787static unsigned long size_of_locs (dw_loc_descr_ref); 2788static void output_loc_operands (dw_loc_descr_ref); 2789static void output_loc_sequence (dw_loc_descr_ref); 2790 2791/* Convert a DWARF stack opcode into its string name. */ 2792 2793static const char * 2794dwarf_stack_op_name (unsigned int op) 2795{ 2796 switch (op) 2797 { 2798 case DW_OP_addr: 2799 case INTERNAL_DW_OP_tls_addr: 2800 return "DW_OP_addr"; 2801 case DW_OP_deref: 2802 return "DW_OP_deref"; 2803 case DW_OP_const1u: 2804 return "DW_OP_const1u"; 2805 case DW_OP_const1s: 2806 return "DW_OP_const1s"; 2807 case DW_OP_const2u: 2808 return "DW_OP_const2u"; 2809 case DW_OP_const2s: 2810 return "DW_OP_const2s"; 2811 case DW_OP_const4u: 2812 return "DW_OP_const4u"; 2813 case DW_OP_const4s: 2814 return "DW_OP_const4s"; 2815 case DW_OP_const8u: 2816 return "DW_OP_const8u"; 2817 case DW_OP_const8s: 2818 return "DW_OP_const8s"; 2819 case DW_OP_constu: 2820 return "DW_OP_constu"; 2821 case DW_OP_consts: 2822 return "DW_OP_consts"; 2823 case DW_OP_dup: 2824 return "DW_OP_dup"; 2825 case DW_OP_drop: 2826 return "DW_OP_drop"; 2827 case DW_OP_over: 2828 return "DW_OP_over"; 2829 case DW_OP_pick: 2830 return "DW_OP_pick"; 2831 case DW_OP_swap: 2832 return "DW_OP_swap"; 2833 case DW_OP_rot: 2834 return "DW_OP_rot"; 2835 case DW_OP_xderef: 2836 return "DW_OP_xderef"; 2837 case DW_OP_abs: 2838 return "DW_OP_abs"; 2839 case DW_OP_and: 2840 return "DW_OP_and"; 2841 case DW_OP_div: 2842 return "DW_OP_div"; 2843 case DW_OP_minus: 2844 return "DW_OP_minus"; 2845 case DW_OP_mod: 2846 return "DW_OP_mod"; 2847 case DW_OP_mul: 2848 return "DW_OP_mul"; 2849 case DW_OP_neg: 2850 return "DW_OP_neg"; 2851 case DW_OP_not: 2852 return "DW_OP_not"; 2853 case DW_OP_or: 2854 return "DW_OP_or"; 2855 case DW_OP_plus: 2856 return "DW_OP_plus"; 2857 case DW_OP_plus_uconst: 2858 return "DW_OP_plus_uconst"; 2859 case DW_OP_shl: 2860 return "DW_OP_shl"; 2861 case DW_OP_shr: 2862 return "DW_OP_shr"; 2863 case DW_OP_shra: 2864 return "DW_OP_shra"; 2865 case DW_OP_xor: 2866 return "DW_OP_xor"; 2867 case DW_OP_bra: 2868 return "DW_OP_bra"; 2869 case DW_OP_eq: 2870 return "DW_OP_eq"; 2871 case DW_OP_ge: 2872 return "DW_OP_ge"; 2873 case DW_OP_gt: 2874 return "DW_OP_gt"; 2875 case DW_OP_le: 2876 return "DW_OP_le"; 2877 case DW_OP_lt: 2878 return "DW_OP_lt"; 2879 case DW_OP_ne: 2880 return "DW_OP_ne"; 2881 case DW_OP_skip: 2882 return "DW_OP_skip"; 2883 case DW_OP_lit0: 2884 return "DW_OP_lit0"; 2885 case DW_OP_lit1: 2886 return "DW_OP_lit1"; 2887 case DW_OP_lit2: 2888 return "DW_OP_lit2"; 2889 case DW_OP_lit3: 2890 return "DW_OP_lit3"; 2891 case DW_OP_lit4: 2892 return "DW_OP_lit4"; 2893 case DW_OP_lit5: 2894 return "DW_OP_lit5"; 2895 case DW_OP_lit6: 2896 return "DW_OP_lit6"; 2897 case DW_OP_lit7: 2898 return "DW_OP_lit7"; 2899 case DW_OP_lit8: 2900 return "DW_OP_lit8"; 2901 case DW_OP_lit9: 2902 return "DW_OP_lit9"; 2903 case DW_OP_lit10: 2904 return "DW_OP_lit10"; 2905 case DW_OP_lit11: 2906 return "DW_OP_lit11"; 2907 case DW_OP_lit12: 2908 return "DW_OP_lit12"; 2909 case DW_OP_lit13: 2910 return "DW_OP_lit13"; 2911 case DW_OP_lit14: 2912 return "DW_OP_lit14"; 2913 case DW_OP_lit15: 2914 return "DW_OP_lit15"; 2915 case DW_OP_lit16: 2916 return "DW_OP_lit16"; 2917 case DW_OP_lit17: 2918 return "DW_OP_lit17"; 2919 case DW_OP_lit18: 2920 return "DW_OP_lit18"; 2921 case DW_OP_lit19: 2922 return "DW_OP_lit19"; 2923 case DW_OP_lit20: 2924 return "DW_OP_lit20"; 2925 case DW_OP_lit21: 2926 return "DW_OP_lit21"; 2927 case DW_OP_lit22: 2928 return "DW_OP_lit22"; 2929 case DW_OP_lit23: 2930 return "DW_OP_lit23"; 2931 case DW_OP_lit24: 2932 return "DW_OP_lit24"; 2933 case DW_OP_lit25: 2934 return "DW_OP_lit25"; 2935 case DW_OP_lit26: 2936 return "DW_OP_lit26"; 2937 case DW_OP_lit27: 2938 return "DW_OP_lit27"; 2939 case DW_OP_lit28: 2940 return "DW_OP_lit28"; 2941 case DW_OP_lit29: 2942 return "DW_OP_lit29"; 2943 case DW_OP_lit30: 2944 return "DW_OP_lit30"; 2945 case DW_OP_lit31: 2946 return "DW_OP_lit31"; 2947 case DW_OP_reg0: 2948 return "DW_OP_reg0"; 2949 case DW_OP_reg1: 2950 return "DW_OP_reg1"; 2951 case DW_OP_reg2: 2952 return "DW_OP_reg2"; 2953 case DW_OP_reg3: 2954 return "DW_OP_reg3"; 2955 case DW_OP_reg4: 2956 return "DW_OP_reg4"; 2957 case DW_OP_reg5: 2958 return "DW_OP_reg5"; 2959 case DW_OP_reg6: 2960 return "DW_OP_reg6"; 2961 case DW_OP_reg7: 2962 return "DW_OP_reg7"; 2963 case DW_OP_reg8: 2964 return "DW_OP_reg8"; 2965 case DW_OP_reg9: 2966 return "DW_OP_reg9"; 2967 case DW_OP_reg10: 2968 return "DW_OP_reg10"; 2969 case DW_OP_reg11: 2970 return "DW_OP_reg11"; 2971 case DW_OP_reg12: 2972 return "DW_OP_reg12"; 2973 case DW_OP_reg13: 2974 return "DW_OP_reg13"; 2975 case DW_OP_reg14: 2976 return "DW_OP_reg14"; 2977 case DW_OP_reg15: 2978 return "DW_OP_reg15"; 2979 case DW_OP_reg16: 2980 return "DW_OP_reg16"; 2981 case DW_OP_reg17: 2982 return "DW_OP_reg17"; 2983 case DW_OP_reg18: 2984 return "DW_OP_reg18"; 2985 case DW_OP_reg19: 2986 return "DW_OP_reg19"; 2987 case DW_OP_reg20: 2988 return "DW_OP_reg20"; 2989 case DW_OP_reg21: 2990 return "DW_OP_reg21"; 2991 case DW_OP_reg22: 2992 return "DW_OP_reg22"; 2993 case DW_OP_reg23: 2994 return "DW_OP_reg23"; 2995 case DW_OP_reg24: 2996 return "DW_OP_reg24"; 2997 case DW_OP_reg25: 2998 return "DW_OP_reg25"; 2999 case DW_OP_reg26: 3000 return "DW_OP_reg26"; 3001 case DW_OP_reg27: 3002 return "DW_OP_reg27"; 3003 case DW_OP_reg28: 3004 return "DW_OP_reg28"; 3005 case DW_OP_reg29: 3006 return "DW_OP_reg29"; 3007 case DW_OP_reg30: 3008 return "DW_OP_reg30"; 3009 case DW_OP_reg31: 3010 return "DW_OP_reg31"; 3011 case DW_OP_breg0: 3012 return "DW_OP_breg0"; 3013 case DW_OP_breg1: 3014 return "DW_OP_breg1"; 3015 case DW_OP_breg2: 3016 return "DW_OP_breg2"; 3017 case DW_OP_breg3: 3018 return "DW_OP_breg3"; 3019 case DW_OP_breg4: 3020 return "DW_OP_breg4"; 3021 case DW_OP_breg5: 3022 return "DW_OP_breg5"; 3023 case DW_OP_breg6: 3024 return "DW_OP_breg6"; 3025 case DW_OP_breg7: 3026 return "DW_OP_breg7"; 3027 case DW_OP_breg8: 3028 return "DW_OP_breg8"; 3029 case DW_OP_breg9: 3030 return "DW_OP_breg9"; 3031 case DW_OP_breg10: 3032 return "DW_OP_breg10"; 3033 case DW_OP_breg11: 3034 return "DW_OP_breg11"; 3035 case DW_OP_breg12: 3036 return "DW_OP_breg12"; 3037 case DW_OP_breg13: 3038 return "DW_OP_breg13"; 3039 case DW_OP_breg14: 3040 return "DW_OP_breg14"; 3041 case DW_OP_breg15: 3042 return "DW_OP_breg15"; 3043 case DW_OP_breg16: 3044 return "DW_OP_breg16"; 3045 case DW_OP_breg17: 3046 return "DW_OP_breg17"; 3047 case DW_OP_breg18: 3048 return "DW_OP_breg18"; 3049 case DW_OP_breg19: 3050 return "DW_OP_breg19"; 3051 case DW_OP_breg20: 3052 return "DW_OP_breg20"; 3053 case DW_OP_breg21: 3054 return "DW_OP_breg21"; 3055 case DW_OP_breg22: 3056 return "DW_OP_breg22"; 3057 case DW_OP_breg23: 3058 return "DW_OP_breg23"; 3059 case DW_OP_breg24: 3060 return "DW_OP_breg24"; 3061 case DW_OP_breg25: 3062 return "DW_OP_breg25"; 3063 case DW_OP_breg26: 3064 return "DW_OP_breg26"; 3065 case DW_OP_breg27: 3066 return "DW_OP_breg27"; 3067 case DW_OP_breg28: 3068 return "DW_OP_breg28"; 3069 case DW_OP_breg29: 3070 return "DW_OP_breg29"; 3071 case DW_OP_breg30: 3072 return "DW_OP_breg30"; 3073 case DW_OP_breg31: 3074 return "DW_OP_breg31"; 3075 case DW_OP_regx: 3076 return "DW_OP_regx"; 3077 case DW_OP_fbreg: 3078 return "DW_OP_fbreg"; 3079 case DW_OP_bregx: 3080 return "DW_OP_bregx"; 3081 case DW_OP_piece: 3082 return "DW_OP_piece"; 3083 case DW_OP_deref_size: 3084 return "DW_OP_deref_size"; 3085 case DW_OP_xderef_size: 3086 return "DW_OP_xderef_size"; 3087 case DW_OP_nop: 3088 return "DW_OP_nop"; 3089 case DW_OP_push_object_address: 3090 return "DW_OP_push_object_address"; 3091 case DW_OP_call2: 3092 return "DW_OP_call2"; 3093 case DW_OP_call4: 3094 return "DW_OP_call4"; 3095 case DW_OP_call_ref: 3096 return "DW_OP_call_ref"; 3097 case DW_OP_GNU_push_tls_address: 3098 return "DW_OP_GNU_push_tls_address"; 3099 default: 3100 return "OP_<unknown>"; 3101 } 3102} 3103 3104/* Return a pointer to a newly allocated location description. Location 3105 descriptions are simple expression terms that can be strung 3106 together to form more complicated location (address) descriptions. */ 3107 3108static inline dw_loc_descr_ref 3109new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1, 3110 unsigned HOST_WIDE_INT oprnd2) 3111{ 3112 dw_loc_descr_ref descr = ggc_alloc_cleared (sizeof (dw_loc_descr_node)); 3113 3114 descr->dw_loc_opc = op; 3115 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const; 3116 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1; 3117 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const; 3118 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2; 3119 3120 return descr; 3121} 3122 3123/* Add a location description term to a location description expression. */ 3124 3125static inline void 3126add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr) 3127{ 3128 dw_loc_descr_ref *d; 3129 3130 /* Find the end of the chain. */ 3131 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next) 3132 ; 3133 3134 *d = descr; 3135} 3136 3137/* Return the size of a location descriptor. */ 3138 3139static unsigned long 3140size_of_loc_descr (dw_loc_descr_ref loc) 3141{ 3142 unsigned long size = 1; 3143 3144 switch (loc->dw_loc_opc) 3145 { 3146 case DW_OP_addr: 3147 case INTERNAL_DW_OP_tls_addr: 3148 size += DWARF2_ADDR_SIZE; 3149 break; 3150 case DW_OP_const1u: 3151 case DW_OP_const1s: 3152 size += 1; 3153 break; 3154 case DW_OP_const2u: 3155 case DW_OP_const2s: 3156 size += 2; 3157 break; 3158 case DW_OP_const4u: 3159 case DW_OP_const4s: 3160 size += 4; 3161 break; 3162 case DW_OP_const8u: 3163 case DW_OP_const8s: 3164 size += 8; 3165 break; 3166 case DW_OP_constu: 3167 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 3168 break; 3169 case DW_OP_consts: 3170 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); 3171 break; 3172 case DW_OP_pick: 3173 size += 1; 3174 break; 3175 case DW_OP_plus_uconst: 3176 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 3177 break; 3178 case DW_OP_skip: 3179 case DW_OP_bra: 3180 size += 2; 3181 break; 3182 case DW_OP_breg0: 3183 case DW_OP_breg1: 3184 case DW_OP_breg2: 3185 case DW_OP_breg3: 3186 case DW_OP_breg4: 3187 case DW_OP_breg5: 3188 case DW_OP_breg6: 3189 case DW_OP_breg7: 3190 case DW_OP_breg8: 3191 case DW_OP_breg9: 3192 case DW_OP_breg10: 3193 case DW_OP_breg11: 3194 case DW_OP_breg12: 3195 case DW_OP_breg13: 3196 case DW_OP_breg14: 3197 case DW_OP_breg15: 3198 case DW_OP_breg16: 3199 case DW_OP_breg17: 3200 case DW_OP_breg18: 3201 case DW_OP_breg19: 3202 case DW_OP_breg20: 3203 case DW_OP_breg21: 3204 case DW_OP_breg22: 3205 case DW_OP_breg23: 3206 case DW_OP_breg24: 3207 case DW_OP_breg25: 3208 case DW_OP_breg26: 3209 case DW_OP_breg27: 3210 case DW_OP_breg28: 3211 case DW_OP_breg29: 3212 case DW_OP_breg30: 3213 case DW_OP_breg31: 3214 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); 3215 break; 3216 case DW_OP_regx: 3217 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 3218 break; 3219 case DW_OP_fbreg: 3220 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); 3221 break; 3222 case DW_OP_bregx: 3223 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 3224 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int); 3225 break; 3226 case DW_OP_piece: 3227 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 3228 break; 3229 case DW_OP_deref_size: 3230 case DW_OP_xderef_size: 3231 size += 1; 3232 break; 3233 case DW_OP_call2: 3234 size += 2; 3235 break; 3236 case DW_OP_call4: 3237 size += 4; 3238 break; 3239 case DW_OP_call_ref: 3240 size += DWARF2_ADDR_SIZE; 3241 break; 3242 default: 3243 break; 3244 } 3245 3246 return size; 3247} 3248 3249/* Return the size of a series of location descriptors. */ 3250 3251static unsigned long 3252size_of_locs (dw_loc_descr_ref loc) 3253{ 3254 dw_loc_descr_ref l; 3255 unsigned long size; 3256 3257 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr 3258 field, to avoid writing to a PCH file. */ 3259 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next) 3260 { 3261 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra) 3262 break; 3263 size += size_of_loc_descr (l); 3264 } 3265 if (! l) 3266 return size; 3267 3268 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next) 3269 { 3270 l->dw_loc_addr = size; 3271 size += size_of_loc_descr (l); 3272 } 3273 3274 return size; 3275} 3276 3277/* Output location description stack opcode's operands (if any). */ 3278 3279static void 3280output_loc_operands (dw_loc_descr_ref loc) 3281{ 3282 dw_val_ref val1 = &loc->dw_loc_oprnd1; 3283 dw_val_ref val2 = &loc->dw_loc_oprnd2; 3284 3285 switch (loc->dw_loc_opc) 3286 { 3287#ifdef DWARF2_DEBUGGING_INFO 3288 case DW_OP_addr: 3289 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL); 3290 break; 3291 case DW_OP_const2u: 3292 case DW_OP_const2s: 3293 dw2_asm_output_data (2, val1->v.val_int, NULL); 3294 break; 3295 case DW_OP_const4u: 3296 case DW_OP_const4s: 3297 dw2_asm_output_data (4, val1->v.val_int, NULL); 3298 break; 3299 case DW_OP_const8u: 3300 case DW_OP_const8s: 3301 gcc_assert (HOST_BITS_PER_LONG >= 64); 3302 dw2_asm_output_data (8, val1->v.val_int, NULL); 3303 break; 3304 case DW_OP_skip: 3305 case DW_OP_bra: 3306 { 3307 int offset; 3308 3309 gcc_assert (val1->val_class == dw_val_class_loc); 3310 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3); 3311 3312 dw2_asm_output_data (2, offset, NULL); 3313 } 3314 break; 3315#else 3316 case DW_OP_addr: 3317 case DW_OP_const2u: 3318 case DW_OP_const2s: 3319 case DW_OP_const4u: 3320 case DW_OP_const4s: 3321 case DW_OP_const8u: 3322 case DW_OP_const8s: 3323 case DW_OP_skip: 3324 case DW_OP_bra: 3325 /* We currently don't make any attempt to make sure these are 3326 aligned properly like we do for the main unwind info, so 3327 don't support emitting things larger than a byte if we're 3328 only doing unwinding. */ 3329 gcc_unreachable (); 3330#endif 3331 case DW_OP_const1u: 3332 case DW_OP_const1s: 3333 dw2_asm_output_data (1, val1->v.val_int, NULL); 3334 break; 3335 case DW_OP_constu: 3336 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3337 break; 3338 case DW_OP_consts: 3339 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); 3340 break; 3341 case DW_OP_pick: 3342 dw2_asm_output_data (1, val1->v.val_int, NULL); 3343 break; 3344 case DW_OP_plus_uconst: 3345 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3346 break; 3347 case DW_OP_breg0: 3348 case DW_OP_breg1: 3349 case DW_OP_breg2: 3350 case DW_OP_breg3: 3351 case DW_OP_breg4: 3352 case DW_OP_breg5: 3353 case DW_OP_breg6: 3354 case DW_OP_breg7: 3355 case DW_OP_breg8: 3356 case DW_OP_breg9: 3357 case DW_OP_breg10: 3358 case DW_OP_breg11: 3359 case DW_OP_breg12: 3360 case DW_OP_breg13: 3361 case DW_OP_breg14: 3362 case DW_OP_breg15: 3363 case DW_OP_breg16: 3364 case DW_OP_breg17: 3365 case DW_OP_breg18: 3366 case DW_OP_breg19: 3367 case DW_OP_breg20: 3368 case DW_OP_breg21: 3369 case DW_OP_breg22: 3370 case DW_OP_breg23: 3371 case DW_OP_breg24: 3372 case DW_OP_breg25: 3373 case DW_OP_breg26: 3374 case DW_OP_breg27: 3375 case DW_OP_breg28: 3376 case DW_OP_breg29: 3377 case DW_OP_breg30: 3378 case DW_OP_breg31: 3379 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); 3380 break; 3381 case DW_OP_regx: 3382 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3383 break; 3384 case DW_OP_fbreg: 3385 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); 3386 break; 3387 case DW_OP_bregx: 3388 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3389 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL); 3390 break; 3391 case DW_OP_piece: 3392 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3393 break; 3394 case DW_OP_deref_size: 3395 case DW_OP_xderef_size: 3396 dw2_asm_output_data (1, val1->v.val_int, NULL); 3397 break; 3398 3399 case INTERNAL_DW_OP_tls_addr: 3400 if (targetm.asm_out.output_dwarf_dtprel) 3401 { 3402 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 3403 DWARF2_ADDR_SIZE, 3404 val1->v.val_addr); 3405 fputc ('\n', asm_out_file); 3406 } 3407 else 3408 gcc_unreachable (); 3409 break; 3410 3411 default: 3412 /* Other codes have no operands. */ 3413 break; 3414 } 3415} 3416 3417/* Output a sequence of location operations. */ 3418 3419static void 3420output_loc_sequence (dw_loc_descr_ref loc) 3421{ 3422 for (; loc != NULL; loc = loc->dw_loc_next) 3423 { 3424 /* Output the opcode. */ 3425 dw2_asm_output_data (1, loc->dw_loc_opc, 3426 "%s", dwarf_stack_op_name (loc->dw_loc_opc)); 3427 3428 /* Output the operand(s) (if any). */ 3429 output_loc_operands (loc); 3430 } 3431} 3432 3433/* This routine will generate the correct assembly data for a location 3434 description based on a cfi entry with a complex address. */ 3435 3436static void 3437output_cfa_loc (dw_cfi_ref cfi) 3438{ 3439 dw_loc_descr_ref loc; 3440 unsigned long size; 3441 3442 /* Output the size of the block. */ 3443 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc; 3444 size = size_of_locs (loc); 3445 dw2_asm_output_data_uleb128 (size, NULL); 3446 3447 /* Now output the operations themselves. */ 3448 output_loc_sequence (loc); 3449} 3450 3451/* This function builds a dwarf location descriptor sequence from a 3452 dw_cfa_location, adding the given OFFSET to the result of the 3453 expression. */ 3454 3455static struct dw_loc_descr_struct * 3456build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset) 3457{ 3458 struct dw_loc_descr_struct *head, *tmp; 3459 3460 offset += cfa->offset; 3461 3462 if (cfa->indirect) 3463 { 3464 if (cfa->base_offset) 3465 { 3466 if (cfa->reg <= 31) 3467 head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0); 3468 else 3469 head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset); 3470 } 3471 else if (cfa->reg <= 31) 3472 head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0); 3473 else 3474 head = new_loc_descr (DW_OP_regx, cfa->reg, 0); 3475 3476 head->dw_loc_oprnd1.val_class = dw_val_class_const; 3477 tmp = new_loc_descr (DW_OP_deref, 0, 0); 3478 add_loc_descr (&head, tmp); 3479 if (offset != 0) 3480 { 3481 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0); 3482 add_loc_descr (&head, tmp); 3483 } 3484 } 3485 else 3486 { 3487 if (offset == 0) 3488 if (cfa->reg <= 31) 3489 head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0); 3490 else 3491 head = new_loc_descr (DW_OP_regx, cfa->reg, 0); 3492 else if (cfa->reg <= 31) 3493 head = new_loc_descr (DW_OP_breg0 + cfa->reg, offset, 0); 3494 else 3495 head = new_loc_descr (DW_OP_bregx, cfa->reg, offset); 3496 } 3497 3498 return head; 3499} 3500 3501/* This function fills in aa dw_cfa_location structure from a dwarf location 3502 descriptor sequence. */ 3503 3504static void 3505get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc) 3506{ 3507 struct dw_loc_descr_struct *ptr; 3508 cfa->offset = 0; 3509 cfa->base_offset = 0; 3510 cfa->indirect = 0; 3511 cfa->reg = -1; 3512 3513 for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next) 3514 { 3515 enum dwarf_location_atom op = ptr->dw_loc_opc; 3516 3517 switch (op) 3518 { 3519 case DW_OP_reg0: 3520 case DW_OP_reg1: 3521 case DW_OP_reg2: 3522 case DW_OP_reg3: 3523 case DW_OP_reg4: 3524 case DW_OP_reg5: 3525 case DW_OP_reg6: 3526 case DW_OP_reg7: 3527 case DW_OP_reg8: 3528 case DW_OP_reg9: 3529 case DW_OP_reg10: 3530 case DW_OP_reg11: 3531 case DW_OP_reg12: 3532 case DW_OP_reg13: 3533 case DW_OP_reg14: 3534 case DW_OP_reg15: 3535 case DW_OP_reg16: 3536 case DW_OP_reg17: 3537 case DW_OP_reg18: 3538 case DW_OP_reg19: 3539 case DW_OP_reg20: 3540 case DW_OP_reg21: 3541 case DW_OP_reg22: 3542 case DW_OP_reg23: 3543 case DW_OP_reg24: 3544 case DW_OP_reg25: 3545 case DW_OP_reg26: 3546 case DW_OP_reg27: 3547 case DW_OP_reg28: 3548 case DW_OP_reg29: 3549 case DW_OP_reg30: 3550 case DW_OP_reg31: 3551 cfa->reg = op - DW_OP_reg0; 3552 break; 3553 case DW_OP_regx: 3554 cfa->reg = ptr->dw_loc_oprnd1.v.val_int; 3555 break; 3556 case DW_OP_breg0: 3557 case DW_OP_breg1: 3558 case DW_OP_breg2: 3559 case DW_OP_breg3: 3560 case DW_OP_breg4: 3561 case DW_OP_breg5: 3562 case DW_OP_breg6: 3563 case DW_OP_breg7: 3564 case DW_OP_breg8: 3565 case DW_OP_breg9: 3566 case DW_OP_breg10: 3567 case DW_OP_breg11: 3568 case DW_OP_breg12: 3569 case DW_OP_breg13: 3570 case DW_OP_breg14: 3571 case DW_OP_breg15: 3572 case DW_OP_breg16: 3573 case DW_OP_breg17: 3574 case DW_OP_breg18: 3575 case DW_OP_breg19: 3576 case DW_OP_breg20: 3577 case DW_OP_breg21: 3578 case DW_OP_breg22: 3579 case DW_OP_breg23: 3580 case DW_OP_breg24: 3581 case DW_OP_breg25: 3582 case DW_OP_breg26: 3583 case DW_OP_breg27: 3584 case DW_OP_breg28: 3585 case DW_OP_breg29: 3586 case DW_OP_breg30: 3587 case DW_OP_breg31: 3588 cfa->reg = op - DW_OP_breg0; 3589 cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int; 3590 break; 3591 case DW_OP_bregx: 3592 cfa->reg = ptr->dw_loc_oprnd1.v.val_int; 3593 cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int; 3594 break; 3595 case DW_OP_deref: 3596 cfa->indirect = 1; 3597 break; 3598 case DW_OP_plus_uconst: 3599 cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned; 3600 break; 3601 default: 3602 internal_error ("DW_LOC_OP %s not implemented", 3603 dwarf_stack_op_name (ptr->dw_loc_opc)); 3604 } 3605 } 3606} 3607#endif /* .debug_frame support */ 3608 3609/* And now, the support for symbolic debugging information. */ 3610#ifdef DWARF2_DEBUGGING_INFO 3611 3612/* .debug_str support. */ 3613static int output_indirect_string (void **, void *); 3614 3615static void dwarf2out_init (const char *); 3616static void dwarf2out_finish (const char *); 3617static void dwarf2out_define (unsigned int, const char *); 3618static void dwarf2out_undef (unsigned int, const char *); 3619static void dwarf2out_start_source_file (unsigned, const char *); 3620static void dwarf2out_end_source_file (unsigned); 3621static void dwarf2out_begin_block (unsigned, unsigned); 3622static void dwarf2out_end_block (unsigned, unsigned); 3623static bool dwarf2out_ignore_block (tree); 3624static void dwarf2out_global_decl (tree); 3625static void dwarf2out_type_decl (tree, int); 3626static void dwarf2out_imported_module_or_decl (tree, tree); 3627static void dwarf2out_abstract_function (tree); 3628static void dwarf2out_var_location (rtx); 3629static void dwarf2out_begin_function (tree); 3630static void dwarf2out_switch_text_section (void); 3631 3632/* The debug hooks structure. */ 3633 3634const struct gcc_debug_hooks dwarf2_debug_hooks = 3635{ 3636 dwarf2out_init, 3637 dwarf2out_finish, 3638 dwarf2out_define, 3639 dwarf2out_undef, 3640 dwarf2out_start_source_file, 3641 dwarf2out_end_source_file, 3642 dwarf2out_begin_block, 3643 dwarf2out_end_block, 3644 dwarf2out_ignore_block, 3645 dwarf2out_source_line, 3646 dwarf2out_begin_prologue, 3647 debug_nothing_int_charstar, /* end_prologue */ 3648 dwarf2out_end_epilogue, 3649 dwarf2out_begin_function, 3650 debug_nothing_int, /* end_function */ 3651 dwarf2out_decl, /* function_decl */ 3652 dwarf2out_global_decl, 3653 dwarf2out_type_decl, /* type_decl */ 3654 dwarf2out_imported_module_or_decl, 3655 debug_nothing_tree, /* deferred_inline_function */ 3656 /* The DWARF 2 backend tries to reduce debugging bloat by not 3657 emitting the abstract description of inline functions until 3658 something tries to reference them. */ 3659 dwarf2out_abstract_function, /* outlining_inline_function */ 3660 debug_nothing_rtx, /* label */ 3661 debug_nothing_int, /* handle_pch */ 3662 dwarf2out_var_location, 3663 dwarf2out_switch_text_section, 3664 1 /* start_end_main_source_file */ 3665}; 3666#endif 3667 3668/* NOTE: In the comments in this file, many references are made to 3669 "Debugging Information Entries". This term is abbreviated as `DIE' 3670 throughout the remainder of this file. */ 3671 3672/* An internal representation of the DWARF output is built, and then 3673 walked to generate the DWARF debugging info. The walk of the internal 3674 representation is done after the entire program has been compiled. 3675 The types below are used to describe the internal representation. */ 3676 3677/* Various DIE's use offsets relative to the beginning of the 3678 .debug_info section to refer to each other. */ 3679 3680typedef long int dw_offset; 3681 3682/* Define typedefs here to avoid circular dependencies. */ 3683 3684typedef struct dw_attr_struct *dw_attr_ref; 3685typedef struct dw_line_info_struct *dw_line_info_ref; 3686typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref; 3687typedef struct pubname_struct *pubname_ref; 3688typedef struct dw_ranges_struct *dw_ranges_ref; 3689 3690/* Each entry in the line_info_table maintains the file and 3691 line number associated with the label generated for that 3692 entry. The label gives the PC value associated with 3693 the line number entry. */ 3694 3695typedef struct dw_line_info_struct GTY(()) 3696{ 3697 unsigned long dw_file_num; 3698 unsigned long dw_line_num; 3699} 3700dw_line_info_entry; 3701 3702/* Line information for functions in separate sections; each one gets its 3703 own sequence. */ 3704typedef struct dw_separate_line_info_struct GTY(()) 3705{ 3706 unsigned long dw_file_num; 3707 unsigned long dw_line_num; 3708 unsigned long function; 3709} 3710dw_separate_line_info_entry; 3711 3712/* Each DIE attribute has a field specifying the attribute kind, 3713 a link to the next attribute in the chain, and an attribute value. 3714 Attributes are typically linked below the DIE they modify. */ 3715 3716typedef struct dw_attr_struct GTY(()) 3717{ 3718 enum dwarf_attribute dw_attr; 3719 dw_val_node dw_attr_val; 3720} 3721dw_attr_node; 3722 3723DEF_VEC_O(dw_attr_node); 3724DEF_VEC_ALLOC_O(dw_attr_node,gc); 3725 3726/* The Debugging Information Entry (DIE) structure. DIEs form a tree. 3727 The children of each node form a circular list linked by 3728 die_sib. die_child points to the node *before* the "first" child node. */ 3729 3730typedef struct die_struct GTY(()) 3731{ 3732 enum dwarf_tag die_tag; 3733 char *die_symbol; 3734 VEC(dw_attr_node,gc) * die_attr; 3735 dw_die_ref die_parent; 3736 dw_die_ref die_child; 3737 dw_die_ref die_sib; 3738 dw_die_ref die_definition; /* ref from a specification to its definition */ 3739 dw_offset die_offset; 3740 unsigned long die_abbrev; 3741 int die_mark; 3742 /* Die is used and must not be pruned as unused. */ 3743 int die_perennial_p; 3744 unsigned int decl_id; 3745} 3746die_node; 3747 3748/* Evaluate 'expr' while 'c' is set to each child of DIE in order. */ 3749#define FOR_EACH_CHILD(die, c, expr) do { \ 3750 c = die->die_child; \ 3751 if (c) do { \ 3752 c = c->die_sib; \ 3753 expr; \ 3754 } while (c != die->die_child); \ 3755} while (0) 3756 3757/* The pubname structure */ 3758 3759typedef struct pubname_struct GTY(()) 3760{ 3761 dw_die_ref die; 3762 char *name; 3763} 3764pubname_entry; 3765 3766DEF_VEC_O(pubname_entry); 3767DEF_VEC_ALLOC_O(pubname_entry, gc); 3768 3769struct dw_ranges_struct GTY(()) 3770{ 3771 int block_num; 3772}; 3773 3774/* The limbo die list structure. */ 3775typedef struct limbo_die_struct GTY(()) 3776{ 3777 dw_die_ref die; 3778 tree created_for; 3779 struct limbo_die_struct *next; 3780} 3781limbo_die_node; 3782 3783/* How to start an assembler comment. */ 3784#ifndef ASM_COMMENT_START 3785#define ASM_COMMENT_START ";#" 3786#endif 3787 3788/* Define a macro which returns nonzero for a TYPE_DECL which was 3789 implicitly generated for a tagged type. 3790 3791 Note that unlike the gcc front end (which generates a NULL named 3792 TYPE_DECL node for each complete tagged type, each array type, and 3793 each function type node created) the g++ front end generates a 3794 _named_ TYPE_DECL node for each tagged type node created. 3795 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to 3796 generate a DW_TAG_typedef DIE for them. */ 3797 3798#define TYPE_DECL_IS_STUB(decl) \ 3799 (DECL_NAME (decl) == NULL_TREE \ 3800 || (DECL_ARTIFICIAL (decl) \ 3801 && is_tagged_type (TREE_TYPE (decl)) \ 3802 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \ 3803 /* This is necessary for stub decls that \ 3804 appear in nested inline functions. */ \ 3805 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \ 3806 && (decl_ultimate_origin (decl) \ 3807 == TYPE_STUB_DECL (TREE_TYPE (decl))))))) 3808 3809/* Information concerning the compilation unit's programming 3810 language, and compiler version. */ 3811 3812/* Fixed size portion of the DWARF compilation unit header. */ 3813#define DWARF_COMPILE_UNIT_HEADER_SIZE \ 3814 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3) 3815 3816/* Fixed size portion of public names info. */ 3817#define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2) 3818 3819/* Fixed size portion of the address range info. */ 3820#define DWARF_ARANGES_HEADER_SIZE \ 3821 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \ 3822 DWARF2_ADDR_SIZE * 2) \ 3823 - DWARF_INITIAL_LENGTH_SIZE) 3824 3825/* Size of padding portion in the address range info. It must be 3826 aligned to twice the pointer size. */ 3827#define DWARF_ARANGES_PAD_SIZE \ 3828 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \ 3829 DWARF2_ADDR_SIZE * 2) \ 3830 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4)) 3831 3832/* Use assembler line directives if available. */ 3833#ifndef DWARF2_ASM_LINE_DEBUG_INFO 3834#ifdef HAVE_AS_DWARF2_DEBUG_LINE 3835#define DWARF2_ASM_LINE_DEBUG_INFO 1 3836#else 3837#define DWARF2_ASM_LINE_DEBUG_INFO 0 3838#endif 3839#endif 3840 3841/* Minimum line offset in a special line info. opcode. 3842 This value was chosen to give a reasonable range of values. */ 3843#define DWARF_LINE_BASE -10 3844 3845/* First special line opcode - leave room for the standard opcodes. */ 3846#define DWARF_LINE_OPCODE_BASE 10 3847 3848/* Range of line offsets in a special line info. opcode. */ 3849#define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1) 3850 3851/* Flag that indicates the initial value of the is_stmt_start flag. 3852 In the present implementation, we do not mark any lines as 3853 the beginning of a source statement, because that information 3854 is not made available by the GCC front-end. */ 3855#define DWARF_LINE_DEFAULT_IS_STMT_START 1 3856 3857#ifdef DWARF2_DEBUGGING_INFO 3858/* This location is used by calc_die_sizes() to keep track 3859 the offset of each DIE within the .debug_info section. */ 3860static unsigned long next_die_offset; 3861#endif 3862 3863/* Record the root of the DIE's built for the current compilation unit. */ 3864static GTY(()) dw_die_ref comp_unit_die; 3865 3866/* A list of DIEs with a NULL parent waiting to be relocated. */ 3867static GTY(()) limbo_die_node *limbo_die_list; 3868 3869/* Filenames referenced by this compilation unit. */ 3870static GTY((param_is (struct dwarf_file_data))) htab_t file_table; 3871 3872/* A hash table of references to DIE's that describe declarations. 3873 The key is a DECL_UID() which is a unique number identifying each decl. */ 3874static GTY ((param_is (struct die_struct))) htab_t decl_die_table; 3875 3876/* Node of the variable location list. */ 3877struct var_loc_node GTY ((chain_next ("%h.next"))) 3878{ 3879 rtx GTY (()) var_loc_note; 3880 const char * GTY (()) label; 3881 const char * GTY (()) section_label; 3882 struct var_loc_node * GTY (()) next; 3883}; 3884 3885/* Variable location list. */ 3886struct var_loc_list_def GTY (()) 3887{ 3888 struct var_loc_node * GTY (()) first; 3889 3890 /* Do not mark the last element of the chained list because 3891 it is marked through the chain. */ 3892 struct var_loc_node * GTY ((skip ("%h"))) last; 3893 3894 /* DECL_UID of the variable decl. */ 3895 unsigned int decl_id; 3896}; 3897typedef struct var_loc_list_def var_loc_list; 3898 3899 3900/* Table of decl location linked lists. */ 3901static GTY ((param_is (var_loc_list))) htab_t decl_loc_table; 3902 3903/* A pointer to the base of a list of references to DIE's that 3904 are uniquely identified by their tag, presence/absence of 3905 children DIE's, and list of attribute/value pairs. */ 3906static GTY((length ("abbrev_die_table_allocated"))) 3907 dw_die_ref *abbrev_die_table; 3908 3909/* Number of elements currently allocated for abbrev_die_table. */ 3910static GTY(()) unsigned abbrev_die_table_allocated; 3911 3912/* Number of elements in type_die_table currently in use. */ 3913static GTY(()) unsigned abbrev_die_table_in_use; 3914 3915/* Size (in elements) of increments by which we may expand the 3916 abbrev_die_table. */ 3917#define ABBREV_DIE_TABLE_INCREMENT 256 3918 3919/* A pointer to the base of a table that contains line information 3920 for each source code line in .text in the compilation unit. */ 3921static GTY((length ("line_info_table_allocated"))) 3922 dw_line_info_ref line_info_table; 3923 3924/* Number of elements currently allocated for line_info_table. */ 3925static GTY(()) unsigned line_info_table_allocated; 3926 3927/* Number of elements in line_info_table currently in use. */ 3928static GTY(()) unsigned line_info_table_in_use; 3929 3930/* True if the compilation unit places functions in more than one section. */ 3931static GTY(()) bool have_multiple_function_sections = false; 3932 3933/* A pointer to the base of a table that contains line information 3934 for each source code line outside of .text in the compilation unit. */ 3935static GTY ((length ("separate_line_info_table_allocated"))) 3936 dw_separate_line_info_ref separate_line_info_table; 3937 3938/* Number of elements currently allocated for separate_line_info_table. */ 3939static GTY(()) unsigned separate_line_info_table_allocated; 3940 3941/* Number of elements in separate_line_info_table currently in use. */ 3942static GTY(()) unsigned separate_line_info_table_in_use; 3943 3944/* Size (in elements) of increments by which we may expand the 3945 line_info_table. */ 3946#define LINE_INFO_TABLE_INCREMENT 1024 3947 3948/* A pointer to the base of a table that contains a list of publicly 3949 accessible names. */ 3950static GTY (()) VEC (pubname_entry, gc) * pubname_table; 3951 3952/* A pointer to the base of a table that contains a list of publicly 3953 accessible types. */ 3954static GTY (()) VEC (pubname_entry, gc) * pubtype_table; 3955 3956/* Array of dies for which we should generate .debug_arange info. */ 3957static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table; 3958 3959/* Number of elements currently allocated for arange_table. */ 3960static GTY(()) unsigned arange_table_allocated; 3961 3962/* Number of elements in arange_table currently in use. */ 3963static GTY(()) unsigned arange_table_in_use; 3964 3965/* Size (in elements) of increments by which we may expand the 3966 arange_table. */ 3967#define ARANGE_TABLE_INCREMENT 64 3968 3969/* Array of dies for which we should generate .debug_ranges info. */ 3970static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table; 3971 3972/* Number of elements currently allocated for ranges_table. */ 3973static GTY(()) unsigned ranges_table_allocated; 3974 3975/* Number of elements in ranges_table currently in use. */ 3976static GTY(()) unsigned ranges_table_in_use; 3977 3978/* Size (in elements) of increments by which we may expand the 3979 ranges_table. */ 3980#define RANGES_TABLE_INCREMENT 64 3981 3982/* Whether we have location lists that need outputting */ 3983static GTY(()) bool have_location_lists; 3984 3985/* Unique label counter. */ 3986static GTY(()) unsigned int loclabel_num; 3987 3988#ifdef DWARF2_DEBUGGING_INFO 3989/* Record whether the function being analyzed contains inlined functions. */ 3990static int current_function_has_inlines; 3991#endif 3992#if 0 && defined (MIPS_DEBUGGING_INFO) 3993static int comp_unit_has_inlines; 3994#endif 3995 3996/* The last file entry emitted by maybe_emit_file(). */ 3997static GTY(()) struct dwarf_file_data * last_emitted_file; 3998 3999/* Number of internal labels generated by gen_internal_sym(). */ 4000static GTY(()) int label_num; 4001 4002/* Cached result of previous call to lookup_filename. */ 4003static GTY(()) struct dwarf_file_data * file_table_last_lookup; 4004 4005#ifdef DWARF2_DEBUGGING_INFO 4006 4007/* Offset from the "steady-state frame pointer" to the frame base, 4008 within the current function. */ 4009static HOST_WIDE_INT frame_pointer_fb_offset; 4010 4011/* Forward declarations for functions defined in this file. */ 4012 4013static int is_pseudo_reg (rtx); 4014static tree type_main_variant (tree); 4015static int is_tagged_type (tree); 4016static const char *dwarf_tag_name (unsigned); 4017static const char *dwarf_attr_name (unsigned); 4018static const char *dwarf_form_name (unsigned); 4019static tree decl_ultimate_origin (tree); 4020static tree block_ultimate_origin (tree); 4021static tree decl_class_context (tree); 4022static void add_dwarf_attr (dw_die_ref, dw_attr_ref); 4023static inline enum dw_val_class AT_class (dw_attr_ref); 4024static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned); 4025static inline unsigned AT_flag (dw_attr_ref); 4026static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT); 4027static inline HOST_WIDE_INT AT_int (dw_attr_ref); 4028static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT); 4029static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref); 4030static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long, 4031 unsigned long); 4032static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int, 4033 unsigned int, unsigned char *); 4034static hashval_t debug_str_do_hash (const void *); 4035static int debug_str_eq (const void *, const void *); 4036static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *); 4037static inline const char *AT_string (dw_attr_ref); 4038static int AT_string_form (dw_attr_ref); 4039static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref); 4040static void add_AT_specification (dw_die_ref, dw_die_ref); 4041static inline dw_die_ref AT_ref (dw_attr_ref); 4042static inline int AT_ref_external (dw_attr_ref); 4043static inline void set_AT_ref_external (dw_attr_ref, int); 4044static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned); 4045static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref); 4046static inline dw_loc_descr_ref AT_loc (dw_attr_ref); 4047static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute, 4048 dw_loc_list_ref); 4049static inline dw_loc_list_ref AT_loc_list (dw_attr_ref); 4050static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx); 4051static inline rtx AT_addr (dw_attr_ref); 4052static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *); 4053static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *); 4054static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *); 4055static void add_AT_offset (dw_die_ref, enum dwarf_attribute, 4056 unsigned HOST_WIDE_INT); 4057static void add_AT_range_list (dw_die_ref, enum dwarf_attribute, 4058 unsigned long); 4059static inline const char *AT_lbl (dw_attr_ref); 4060static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute); 4061static const char *get_AT_low_pc (dw_die_ref); 4062static const char *get_AT_hi_pc (dw_die_ref); 4063static const char *get_AT_string (dw_die_ref, enum dwarf_attribute); 4064static int get_AT_flag (dw_die_ref, enum dwarf_attribute); 4065static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute); 4066static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute); 4067static bool is_c_family (void); 4068static bool is_cxx (void); 4069static bool is_java (void); 4070static bool is_fortran (void); 4071static bool is_ada (void); 4072static void remove_AT (dw_die_ref, enum dwarf_attribute); 4073static void remove_child_TAG (dw_die_ref, enum dwarf_tag); 4074static void add_child_die (dw_die_ref, dw_die_ref); 4075static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree); 4076static dw_die_ref lookup_type_die (tree); 4077static void equate_type_number_to_die (tree, dw_die_ref); 4078static hashval_t decl_die_table_hash (const void *); 4079static int decl_die_table_eq (const void *, const void *); 4080static dw_die_ref lookup_decl_die (tree); 4081static hashval_t decl_loc_table_hash (const void *); 4082static int decl_loc_table_eq (const void *, const void *); 4083static var_loc_list *lookup_decl_loc (tree); 4084static void equate_decl_number_to_die (tree, dw_die_ref); 4085static void add_var_loc_to_decl (tree, struct var_loc_node *); 4086static void print_spaces (FILE *); 4087static void print_die (dw_die_ref, FILE *); 4088static void print_dwarf_line_table (FILE *); 4089static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref); 4090static dw_die_ref pop_compile_unit (dw_die_ref); 4091static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *); 4092static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *); 4093static void die_checksum (dw_die_ref, struct md5_ctx *, int *); 4094static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *); 4095static int same_dw_val_p (dw_val_node *, dw_val_node *, int *); 4096static int same_attr_p (dw_attr_ref, dw_attr_ref, int *); 4097static int same_die_p (dw_die_ref, dw_die_ref, int *); 4098static int same_die_p_wrap (dw_die_ref, dw_die_ref); 4099static void compute_section_prefix (dw_die_ref); 4100static int is_type_die (dw_die_ref); 4101static int is_comdat_die (dw_die_ref); 4102static int is_symbol_die (dw_die_ref); 4103static void assign_symbol_names (dw_die_ref); 4104static void break_out_includes (dw_die_ref); 4105static hashval_t htab_cu_hash (const void *); 4106static int htab_cu_eq (const void *, const void *); 4107static void htab_cu_del (void *); 4108static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *); 4109static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned); 4110static void add_sibling_attributes (dw_die_ref); 4111static void build_abbrev_table (dw_die_ref); 4112static void output_location_lists (dw_die_ref); 4113static int constant_size (long unsigned); 4114static unsigned long size_of_die (dw_die_ref); 4115static void calc_die_sizes (dw_die_ref); 4116static void mark_dies (dw_die_ref); 4117static void unmark_dies (dw_die_ref); 4118static void unmark_all_dies (dw_die_ref); 4119static unsigned long size_of_pubnames (VEC (pubname_entry,gc) *); 4120static unsigned long size_of_aranges (void); 4121static enum dwarf_form value_format (dw_attr_ref); 4122static void output_value_format (dw_attr_ref); 4123static void output_abbrev_section (void); 4124static void output_die_symbol (dw_die_ref); 4125static void output_die (dw_die_ref); 4126static void output_compilation_unit_header (void); 4127static void output_comp_unit (dw_die_ref, int); 4128static const char *dwarf2_name (tree, int); 4129static void add_pubname (tree, dw_die_ref); 4130static void add_pubtype (tree, dw_die_ref); 4131static void output_pubnames (VEC (pubname_entry,gc) *); 4132static void add_arange (tree, dw_die_ref); 4133static void output_aranges (void); 4134static unsigned int add_ranges (tree); 4135static void output_ranges (void); 4136static void output_line_info (void); 4137static void output_file_names (void); 4138static dw_die_ref base_type_die (tree); 4139static tree root_type (tree); 4140static int is_base_type (tree); 4141static bool is_subrange_type (tree); 4142static dw_die_ref subrange_type_die (tree, dw_die_ref); 4143static dw_die_ref modified_type_die (tree, int, int, dw_die_ref); 4144static int type_is_enum (tree); 4145static unsigned int dbx_reg_number (rtx); 4146static void add_loc_descr_op_piece (dw_loc_descr_ref *, int); 4147static dw_loc_descr_ref reg_loc_descriptor (rtx); 4148static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int); 4149static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx); 4150static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT); 4151static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT); 4152static int is_based_loc (rtx); 4153static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode); 4154static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx); 4155static dw_loc_descr_ref loc_descriptor (rtx); 4156static dw_loc_descr_ref loc_descriptor_from_tree_1 (tree, int); 4157static dw_loc_descr_ref loc_descriptor_from_tree (tree); 4158static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int); 4159static tree field_type (tree); 4160static unsigned int simple_type_align_in_bits (tree); 4161static unsigned int simple_decl_align_in_bits (tree); 4162static unsigned HOST_WIDE_INT simple_type_size_in_bits (tree); 4163static HOST_WIDE_INT field_byte_offset (tree); 4164static void add_AT_location_description (dw_die_ref, enum dwarf_attribute, 4165 dw_loc_descr_ref); 4166static void add_data_member_location_attribute (dw_die_ref, tree); 4167static void add_const_value_attribute (dw_die_ref, rtx); 4168static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *); 4169static HOST_WIDE_INT extract_int (const unsigned char *, unsigned); 4170static void insert_float (rtx, unsigned char *); 4171static rtx rtl_for_decl_location (tree); 4172static void add_location_or_const_value_attribute (dw_die_ref, tree, 4173 enum dwarf_attribute); 4174static void tree_add_const_value_attribute (dw_die_ref, tree); 4175static void add_name_attribute (dw_die_ref, const char *); 4176static void add_comp_dir_attribute (dw_die_ref); 4177static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree); 4178static void add_subscript_info (dw_die_ref, tree); 4179static void add_byte_size_attribute (dw_die_ref, tree); 4180static void add_bit_offset_attribute (dw_die_ref, tree); 4181static void add_bit_size_attribute (dw_die_ref, tree); 4182static void add_prototyped_attribute (dw_die_ref, tree); 4183static void add_abstract_origin_attribute (dw_die_ref, tree); 4184static void add_pure_or_virtual_attribute (dw_die_ref, tree); 4185static void add_src_coords_attributes (dw_die_ref, tree); 4186static void add_name_and_src_coords_attributes (dw_die_ref, tree); 4187static void push_decl_scope (tree); 4188static void pop_decl_scope (void); 4189static dw_die_ref scope_die_for (tree, dw_die_ref); 4190static inline int local_scope_p (dw_die_ref); 4191static inline int class_or_namespace_scope_p (dw_die_ref); 4192static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref); 4193static void add_calling_convention_attribute (dw_die_ref, tree); 4194static const char *type_tag (tree); 4195static tree member_declared_type (tree); 4196#if 0 4197static const char *decl_start_label (tree); 4198#endif 4199static void gen_array_type_die (tree, dw_die_ref); 4200#if 0 4201static void gen_entry_point_die (tree, dw_die_ref); 4202#endif 4203static void gen_inlined_enumeration_type_die (tree, dw_die_ref); 4204static void gen_inlined_structure_type_die (tree, dw_die_ref); 4205static void gen_inlined_union_type_die (tree, dw_die_ref); 4206static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref); 4207static dw_die_ref gen_formal_parameter_die (tree, dw_die_ref); 4208static void gen_unspecified_parameters_die (tree, dw_die_ref); 4209static void gen_formal_types_die (tree, dw_die_ref); 4210static void gen_subprogram_die (tree, dw_die_ref); 4211static void gen_variable_die (tree, dw_die_ref); 4212static void gen_label_die (tree, dw_die_ref); 4213static void gen_lexical_block_die (tree, dw_die_ref, int); 4214static void gen_inlined_subroutine_die (tree, dw_die_ref, int); 4215static void gen_field_die (tree, dw_die_ref); 4216static void gen_ptr_to_mbr_type_die (tree, dw_die_ref); 4217static dw_die_ref gen_compile_unit_die (const char *); 4218static void gen_inheritance_die (tree, tree, dw_die_ref); 4219static void gen_member_die (tree, dw_die_ref); 4220static void gen_struct_or_union_type_die (tree, dw_die_ref, 4221 enum debug_info_usage); 4222static void gen_subroutine_type_die (tree, dw_die_ref); 4223static void gen_typedef_die (tree, dw_die_ref); 4224static void gen_type_die (tree, dw_die_ref); 4225static void gen_tagged_type_instantiation_die (tree, dw_die_ref); 4226static void gen_block_die (tree, dw_die_ref, int); 4227static void decls_for_scope (tree, dw_die_ref, int); 4228static int is_redundant_typedef (tree); 4229static void gen_namespace_die (tree); 4230static void gen_decl_die (tree, dw_die_ref); 4231static dw_die_ref force_decl_die (tree); 4232static dw_die_ref force_type_die (tree); 4233static dw_die_ref setup_namespace_context (tree, dw_die_ref); 4234static void declare_in_namespace (tree, dw_die_ref); 4235static struct dwarf_file_data * lookup_filename (const char *); 4236static void retry_incomplete_types (void); 4237static void gen_type_die_for_member (tree, tree, dw_die_ref); 4238static void splice_child_die (dw_die_ref, dw_die_ref); 4239static int file_info_cmp (const void *, const void *); 4240static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *, 4241 const char *, const char *, unsigned); 4242static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref, 4243 const char *, const char *, 4244 const char *); 4245static void output_loc_list (dw_loc_list_ref); 4246static char *gen_internal_sym (const char *); 4247 4248static void prune_unmark_dies (dw_die_ref); 4249static void prune_unused_types_mark (dw_die_ref, int); 4250static void prune_unused_types_walk (dw_die_ref); 4251static void prune_unused_types_walk_attribs (dw_die_ref); 4252static void prune_unused_types_prune (dw_die_ref); 4253static void prune_unused_types (void); 4254static int maybe_emit_file (struct dwarf_file_data *fd); 4255 4256/* Section names used to hold DWARF debugging information. */ 4257#ifndef DEBUG_INFO_SECTION 4258#define DEBUG_INFO_SECTION ".debug_info" 4259#endif 4260#ifndef DEBUG_ABBREV_SECTION 4261#define DEBUG_ABBREV_SECTION ".debug_abbrev" 4262#endif 4263#ifndef DEBUG_ARANGES_SECTION 4264#define DEBUG_ARANGES_SECTION ".debug_aranges" 4265#endif 4266#ifndef DEBUG_MACINFO_SECTION 4267#define DEBUG_MACINFO_SECTION ".debug_macinfo" 4268#endif 4269#ifndef DEBUG_LINE_SECTION 4270#define DEBUG_LINE_SECTION ".debug_line" 4271#endif 4272#ifndef DEBUG_LOC_SECTION 4273#define DEBUG_LOC_SECTION ".debug_loc" 4274#endif 4275#ifndef DEBUG_PUBNAMES_SECTION 4276#define DEBUG_PUBNAMES_SECTION ".debug_pubnames" 4277#endif 4278#ifndef DEBUG_STR_SECTION 4279#define DEBUG_STR_SECTION ".debug_str" 4280#endif 4281#ifndef DEBUG_RANGES_SECTION 4282#define DEBUG_RANGES_SECTION ".debug_ranges" 4283#endif 4284 4285/* Standard ELF section names for compiled code and data. */ 4286#ifndef TEXT_SECTION_NAME 4287#define TEXT_SECTION_NAME ".text" 4288#endif 4289 4290/* Section flags for .debug_str section. */ 4291#define DEBUG_STR_SECTION_FLAGS \ 4292 (HAVE_GAS_SHF_MERGE && flag_merge_constants \ 4293 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \ 4294 : SECTION_DEBUG) 4295 4296/* Labels we insert at beginning sections we can reference instead of 4297 the section names themselves. */ 4298 4299#ifndef TEXT_SECTION_LABEL 4300#define TEXT_SECTION_LABEL "Ltext" 4301#endif 4302#ifndef COLD_TEXT_SECTION_LABEL 4303#define COLD_TEXT_SECTION_LABEL "Ltext_cold" 4304#endif 4305#ifndef DEBUG_LINE_SECTION_LABEL 4306#define DEBUG_LINE_SECTION_LABEL "Ldebug_line" 4307#endif 4308#ifndef DEBUG_INFO_SECTION_LABEL 4309#define DEBUG_INFO_SECTION_LABEL "Ldebug_info" 4310#endif 4311#ifndef DEBUG_ABBREV_SECTION_LABEL 4312#define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev" 4313#endif 4314#ifndef DEBUG_LOC_SECTION_LABEL 4315#define DEBUG_LOC_SECTION_LABEL "Ldebug_loc" 4316#endif 4317#ifndef DEBUG_RANGES_SECTION_LABEL 4318#define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges" 4319#endif 4320#ifndef DEBUG_MACINFO_SECTION_LABEL 4321#define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo" 4322#endif 4323 4324/* Definitions of defaults for formats and names of various special 4325 (artificial) labels which may be generated within this file (when the -g 4326 options is used and DWARF2_DEBUGGING_INFO is in effect. 4327 If necessary, these may be overridden from within the tm.h file, but 4328 typically, overriding these defaults is unnecessary. */ 4329 4330static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4331static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4332static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4333static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4334static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4335static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4336static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4337static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4338static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4339static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES]; 4340 4341#ifndef TEXT_END_LABEL 4342#define TEXT_END_LABEL "Letext" 4343#endif 4344#ifndef COLD_END_LABEL 4345#define COLD_END_LABEL "Letext_cold" 4346#endif 4347#ifndef BLOCK_BEGIN_LABEL 4348#define BLOCK_BEGIN_LABEL "LBB" 4349#endif 4350#ifndef BLOCK_END_LABEL 4351#define BLOCK_END_LABEL "LBE" 4352#endif 4353#ifndef LINE_CODE_LABEL 4354#define LINE_CODE_LABEL "LM" 4355#endif 4356#ifndef SEPARATE_LINE_CODE_LABEL 4357#define SEPARATE_LINE_CODE_LABEL "LSM" 4358#endif 4359 4360/* We allow a language front-end to designate a function that is to be 4361 called to "demangle" any name before it is put into a DIE. */ 4362 4363static const char *(*demangle_name_func) (const char *); 4364 4365void 4366dwarf2out_set_demangle_name_func (const char *(*func) (const char *)) 4367{ 4368 demangle_name_func = func; 4369} 4370 4371/* Test if rtl node points to a pseudo register. */ 4372 4373static inline int 4374is_pseudo_reg (rtx rtl) 4375{ 4376 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER) 4377 || (GET_CODE (rtl) == SUBREG 4378 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER)); 4379} 4380 4381/* Return a reference to a type, with its const and volatile qualifiers 4382 removed. */ 4383 4384static inline tree 4385type_main_variant (tree type) 4386{ 4387 type = TYPE_MAIN_VARIANT (type); 4388 4389 /* ??? There really should be only one main variant among any group of 4390 variants of a given type (and all of the MAIN_VARIANT values for all 4391 members of the group should point to that one type) but sometimes the C 4392 front-end messes this up for array types, so we work around that bug 4393 here. */ 4394 if (TREE_CODE (type) == ARRAY_TYPE) 4395 while (type != TYPE_MAIN_VARIANT (type)) 4396 type = TYPE_MAIN_VARIANT (type); 4397 4398 return type; 4399} 4400 4401/* Return nonzero if the given type node represents a tagged type. */ 4402 4403static inline int 4404is_tagged_type (tree type) 4405{ 4406 enum tree_code code = TREE_CODE (type); 4407 4408 return (code == RECORD_TYPE || code == UNION_TYPE 4409 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE); 4410} 4411 4412/* Convert a DIE tag into its string name. */ 4413 4414static const char * 4415dwarf_tag_name (unsigned int tag) 4416{ 4417 switch (tag) 4418 { 4419 case DW_TAG_padding: 4420 return "DW_TAG_padding"; 4421 case DW_TAG_array_type: 4422 return "DW_TAG_array_type"; 4423 case DW_TAG_class_type: 4424 return "DW_TAG_class_type"; 4425 case DW_TAG_entry_point: 4426 return "DW_TAG_entry_point"; 4427 case DW_TAG_enumeration_type: 4428 return "DW_TAG_enumeration_type"; 4429 case DW_TAG_formal_parameter: 4430 return "DW_TAG_formal_parameter"; 4431 case DW_TAG_imported_declaration: 4432 return "DW_TAG_imported_declaration"; 4433 case DW_TAG_label: 4434 return "DW_TAG_label"; 4435 case DW_TAG_lexical_block: 4436 return "DW_TAG_lexical_block"; 4437 case DW_TAG_member: 4438 return "DW_TAG_member"; 4439 case DW_TAG_pointer_type: 4440 return "DW_TAG_pointer_type"; 4441 case DW_TAG_reference_type: 4442 return "DW_TAG_reference_type"; 4443 case DW_TAG_compile_unit: 4444 return "DW_TAG_compile_unit"; 4445 case DW_TAG_string_type: 4446 return "DW_TAG_string_type"; 4447 case DW_TAG_structure_type: 4448 return "DW_TAG_structure_type"; 4449 case DW_TAG_subroutine_type: 4450 return "DW_TAG_subroutine_type"; 4451 case DW_TAG_typedef: 4452 return "DW_TAG_typedef"; 4453 case DW_TAG_union_type: 4454 return "DW_TAG_union_type"; 4455 case DW_TAG_unspecified_parameters: 4456 return "DW_TAG_unspecified_parameters"; 4457 case DW_TAG_variant: 4458 return "DW_TAG_variant"; 4459 case DW_TAG_common_block: 4460 return "DW_TAG_common_block"; 4461 case DW_TAG_common_inclusion: 4462 return "DW_TAG_common_inclusion"; 4463 case DW_TAG_inheritance: 4464 return "DW_TAG_inheritance"; 4465 case DW_TAG_inlined_subroutine: 4466 return "DW_TAG_inlined_subroutine"; 4467 case DW_TAG_module: 4468 return "DW_TAG_module"; 4469 case DW_TAG_ptr_to_member_type: 4470 return "DW_TAG_ptr_to_member_type"; 4471 case DW_TAG_set_type: 4472 return "DW_TAG_set_type"; 4473 case DW_TAG_subrange_type: 4474 return "DW_TAG_subrange_type"; 4475 case DW_TAG_with_stmt: 4476 return "DW_TAG_with_stmt"; 4477 case DW_TAG_access_declaration: 4478 return "DW_TAG_access_declaration"; 4479 case DW_TAG_base_type: 4480 return "DW_TAG_base_type"; 4481 case DW_TAG_catch_block: 4482 return "DW_TAG_catch_block"; 4483 case DW_TAG_const_type: 4484 return "DW_TAG_const_type"; 4485 case DW_TAG_constant: 4486 return "DW_TAG_constant"; 4487 case DW_TAG_enumerator: 4488 return "DW_TAG_enumerator"; 4489 case DW_TAG_file_type: 4490 return "DW_TAG_file_type"; 4491 case DW_TAG_friend: 4492 return "DW_TAG_friend"; 4493 case DW_TAG_namelist: 4494 return "DW_TAG_namelist"; 4495 case DW_TAG_namelist_item: 4496 return "DW_TAG_namelist_item"; 4497 case DW_TAG_namespace: 4498 return "DW_TAG_namespace"; 4499 case DW_TAG_packed_type: 4500 return "DW_TAG_packed_type"; 4501 case DW_TAG_subprogram: 4502 return "DW_TAG_subprogram"; 4503 case DW_TAG_template_type_param: 4504 return "DW_TAG_template_type_param"; 4505 case DW_TAG_template_value_param: 4506 return "DW_TAG_template_value_param"; 4507 case DW_TAG_thrown_type: 4508 return "DW_TAG_thrown_type"; 4509 case DW_TAG_try_block: 4510 return "DW_TAG_try_block"; 4511 case DW_TAG_variant_part: 4512 return "DW_TAG_variant_part"; 4513 case DW_TAG_variable: 4514 return "DW_TAG_variable"; 4515 case DW_TAG_volatile_type: 4516 return "DW_TAG_volatile_type"; 4517 case DW_TAG_imported_module: 4518 return "DW_TAG_imported_module"; 4519 case DW_TAG_MIPS_loop: 4520 return "DW_TAG_MIPS_loop"; 4521 case DW_TAG_format_label: 4522 return "DW_TAG_format_label"; 4523 case DW_TAG_function_template: 4524 return "DW_TAG_function_template"; 4525 case DW_TAG_class_template: 4526 return "DW_TAG_class_template"; 4527 case DW_TAG_GNU_BINCL: 4528 return "DW_TAG_GNU_BINCL"; 4529 case DW_TAG_GNU_EINCL: 4530 return "DW_TAG_GNU_EINCL"; 4531 default: 4532 return "DW_TAG_<unknown>"; 4533 } 4534} 4535 4536/* Convert a DWARF attribute code into its string name. */ 4537 4538static const char * 4539dwarf_attr_name (unsigned int attr) 4540{ 4541 switch (attr) 4542 { 4543 case DW_AT_sibling: 4544 return "DW_AT_sibling"; 4545 case DW_AT_location: 4546 return "DW_AT_location"; 4547 case DW_AT_name: 4548 return "DW_AT_name"; 4549 case DW_AT_ordering: 4550 return "DW_AT_ordering"; 4551 case DW_AT_subscr_data: 4552 return "DW_AT_subscr_data"; 4553 case DW_AT_byte_size: 4554 return "DW_AT_byte_size"; 4555 case DW_AT_bit_offset: 4556 return "DW_AT_bit_offset"; 4557 case DW_AT_bit_size: 4558 return "DW_AT_bit_size"; 4559 case DW_AT_element_list: 4560 return "DW_AT_element_list"; 4561 case DW_AT_stmt_list: 4562 return "DW_AT_stmt_list"; 4563 case DW_AT_low_pc: 4564 return "DW_AT_low_pc"; 4565 case DW_AT_high_pc: 4566 return "DW_AT_high_pc"; 4567 case DW_AT_language: 4568 return "DW_AT_language"; 4569 case DW_AT_member: 4570 return "DW_AT_member"; 4571 case DW_AT_discr: 4572 return "DW_AT_discr"; 4573 case DW_AT_discr_value: 4574 return "DW_AT_discr_value"; 4575 case DW_AT_visibility: 4576 return "DW_AT_visibility"; 4577 case DW_AT_import: 4578 return "DW_AT_import"; 4579 case DW_AT_string_length: 4580 return "DW_AT_string_length"; 4581 case DW_AT_common_reference: 4582 return "DW_AT_common_reference"; 4583 case DW_AT_comp_dir: 4584 return "DW_AT_comp_dir"; 4585 case DW_AT_const_value: 4586 return "DW_AT_const_value"; 4587 case DW_AT_containing_type: 4588 return "DW_AT_containing_type"; 4589 case DW_AT_default_value: 4590 return "DW_AT_default_value"; 4591 case DW_AT_inline: 4592 return "DW_AT_inline"; 4593 case DW_AT_is_optional: 4594 return "DW_AT_is_optional"; 4595 case DW_AT_lower_bound: 4596 return "DW_AT_lower_bound"; 4597 case DW_AT_producer: 4598 return "DW_AT_producer"; 4599 case DW_AT_prototyped: 4600 return "DW_AT_prototyped"; 4601 case DW_AT_return_addr: 4602 return "DW_AT_return_addr"; 4603 case DW_AT_start_scope: 4604 return "DW_AT_start_scope"; 4605 case DW_AT_stride_size: 4606 return "DW_AT_stride_size"; 4607 case DW_AT_upper_bound: 4608 return "DW_AT_upper_bound"; 4609 case DW_AT_abstract_origin: 4610 return "DW_AT_abstract_origin"; 4611 case DW_AT_accessibility: 4612 return "DW_AT_accessibility"; 4613 case DW_AT_address_class: 4614 return "DW_AT_address_class"; 4615 case DW_AT_artificial: 4616 return "DW_AT_artificial"; 4617 case DW_AT_base_types: 4618 return "DW_AT_base_types"; 4619 case DW_AT_calling_convention: 4620 return "DW_AT_calling_convention"; 4621 case DW_AT_count: 4622 return "DW_AT_count"; 4623 case DW_AT_data_member_location: 4624 return "DW_AT_data_member_location"; 4625 case DW_AT_decl_column: 4626 return "DW_AT_decl_column"; 4627 case DW_AT_decl_file: 4628 return "DW_AT_decl_file"; 4629 case DW_AT_decl_line: 4630 return "DW_AT_decl_line"; 4631 case DW_AT_declaration: 4632 return "DW_AT_declaration"; 4633 case DW_AT_discr_list: 4634 return "DW_AT_discr_list"; 4635 case DW_AT_encoding: 4636 return "DW_AT_encoding"; 4637 case DW_AT_external: 4638 return "DW_AT_external"; 4639 case DW_AT_frame_base: 4640 return "DW_AT_frame_base"; 4641 case DW_AT_friend: 4642 return "DW_AT_friend"; 4643 case DW_AT_identifier_case: 4644 return "DW_AT_identifier_case"; 4645 case DW_AT_macro_info: 4646 return "DW_AT_macro_info"; 4647 case DW_AT_namelist_items: 4648 return "DW_AT_namelist_items"; 4649 case DW_AT_priority: 4650 return "DW_AT_priority"; 4651 case DW_AT_segment: 4652 return "DW_AT_segment"; 4653 case DW_AT_specification: 4654 return "DW_AT_specification"; 4655 case DW_AT_static_link: 4656 return "DW_AT_static_link"; 4657 case DW_AT_type: 4658 return "DW_AT_type"; 4659 case DW_AT_use_location: 4660 return "DW_AT_use_location"; 4661 case DW_AT_variable_parameter: 4662 return "DW_AT_variable_parameter"; 4663 case DW_AT_virtuality: 4664 return "DW_AT_virtuality"; 4665 case DW_AT_vtable_elem_location: 4666 return "DW_AT_vtable_elem_location"; 4667 4668 case DW_AT_allocated: 4669 return "DW_AT_allocated"; 4670 case DW_AT_associated: 4671 return "DW_AT_associated"; 4672 case DW_AT_data_location: 4673 return "DW_AT_data_location"; 4674 case DW_AT_stride: 4675 return "DW_AT_stride"; 4676 case DW_AT_entry_pc: 4677 return "DW_AT_entry_pc"; 4678 case DW_AT_use_UTF8: 4679 return "DW_AT_use_UTF8"; 4680 case DW_AT_extension: 4681 return "DW_AT_extension"; 4682 case DW_AT_ranges: 4683 return "DW_AT_ranges"; 4684 case DW_AT_trampoline: 4685 return "DW_AT_trampoline"; 4686 case DW_AT_call_column: 4687 return "DW_AT_call_column"; 4688 case DW_AT_call_file: 4689 return "DW_AT_call_file"; 4690 case DW_AT_call_line: 4691 return "DW_AT_call_line"; 4692 4693 case DW_AT_MIPS_fde: 4694 return "DW_AT_MIPS_fde"; 4695 case DW_AT_MIPS_loop_begin: 4696 return "DW_AT_MIPS_loop_begin"; 4697 case DW_AT_MIPS_tail_loop_begin: 4698 return "DW_AT_MIPS_tail_loop_begin"; 4699 case DW_AT_MIPS_epilog_begin: 4700 return "DW_AT_MIPS_epilog_begin"; 4701 case DW_AT_MIPS_loop_unroll_factor: 4702 return "DW_AT_MIPS_loop_unroll_factor"; 4703 case DW_AT_MIPS_software_pipeline_depth: 4704 return "DW_AT_MIPS_software_pipeline_depth"; 4705 case DW_AT_MIPS_linkage_name: 4706 return "DW_AT_MIPS_linkage_name"; 4707 case DW_AT_MIPS_stride: 4708 return "DW_AT_MIPS_stride"; 4709 case DW_AT_MIPS_abstract_name: 4710 return "DW_AT_MIPS_abstract_name"; 4711 case DW_AT_MIPS_clone_origin: 4712 return "DW_AT_MIPS_clone_origin"; 4713 case DW_AT_MIPS_has_inlines: 4714 return "DW_AT_MIPS_has_inlines"; 4715 4716 case DW_AT_sf_names: 4717 return "DW_AT_sf_names"; 4718 case DW_AT_src_info: 4719 return "DW_AT_src_info"; 4720 case DW_AT_mac_info: 4721 return "DW_AT_mac_info"; 4722 case DW_AT_src_coords: 4723 return "DW_AT_src_coords"; 4724 case DW_AT_body_begin: 4725 return "DW_AT_body_begin"; 4726 case DW_AT_body_end: 4727 return "DW_AT_body_end"; 4728 case DW_AT_GNU_vector: 4729 return "DW_AT_GNU_vector"; 4730 4731 case DW_AT_VMS_rtnbeg_pd_address: 4732 return "DW_AT_VMS_rtnbeg_pd_address"; 4733 4734 /* APPLE LOCAL begin radar 5811943 - Fix type of pointers to Blocks */ 4735 case DW_AT_APPLE_block: 4736 return "DW_AT_APPLE_block"; 4737 /* APPLE LOCAL end radar 5811943 - Fix type of pointers to Blocks */ 4738 4739 default: 4740 return "DW_AT_<unknown>"; 4741 } 4742} 4743 4744/* Convert a DWARF value form code into its string name. */ 4745 4746static const char * 4747dwarf_form_name (unsigned int form) 4748{ 4749 switch (form) 4750 { 4751 case DW_FORM_addr: 4752 return "DW_FORM_addr"; 4753 case DW_FORM_block2: 4754 return "DW_FORM_block2"; 4755 case DW_FORM_block4: 4756 return "DW_FORM_block4"; 4757 case DW_FORM_data2: 4758 return "DW_FORM_data2"; 4759 case DW_FORM_data4: 4760 return "DW_FORM_data4"; 4761 case DW_FORM_data8: 4762 return "DW_FORM_data8"; 4763 case DW_FORM_string: 4764 return "DW_FORM_string"; 4765 case DW_FORM_block: 4766 return "DW_FORM_block"; 4767 case DW_FORM_block1: 4768 return "DW_FORM_block1"; 4769 case DW_FORM_data1: 4770 return "DW_FORM_data1"; 4771 case DW_FORM_flag: 4772 return "DW_FORM_flag"; 4773 case DW_FORM_sdata: 4774 return "DW_FORM_sdata"; 4775 case DW_FORM_strp: 4776 return "DW_FORM_strp"; 4777 case DW_FORM_udata: 4778 return "DW_FORM_udata"; 4779 case DW_FORM_ref_addr: 4780 return "DW_FORM_ref_addr"; 4781 case DW_FORM_ref1: 4782 return "DW_FORM_ref1"; 4783 case DW_FORM_ref2: 4784 return "DW_FORM_ref2"; 4785 case DW_FORM_ref4: 4786 return "DW_FORM_ref4"; 4787 case DW_FORM_ref8: 4788 return "DW_FORM_ref8"; 4789 case DW_FORM_ref_udata: 4790 return "DW_FORM_ref_udata"; 4791 case DW_FORM_indirect: 4792 return "DW_FORM_indirect"; 4793 default: 4794 return "DW_FORM_<unknown>"; 4795 } 4796} 4797 4798/* Determine the "ultimate origin" of a decl. The decl may be an inlined 4799 instance of an inlined instance of a decl which is local to an inline 4800 function, so we have to trace all of the way back through the origin chain 4801 to find out what sort of node actually served as the original seed for the 4802 given block. */ 4803 4804static tree 4805decl_ultimate_origin (tree decl) 4806{ 4807 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON)) 4808 return NULL_TREE; 4809 4810 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the 4811 nodes in the function to point to themselves; ignore that if 4812 we're trying to output the abstract instance of this function. */ 4813 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl) 4814 return NULL_TREE; 4815 4816 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the 4817 most distant ancestor, this should never happen. */ 4818 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl))); 4819 4820 return DECL_ABSTRACT_ORIGIN (decl); 4821} 4822 4823/* Determine the "ultimate origin" of a block. The block may be an inlined 4824 instance of an inlined instance of a block which is local to an inline 4825 function, so we have to trace all of the way back through the origin chain 4826 to find out what sort of node actually served as the original seed for the 4827 given block. */ 4828 4829static tree 4830block_ultimate_origin (tree block) 4831{ 4832 tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block); 4833 4834 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the 4835 nodes in the function to point to themselves; ignore that if 4836 we're trying to output the abstract instance of this function. */ 4837 if (BLOCK_ABSTRACT (block) && immediate_origin == block) 4838 return NULL_TREE; 4839 4840 if (immediate_origin == NULL_TREE) 4841 return NULL_TREE; 4842 else 4843 { 4844 tree ret_val; 4845 tree lookahead = immediate_origin; 4846 4847 do 4848 { 4849 ret_val = lookahead; 4850 lookahead = (TREE_CODE (ret_val) == BLOCK 4851 ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL); 4852 } 4853 while (lookahead != NULL && lookahead != ret_val); 4854 4855 /* The block's abstract origin chain may not be the *ultimate* origin of 4856 the block. It could lead to a DECL that has an abstract origin set. 4857 If so, we want that DECL's abstract origin (which is what DECL_ORIGIN 4858 will give us if it has one). Note that DECL's abstract origins are 4859 supposed to be the most distant ancestor (or so decl_ultimate_origin 4860 claims), so we don't need to loop following the DECL origins. */ 4861 if (DECL_P (ret_val)) 4862 return DECL_ORIGIN (ret_val); 4863 4864 return ret_val; 4865 } 4866} 4867 4868/* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT 4869 of a virtual function may refer to a base class, so we check the 'this' 4870 parameter. */ 4871 4872static tree 4873decl_class_context (tree decl) 4874{ 4875 tree context = NULL_TREE; 4876 4877 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl)) 4878 context = DECL_CONTEXT (decl); 4879 else 4880 context = TYPE_MAIN_VARIANT 4881 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))))); 4882 4883 if (context && !TYPE_P (context)) 4884 context = NULL_TREE; 4885 4886 return context; 4887} 4888 4889/* Add an attribute/value pair to a DIE. */ 4890 4891static inline void 4892add_dwarf_attr (dw_die_ref die, dw_attr_ref attr) 4893{ 4894 /* Maybe this should be an assert? */ 4895 if (die == NULL) 4896 return; 4897 4898 if (die->die_attr == NULL) 4899 die->die_attr = VEC_alloc (dw_attr_node, gc, 1); 4900 VEC_safe_push (dw_attr_node, gc, die->die_attr, attr); 4901} 4902 4903static inline enum dw_val_class 4904AT_class (dw_attr_ref a) 4905{ 4906 return a->dw_attr_val.val_class; 4907} 4908 4909/* Add a flag value attribute to a DIE. */ 4910 4911static inline void 4912add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag) 4913{ 4914 dw_attr_node attr; 4915 4916 attr.dw_attr = attr_kind; 4917 attr.dw_attr_val.val_class = dw_val_class_flag; 4918 attr.dw_attr_val.v.val_flag = flag; 4919 add_dwarf_attr (die, &attr); 4920} 4921 4922static inline unsigned 4923AT_flag (dw_attr_ref a) 4924{ 4925 gcc_assert (a && AT_class (a) == dw_val_class_flag); 4926 return a->dw_attr_val.v.val_flag; 4927} 4928 4929/* Add a signed integer attribute value to a DIE. */ 4930 4931static inline void 4932add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val) 4933{ 4934 dw_attr_node attr; 4935 4936 attr.dw_attr = attr_kind; 4937 attr.dw_attr_val.val_class = dw_val_class_const; 4938 attr.dw_attr_val.v.val_int = int_val; 4939 add_dwarf_attr (die, &attr); 4940} 4941 4942static inline HOST_WIDE_INT 4943AT_int (dw_attr_ref a) 4944{ 4945 gcc_assert (a && AT_class (a) == dw_val_class_const); 4946 return a->dw_attr_val.v.val_int; 4947} 4948 4949/* Add an unsigned integer attribute value to a DIE. */ 4950 4951static inline void 4952add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind, 4953 unsigned HOST_WIDE_INT unsigned_val) 4954{ 4955 dw_attr_node attr; 4956 4957 attr.dw_attr = attr_kind; 4958 attr.dw_attr_val.val_class = dw_val_class_unsigned_const; 4959 attr.dw_attr_val.v.val_unsigned = unsigned_val; 4960 add_dwarf_attr (die, &attr); 4961} 4962 4963static inline unsigned HOST_WIDE_INT 4964AT_unsigned (dw_attr_ref a) 4965{ 4966 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const); 4967 return a->dw_attr_val.v.val_unsigned; 4968} 4969 4970/* Add an unsigned double integer attribute value to a DIE. */ 4971 4972static inline void 4973add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind, 4974 long unsigned int val_hi, long unsigned int val_low) 4975{ 4976 dw_attr_node attr; 4977 4978 attr.dw_attr = attr_kind; 4979 attr.dw_attr_val.val_class = dw_val_class_long_long; 4980 attr.dw_attr_val.v.val_long_long.hi = val_hi; 4981 attr.dw_attr_val.v.val_long_long.low = val_low; 4982 add_dwarf_attr (die, &attr); 4983} 4984 4985/* Add a floating point attribute value to a DIE and return it. */ 4986 4987static inline void 4988add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind, 4989 unsigned int length, unsigned int elt_size, unsigned char *array) 4990{ 4991 dw_attr_node attr; 4992 4993 attr.dw_attr = attr_kind; 4994 attr.dw_attr_val.val_class = dw_val_class_vec; 4995 attr.dw_attr_val.v.val_vec.length = length; 4996 attr.dw_attr_val.v.val_vec.elt_size = elt_size; 4997 attr.dw_attr_val.v.val_vec.array = array; 4998 add_dwarf_attr (die, &attr); 4999} 5000 5001/* Hash and equality functions for debug_str_hash. */ 5002 5003static hashval_t 5004debug_str_do_hash (const void *x) 5005{ 5006 return htab_hash_string (((const struct indirect_string_node *)x)->str); 5007} 5008 5009static int 5010debug_str_eq (const void *x1, const void *x2) 5011{ 5012 return strcmp ((((const struct indirect_string_node *)x1)->str), 5013 (const char *)x2) == 0; 5014} 5015 5016/* Add a string attribute value to a DIE. */ 5017 5018static inline void 5019add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str) 5020{ 5021 dw_attr_node attr; 5022 struct indirect_string_node *node; 5023 void **slot; 5024 5025 if (! debug_str_hash) 5026 debug_str_hash = htab_create_ggc (10, debug_str_do_hash, 5027 debug_str_eq, NULL); 5028 5029 slot = htab_find_slot_with_hash (debug_str_hash, str, 5030 htab_hash_string (str), INSERT); 5031 if (*slot == NULL) 5032 *slot = ggc_alloc_cleared (sizeof (struct indirect_string_node)); 5033 node = (struct indirect_string_node *) *slot; 5034 node->str = ggc_strdup (str); 5035 node->refcount++; 5036 5037 attr.dw_attr = attr_kind; 5038 attr.dw_attr_val.val_class = dw_val_class_str; 5039 attr.dw_attr_val.v.val_str = node; 5040 add_dwarf_attr (die, &attr); 5041} 5042 5043static inline const char * 5044AT_string (dw_attr_ref a) 5045{ 5046 gcc_assert (a && AT_class (a) == dw_val_class_str); 5047 return a->dw_attr_val.v.val_str->str; 5048} 5049 5050/* Find out whether a string should be output inline in DIE 5051 or out-of-line in .debug_str section. */ 5052 5053static int 5054AT_string_form (dw_attr_ref a) 5055{ 5056 struct indirect_string_node *node; 5057 unsigned int len; 5058 char label[32]; 5059 5060 gcc_assert (a && AT_class (a) == dw_val_class_str); 5061 5062 node = a->dw_attr_val.v.val_str; 5063 if (node->form) 5064 return node->form; 5065 5066 len = strlen (node->str) + 1; 5067 5068 /* If the string is shorter or equal to the size of the reference, it is 5069 always better to put it inline. */ 5070 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0) 5071 return node->form = DW_FORM_string; 5072 5073 /* If we cannot expect the linker to merge strings in .debug_str 5074 section, only put it into .debug_str if it is worth even in this 5075 single module. */ 5076 if ((debug_str_section->common.flags & SECTION_MERGE) == 0 5077 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len) 5078 return node->form = DW_FORM_string; 5079 5080 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter); 5081 ++dw2_string_counter; 5082 node->label = xstrdup (label); 5083 5084 return node->form = DW_FORM_strp; 5085} 5086 5087/* Add a DIE reference attribute value to a DIE. */ 5088 5089static inline void 5090add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die) 5091{ 5092 dw_attr_node attr; 5093 5094 attr.dw_attr = attr_kind; 5095 attr.dw_attr_val.val_class = dw_val_class_die_ref; 5096 attr.dw_attr_val.v.val_die_ref.die = targ_die; 5097 attr.dw_attr_val.v.val_die_ref.external = 0; 5098 add_dwarf_attr (die, &attr); 5099} 5100 5101/* Add an AT_specification attribute to a DIE, and also make the back 5102 pointer from the specification to the definition. */ 5103 5104static inline void 5105add_AT_specification (dw_die_ref die, dw_die_ref targ_die) 5106{ 5107 add_AT_die_ref (die, DW_AT_specification, targ_die); 5108 gcc_assert (!targ_die->die_definition); 5109 targ_die->die_definition = die; 5110} 5111 5112static inline dw_die_ref 5113AT_ref (dw_attr_ref a) 5114{ 5115 gcc_assert (a && AT_class (a) == dw_val_class_die_ref); 5116 return a->dw_attr_val.v.val_die_ref.die; 5117} 5118 5119static inline int 5120AT_ref_external (dw_attr_ref a) 5121{ 5122 if (a && AT_class (a) == dw_val_class_die_ref) 5123 return a->dw_attr_val.v.val_die_ref.external; 5124 5125 return 0; 5126} 5127 5128static inline void 5129set_AT_ref_external (dw_attr_ref a, int i) 5130{ 5131 gcc_assert (a && AT_class (a) == dw_val_class_die_ref); 5132 a->dw_attr_val.v.val_die_ref.external = i; 5133} 5134 5135/* Add an FDE reference attribute value to a DIE. */ 5136 5137static inline void 5138add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde) 5139{ 5140 dw_attr_node attr; 5141 5142 attr.dw_attr = attr_kind; 5143 attr.dw_attr_val.val_class = dw_val_class_fde_ref; 5144 attr.dw_attr_val.v.val_fde_index = targ_fde; 5145 add_dwarf_attr (die, &attr); 5146} 5147 5148/* Add a location description attribute value to a DIE. */ 5149 5150static inline void 5151add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc) 5152{ 5153 dw_attr_node attr; 5154 5155 attr.dw_attr = attr_kind; 5156 attr.dw_attr_val.val_class = dw_val_class_loc; 5157 attr.dw_attr_val.v.val_loc = loc; 5158 add_dwarf_attr (die, &attr); 5159} 5160 5161static inline dw_loc_descr_ref 5162AT_loc (dw_attr_ref a) 5163{ 5164 gcc_assert (a && AT_class (a) == dw_val_class_loc); 5165 return a->dw_attr_val.v.val_loc; 5166} 5167 5168static inline void 5169add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list) 5170{ 5171 dw_attr_node attr; 5172 5173 attr.dw_attr = attr_kind; 5174 attr.dw_attr_val.val_class = dw_val_class_loc_list; 5175 attr.dw_attr_val.v.val_loc_list = loc_list; 5176 add_dwarf_attr (die, &attr); 5177 have_location_lists = true; 5178} 5179 5180static inline dw_loc_list_ref 5181AT_loc_list (dw_attr_ref a) 5182{ 5183 gcc_assert (a && AT_class (a) == dw_val_class_loc_list); 5184 return a->dw_attr_val.v.val_loc_list; 5185} 5186 5187/* Add an address constant attribute value to a DIE. */ 5188 5189static inline void 5190add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr) 5191{ 5192 dw_attr_node attr; 5193 5194 attr.dw_attr = attr_kind; 5195 attr.dw_attr_val.val_class = dw_val_class_addr; 5196 attr.dw_attr_val.v.val_addr = addr; 5197 add_dwarf_attr (die, &attr); 5198} 5199 5200/* Get the RTX from to an address DIE attribute. */ 5201 5202static inline rtx 5203AT_addr (dw_attr_ref a) 5204{ 5205 gcc_assert (a && AT_class (a) == dw_val_class_addr); 5206 return a->dw_attr_val.v.val_addr; 5207} 5208 5209/* Add a file attribute value to a DIE. */ 5210 5211static inline void 5212add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind, 5213 struct dwarf_file_data *fd) 5214{ 5215 dw_attr_node attr; 5216 5217 attr.dw_attr = attr_kind; 5218 attr.dw_attr_val.val_class = dw_val_class_file; 5219 attr.dw_attr_val.v.val_file = fd; 5220 add_dwarf_attr (die, &attr); 5221} 5222 5223/* Get the dwarf_file_data from a file DIE attribute. */ 5224 5225static inline struct dwarf_file_data * 5226AT_file (dw_attr_ref a) 5227{ 5228 gcc_assert (a && AT_class (a) == dw_val_class_file); 5229 return a->dw_attr_val.v.val_file; 5230} 5231 5232/* Add a label identifier attribute value to a DIE. */ 5233 5234static inline void 5235add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id) 5236{ 5237 dw_attr_node attr; 5238 5239 attr.dw_attr = attr_kind; 5240 attr.dw_attr_val.val_class = dw_val_class_lbl_id; 5241 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id); 5242 add_dwarf_attr (die, &attr); 5243} 5244 5245/* Add a section offset attribute value to a DIE, an offset into the 5246 debug_line section. */ 5247 5248static inline void 5249add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind, 5250 const char *label) 5251{ 5252 dw_attr_node attr; 5253 5254 attr.dw_attr = attr_kind; 5255 attr.dw_attr_val.val_class = dw_val_class_lineptr; 5256 attr.dw_attr_val.v.val_lbl_id = xstrdup (label); 5257 add_dwarf_attr (die, &attr); 5258} 5259 5260/* Add a section offset attribute value to a DIE, an offset into the 5261 debug_macinfo section. */ 5262 5263static inline void 5264add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind, 5265 const char *label) 5266{ 5267 dw_attr_node attr; 5268 5269 attr.dw_attr = attr_kind; 5270 attr.dw_attr_val.val_class = dw_val_class_macptr; 5271 attr.dw_attr_val.v.val_lbl_id = xstrdup (label); 5272 add_dwarf_attr (die, &attr); 5273} 5274 5275/* Add an offset attribute value to a DIE. */ 5276 5277static inline void 5278add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind, 5279 unsigned HOST_WIDE_INT offset) 5280{ 5281 dw_attr_node attr; 5282 5283 attr.dw_attr = attr_kind; 5284 attr.dw_attr_val.val_class = dw_val_class_offset; 5285 attr.dw_attr_val.v.val_offset = offset; 5286 add_dwarf_attr (die, &attr); 5287} 5288 5289/* Add an range_list attribute value to a DIE. */ 5290 5291static void 5292add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind, 5293 long unsigned int offset) 5294{ 5295 dw_attr_node attr; 5296 5297 attr.dw_attr = attr_kind; 5298 attr.dw_attr_val.val_class = dw_val_class_range_list; 5299 attr.dw_attr_val.v.val_offset = offset; 5300 add_dwarf_attr (die, &attr); 5301} 5302 5303static inline const char * 5304AT_lbl (dw_attr_ref a) 5305{ 5306 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id 5307 || AT_class (a) == dw_val_class_lineptr 5308 || AT_class (a) == dw_val_class_macptr)); 5309 return a->dw_attr_val.v.val_lbl_id; 5310} 5311 5312/* Get the attribute of type attr_kind. */ 5313 5314static dw_attr_ref 5315get_AT (dw_die_ref die, enum dwarf_attribute attr_kind) 5316{ 5317 dw_attr_ref a; 5318 unsigned ix; 5319 dw_die_ref spec = NULL; 5320 5321 if (! die) 5322 return NULL; 5323 5324 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 5325 if (a->dw_attr == attr_kind) 5326 return a; 5327 else if (a->dw_attr == DW_AT_specification 5328 || a->dw_attr == DW_AT_abstract_origin) 5329 spec = AT_ref (a); 5330 5331 if (spec) 5332 return get_AT (spec, attr_kind); 5333 5334 return NULL; 5335} 5336 5337/* Return the "low pc" attribute value, typically associated with a subprogram 5338 DIE. Return null if the "low pc" attribute is either not present, or if it 5339 cannot be represented as an assembler label identifier. */ 5340 5341static inline const char * 5342get_AT_low_pc (dw_die_ref die) 5343{ 5344 dw_attr_ref a = get_AT (die, DW_AT_low_pc); 5345 5346 return a ? AT_lbl (a) : NULL; 5347} 5348 5349/* Return the "high pc" attribute value, typically associated with a subprogram 5350 DIE. Return null if the "high pc" attribute is either not present, or if it 5351 cannot be represented as an assembler label identifier. */ 5352 5353static inline const char * 5354get_AT_hi_pc (dw_die_ref die) 5355{ 5356 dw_attr_ref a = get_AT (die, DW_AT_high_pc); 5357 5358 return a ? AT_lbl (a) : NULL; 5359} 5360 5361/* Return the value of the string attribute designated by ATTR_KIND, or 5362 NULL if it is not present. */ 5363 5364static inline const char * 5365get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind) 5366{ 5367 dw_attr_ref a = get_AT (die, attr_kind); 5368 5369 return a ? AT_string (a) : NULL; 5370} 5371 5372/* Return the value of the flag attribute designated by ATTR_KIND, or -1 5373 if it is not present. */ 5374 5375static inline int 5376get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind) 5377{ 5378 dw_attr_ref a = get_AT (die, attr_kind); 5379 5380 return a ? AT_flag (a) : 0; 5381} 5382 5383/* Return the value of the unsigned attribute designated by ATTR_KIND, or 0 5384 if it is not present. */ 5385 5386static inline unsigned 5387get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind) 5388{ 5389 dw_attr_ref a = get_AT (die, attr_kind); 5390 5391 return a ? AT_unsigned (a) : 0; 5392} 5393 5394static inline dw_die_ref 5395get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind) 5396{ 5397 dw_attr_ref a = get_AT (die, attr_kind); 5398 5399 return a ? AT_ref (a) : NULL; 5400} 5401 5402static inline struct dwarf_file_data * 5403get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind) 5404{ 5405 dw_attr_ref a = get_AT (die, attr_kind); 5406 5407 return a ? AT_file (a) : NULL; 5408} 5409 5410/* Return TRUE if the language is C or C++. */ 5411 5412static inline bool 5413is_c_family (void) 5414{ 5415 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5416 5417 return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_ObjC 5418 || lang == DW_LANG_C99 5419 || lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus); 5420} 5421 5422/* Return TRUE if the language is C++. */ 5423 5424static inline bool 5425is_cxx (void) 5426{ 5427 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5428 5429 return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus; 5430} 5431 5432/* Return TRUE if the language is Fortran. */ 5433 5434static inline bool 5435is_fortran (void) 5436{ 5437 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5438 5439 return (lang == DW_LANG_Fortran77 5440 || lang == DW_LANG_Fortran90 5441 || lang == DW_LANG_Fortran95); 5442} 5443 5444/* Return TRUE if the language is Java. */ 5445 5446static inline bool 5447is_java (void) 5448{ 5449 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5450 5451 return lang == DW_LANG_Java; 5452} 5453 5454/* Return TRUE if the language is Ada. */ 5455 5456static inline bool 5457is_ada (void) 5458{ 5459 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5460 5461 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83; 5462} 5463 5464/* Remove the specified attribute if present. */ 5465 5466static void 5467remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind) 5468{ 5469 dw_attr_ref a; 5470 unsigned ix; 5471 5472 if (! die) 5473 return; 5474 5475 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 5476 if (a->dw_attr == attr_kind) 5477 { 5478 if (AT_class (a) == dw_val_class_str) 5479 if (a->dw_attr_val.v.val_str->refcount) 5480 a->dw_attr_val.v.val_str->refcount--; 5481 5482 /* VEC_ordered_remove should help reduce the number of abbrevs 5483 that are needed. */ 5484 VEC_ordered_remove (dw_attr_node, die->die_attr, ix); 5485 return; 5486 } 5487} 5488 5489/* Remove CHILD from its parent. PREV must have the property that 5490 PREV->DIE_SIB == CHILD. Does not alter CHILD. */ 5491 5492static void 5493remove_child_with_prev (dw_die_ref child, dw_die_ref prev) 5494{ 5495 gcc_assert (child->die_parent == prev->die_parent); 5496 gcc_assert (prev->die_sib == child); 5497 if (prev == child) 5498 { 5499 gcc_assert (child->die_parent->die_child == child); 5500 prev = NULL; 5501 } 5502 else 5503 prev->die_sib = child->die_sib; 5504 if (child->die_parent->die_child == child) 5505 child->die_parent->die_child = prev; 5506} 5507 5508/* Remove child DIE whose die_tag is TAG. Do nothing if no child 5509 matches TAG. */ 5510 5511static void 5512remove_child_TAG (dw_die_ref die, enum dwarf_tag tag) 5513{ 5514 dw_die_ref c; 5515 5516 c = die->die_child; 5517 if (c) do { 5518 dw_die_ref prev = c; 5519 c = c->die_sib; 5520 while (c->die_tag == tag) 5521 { 5522 remove_child_with_prev (c, prev); 5523 /* Might have removed every child. */ 5524 if (c == c->die_sib) 5525 return; 5526 c = c->die_sib; 5527 } 5528 } while (c != die->die_child); 5529} 5530 5531/* Add a CHILD_DIE as the last child of DIE. */ 5532 5533static void 5534add_child_die (dw_die_ref die, dw_die_ref child_die) 5535{ 5536 /* FIXME this should probably be an assert. */ 5537 if (! die || ! child_die) 5538 return; 5539 gcc_assert (die != child_die); 5540 5541 child_die->die_parent = die; 5542 if (die->die_child) 5543 { 5544 child_die->die_sib = die->die_child->die_sib; 5545 die->die_child->die_sib = child_die; 5546 } 5547 else 5548 child_die->die_sib = child_die; 5549 die->die_child = child_die; 5550} 5551 5552/* Move CHILD, which must be a child of PARENT or the DIE for which PARENT 5553 is the specification, to the end of PARENT's list of children. 5554 This is done by removing and re-adding it. */ 5555 5556static void 5557splice_child_die (dw_die_ref parent, dw_die_ref child) 5558{ 5559 dw_die_ref p; 5560 5561 /* We want the declaration DIE from inside the class, not the 5562 specification DIE at toplevel. */ 5563 if (child->die_parent != parent) 5564 { 5565 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification); 5566 5567 if (tmp) 5568 child = tmp; 5569 } 5570 5571 gcc_assert (child->die_parent == parent 5572 || (child->die_parent 5573 == get_AT_ref (parent, DW_AT_specification))); 5574 5575 for (p = child->die_parent->die_child; ; p = p->die_sib) 5576 if (p->die_sib == child) 5577 { 5578 remove_child_with_prev (child, p); 5579 break; 5580 } 5581 5582 add_child_die (parent, child); 5583} 5584 5585/* Return a pointer to a newly created DIE node. */ 5586 5587static inline dw_die_ref 5588new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t) 5589{ 5590 dw_die_ref die = ggc_alloc_cleared (sizeof (die_node)); 5591 5592 die->die_tag = tag_value; 5593 5594 if (parent_die != NULL) 5595 add_child_die (parent_die, die); 5596 else 5597 { 5598 limbo_die_node *limbo_node; 5599 5600 limbo_node = ggc_alloc_cleared (sizeof (limbo_die_node)); 5601 limbo_node->die = die; 5602 limbo_node->created_for = t; 5603 limbo_node->next = limbo_die_list; 5604 limbo_die_list = limbo_node; 5605 } 5606 5607 return die; 5608} 5609 5610/* Return the DIE associated with the given type specifier. */ 5611 5612static inline dw_die_ref 5613lookup_type_die (tree type) 5614{ 5615 return TYPE_SYMTAB_DIE (type); 5616} 5617 5618/* Equate a DIE to a given type specifier. */ 5619 5620static inline void 5621equate_type_number_to_die (tree type, dw_die_ref type_die) 5622{ 5623 TYPE_SYMTAB_DIE (type) = type_die; 5624} 5625 5626/* Returns a hash value for X (which really is a die_struct). */ 5627 5628static hashval_t 5629decl_die_table_hash (const void *x) 5630{ 5631 return (hashval_t) ((const dw_die_ref) x)->decl_id; 5632} 5633 5634/* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */ 5635 5636static int 5637decl_die_table_eq (const void *x, const void *y) 5638{ 5639 return (((const dw_die_ref) x)->decl_id == DECL_UID ((const tree) y)); 5640} 5641 5642/* Return the DIE associated with a given declaration. */ 5643 5644static inline dw_die_ref 5645lookup_decl_die (tree decl) 5646{ 5647 return htab_find_with_hash (decl_die_table, decl, DECL_UID (decl)); 5648} 5649 5650/* Returns a hash value for X (which really is a var_loc_list). */ 5651 5652static hashval_t 5653decl_loc_table_hash (const void *x) 5654{ 5655 return (hashval_t) ((const var_loc_list *) x)->decl_id; 5656} 5657 5658/* Return nonzero if decl_id of var_loc_list X is the same as 5659 UID of decl *Y. */ 5660 5661static int 5662decl_loc_table_eq (const void *x, const void *y) 5663{ 5664 return (((const var_loc_list *) x)->decl_id == DECL_UID ((const tree) y)); 5665} 5666 5667/* Return the var_loc list associated with a given declaration. */ 5668 5669static inline var_loc_list * 5670lookup_decl_loc (tree decl) 5671{ 5672 return htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl)); 5673} 5674 5675/* Equate a DIE to a particular declaration. */ 5676 5677static void 5678equate_decl_number_to_die (tree decl, dw_die_ref decl_die) 5679{ 5680 unsigned int decl_id = DECL_UID (decl); 5681 void **slot; 5682 5683 slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT); 5684 *slot = decl_die; 5685 decl_die->decl_id = decl_id; 5686} 5687 5688/* Add a variable location node to the linked list for DECL. */ 5689 5690static void 5691add_var_loc_to_decl (tree decl, struct var_loc_node *loc) 5692{ 5693 unsigned int decl_id = DECL_UID (decl); 5694 var_loc_list *temp; 5695 void **slot; 5696 5697 slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT); 5698 if (*slot == NULL) 5699 { 5700 temp = ggc_alloc_cleared (sizeof (var_loc_list)); 5701 temp->decl_id = decl_id; 5702 *slot = temp; 5703 } 5704 else 5705 temp = *slot; 5706 5707 if (temp->last) 5708 { 5709 /* If the current location is the same as the end of the list, 5710 we have nothing to do. */ 5711 if (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note), 5712 NOTE_VAR_LOCATION_LOC (loc->var_loc_note))) 5713 { 5714 /* Add LOC to the end of list and update LAST. */ 5715 temp->last->next = loc; 5716 temp->last = loc; 5717 } 5718 } 5719 /* Do not add empty location to the beginning of the list. */ 5720 else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX) 5721 { 5722 temp->first = loc; 5723 temp->last = loc; 5724 } 5725} 5726 5727/* Keep track of the number of spaces used to indent the 5728 output of the debugging routines that print the structure of 5729 the DIE internal representation. */ 5730static int print_indent; 5731 5732/* Indent the line the number of spaces given by print_indent. */ 5733 5734static inline void 5735print_spaces (FILE *outfile) 5736{ 5737 fprintf (outfile, "%*s", print_indent, ""); 5738} 5739 5740/* Print the information associated with a given DIE, and its children. 5741 This routine is a debugging aid only. */ 5742 5743static void 5744print_die (dw_die_ref die, FILE *outfile) 5745{ 5746 dw_attr_ref a; 5747 dw_die_ref c; 5748 unsigned ix; 5749 5750 print_spaces (outfile); 5751 fprintf (outfile, "DIE %4ld: %s\n", 5752 die->die_offset, dwarf_tag_name (die->die_tag)); 5753 print_spaces (outfile); 5754 fprintf (outfile, " abbrev id: %lu", die->die_abbrev); 5755 fprintf (outfile, " offset: %ld\n", die->die_offset); 5756 5757 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 5758 { 5759 print_spaces (outfile); 5760 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr)); 5761 5762 switch (AT_class (a)) 5763 { 5764 case dw_val_class_addr: 5765 fprintf (outfile, "address"); 5766 break; 5767 case dw_val_class_offset: 5768 fprintf (outfile, "offset"); 5769 break; 5770 case dw_val_class_loc: 5771 fprintf (outfile, "location descriptor"); 5772 break; 5773 case dw_val_class_loc_list: 5774 fprintf (outfile, "location list -> label:%s", 5775 AT_loc_list (a)->ll_symbol); 5776 break; 5777 case dw_val_class_range_list: 5778 fprintf (outfile, "range list"); 5779 break; 5780 case dw_val_class_const: 5781 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a)); 5782 break; 5783 case dw_val_class_unsigned_const: 5784 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a)); 5785 break; 5786 case dw_val_class_long_long: 5787 fprintf (outfile, "constant (%lu,%lu)", 5788 a->dw_attr_val.v.val_long_long.hi, 5789 a->dw_attr_val.v.val_long_long.low); 5790 break; 5791 case dw_val_class_vec: 5792 fprintf (outfile, "floating-point or vector constant"); 5793 break; 5794 case dw_val_class_flag: 5795 fprintf (outfile, "%u", AT_flag (a)); 5796 break; 5797 case dw_val_class_die_ref: 5798 if (AT_ref (a) != NULL) 5799 { 5800 if (AT_ref (a)->die_symbol) 5801 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol); 5802 else 5803 fprintf (outfile, "die -> %ld", AT_ref (a)->die_offset); 5804 } 5805 else 5806 fprintf (outfile, "die -> <null>"); 5807 break; 5808 case dw_val_class_lbl_id: 5809 case dw_val_class_lineptr: 5810 case dw_val_class_macptr: 5811 fprintf (outfile, "label: %s", AT_lbl (a)); 5812 break; 5813 case dw_val_class_str: 5814 if (AT_string (a) != NULL) 5815 fprintf (outfile, "\"%s\"", AT_string (a)); 5816 else 5817 fprintf (outfile, "<null>"); 5818 break; 5819 case dw_val_class_file: 5820 fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename, 5821 AT_file (a)->emitted_number); 5822 break; 5823 default: 5824 break; 5825 } 5826 5827 fprintf (outfile, "\n"); 5828 } 5829 5830 if (die->die_child != NULL) 5831 { 5832 print_indent += 4; 5833 FOR_EACH_CHILD (die, c, print_die (c, outfile)); 5834 print_indent -= 4; 5835 } 5836 if (print_indent == 0) 5837 fprintf (outfile, "\n"); 5838} 5839 5840/* Print the contents of the source code line number correspondence table. 5841 This routine is a debugging aid only. */ 5842 5843static void 5844print_dwarf_line_table (FILE *outfile) 5845{ 5846 unsigned i; 5847 dw_line_info_ref line_info; 5848 5849 fprintf (outfile, "\n\nDWARF source line information\n"); 5850 for (i = 1; i < line_info_table_in_use; i++) 5851 { 5852 line_info = &line_info_table[i]; 5853 fprintf (outfile, "%5d: %4ld %6ld\n", i, 5854 line_info->dw_file_num, 5855 line_info->dw_line_num); 5856 } 5857 5858 fprintf (outfile, "\n\n"); 5859} 5860 5861/* Print the information collected for a given DIE. */ 5862 5863void 5864debug_dwarf_die (dw_die_ref die) 5865{ 5866 print_die (die, stderr); 5867} 5868 5869/* Print all DWARF information collected for the compilation unit. 5870 This routine is a debugging aid only. */ 5871 5872void 5873debug_dwarf (void) 5874{ 5875 print_indent = 0; 5876 print_die (comp_unit_die, stderr); 5877 if (! DWARF2_ASM_LINE_DEBUG_INFO) 5878 print_dwarf_line_table (stderr); 5879} 5880 5881/* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU 5882 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL 5883 DIE that marks the start of the DIEs for this include file. */ 5884 5885static dw_die_ref 5886push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die) 5887{ 5888 const char *filename = get_AT_string (bincl_die, DW_AT_name); 5889 dw_die_ref new_unit = gen_compile_unit_die (filename); 5890 5891 new_unit->die_sib = old_unit; 5892 return new_unit; 5893} 5894 5895/* Close an include-file CU and reopen the enclosing one. */ 5896 5897static dw_die_ref 5898pop_compile_unit (dw_die_ref old_unit) 5899{ 5900 dw_die_ref new_unit = old_unit->die_sib; 5901 5902 old_unit->die_sib = NULL; 5903 return new_unit; 5904} 5905 5906#define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx) 5907#define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx) 5908 5909/* Calculate the checksum of a location expression. */ 5910 5911static inline void 5912loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx) 5913{ 5914 CHECKSUM (loc->dw_loc_opc); 5915 CHECKSUM (loc->dw_loc_oprnd1); 5916 CHECKSUM (loc->dw_loc_oprnd2); 5917} 5918 5919/* Calculate the checksum of an attribute. */ 5920 5921static void 5922attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark) 5923{ 5924 dw_loc_descr_ref loc; 5925 rtx r; 5926 5927 CHECKSUM (at->dw_attr); 5928 5929 /* We don't care that this was compiled with a different compiler 5930 snapshot; if the output is the same, that's what matters. */ 5931 if (at->dw_attr == DW_AT_producer) 5932 return; 5933 5934 switch (AT_class (at)) 5935 { 5936 case dw_val_class_const: 5937 CHECKSUM (at->dw_attr_val.v.val_int); 5938 break; 5939 case dw_val_class_unsigned_const: 5940 CHECKSUM (at->dw_attr_val.v.val_unsigned); 5941 break; 5942 case dw_val_class_long_long: 5943 CHECKSUM (at->dw_attr_val.v.val_long_long); 5944 break; 5945 case dw_val_class_vec: 5946 CHECKSUM (at->dw_attr_val.v.val_vec); 5947 break; 5948 case dw_val_class_flag: 5949 CHECKSUM (at->dw_attr_val.v.val_flag); 5950 break; 5951 case dw_val_class_str: 5952 CHECKSUM_STRING (AT_string (at)); 5953 break; 5954 5955 case dw_val_class_addr: 5956 r = AT_addr (at); 5957 gcc_assert (GET_CODE (r) == SYMBOL_REF); 5958 CHECKSUM_STRING (XSTR (r, 0)); 5959 break; 5960 5961 case dw_val_class_offset: 5962 CHECKSUM (at->dw_attr_val.v.val_offset); 5963 break; 5964 5965 case dw_val_class_loc: 5966 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next) 5967 loc_checksum (loc, ctx); 5968 break; 5969 5970 case dw_val_class_die_ref: 5971 die_checksum (AT_ref (at), ctx, mark); 5972 break; 5973 5974 case dw_val_class_fde_ref: 5975 case dw_val_class_lbl_id: 5976 case dw_val_class_lineptr: 5977 case dw_val_class_macptr: 5978 break; 5979 5980 case dw_val_class_file: 5981 CHECKSUM_STRING (AT_file (at)->filename); 5982 break; 5983 5984 default: 5985 break; 5986 } 5987} 5988 5989/* Calculate the checksum of a DIE. */ 5990 5991static void 5992die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark) 5993{ 5994 dw_die_ref c; 5995 dw_attr_ref a; 5996 unsigned ix; 5997 5998 /* To avoid infinite recursion. */ 5999 if (die->die_mark) 6000 { 6001 CHECKSUM (die->die_mark); 6002 return; 6003 } 6004 die->die_mark = ++(*mark); 6005 6006 CHECKSUM (die->die_tag); 6007 6008 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 6009 attr_checksum (a, ctx, mark); 6010 6011 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark)); 6012} 6013 6014#undef CHECKSUM 6015#undef CHECKSUM_STRING 6016 6017/* Do the location expressions look same? */ 6018static inline int 6019same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark) 6020{ 6021 return loc1->dw_loc_opc == loc2->dw_loc_opc 6022 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark) 6023 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark); 6024} 6025 6026/* Do the values look the same? */ 6027static int 6028same_dw_val_p (dw_val_node *v1, dw_val_node *v2, int *mark) 6029{ 6030 dw_loc_descr_ref loc1, loc2; 6031 rtx r1, r2; 6032 6033 if (v1->val_class != v2->val_class) 6034 return 0; 6035 6036 switch (v1->val_class) 6037 { 6038 case dw_val_class_const: 6039 return v1->v.val_int == v2->v.val_int; 6040 case dw_val_class_unsigned_const: 6041 return v1->v.val_unsigned == v2->v.val_unsigned; 6042 case dw_val_class_long_long: 6043 return v1->v.val_long_long.hi == v2->v.val_long_long.hi 6044 && v1->v.val_long_long.low == v2->v.val_long_long.low; 6045 case dw_val_class_vec: 6046 if (v1->v.val_vec.length != v2->v.val_vec.length 6047 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size) 6048 return 0; 6049 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array, 6050 v1->v.val_vec.length * v1->v.val_vec.elt_size)) 6051 return 0; 6052 return 1; 6053 case dw_val_class_flag: 6054 return v1->v.val_flag == v2->v.val_flag; 6055 case dw_val_class_str: 6056 return !strcmp(v1->v.val_str->str, v2->v.val_str->str); 6057 6058 case dw_val_class_addr: 6059 r1 = v1->v.val_addr; 6060 r2 = v2->v.val_addr; 6061 if (GET_CODE (r1) != GET_CODE (r2)) 6062 return 0; 6063 gcc_assert (GET_CODE (r1) == SYMBOL_REF); 6064 return !strcmp (XSTR (r1, 0), XSTR (r2, 0)); 6065 6066 case dw_val_class_offset: 6067 return v1->v.val_offset == v2->v.val_offset; 6068 6069 case dw_val_class_loc: 6070 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc; 6071 loc1 && loc2; 6072 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next) 6073 if (!same_loc_p (loc1, loc2, mark)) 6074 return 0; 6075 return !loc1 && !loc2; 6076 6077 case dw_val_class_die_ref: 6078 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark); 6079 6080 case dw_val_class_fde_ref: 6081 case dw_val_class_lbl_id: 6082 case dw_val_class_lineptr: 6083 case dw_val_class_macptr: 6084 return 1; 6085 6086 case dw_val_class_file: 6087 return v1->v.val_file == v2->v.val_file; 6088 6089 default: 6090 return 1; 6091 } 6092} 6093 6094/* Do the attributes look the same? */ 6095 6096static int 6097same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark) 6098{ 6099 if (at1->dw_attr != at2->dw_attr) 6100 return 0; 6101 6102 /* We don't care that this was compiled with a different compiler 6103 snapshot; if the output is the same, that's what matters. */ 6104 if (at1->dw_attr == DW_AT_producer) 6105 return 1; 6106 6107 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark); 6108} 6109 6110/* Do the dies look the same? */ 6111 6112static int 6113same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark) 6114{ 6115 dw_die_ref c1, c2; 6116 dw_attr_ref a1; 6117 unsigned ix; 6118 6119 /* To avoid infinite recursion. */ 6120 if (die1->die_mark) 6121 return die1->die_mark == die2->die_mark; 6122 die1->die_mark = die2->die_mark = ++(*mark); 6123 6124 if (die1->die_tag != die2->die_tag) 6125 return 0; 6126 6127 if (VEC_length (dw_attr_node, die1->die_attr) 6128 != VEC_length (dw_attr_node, die2->die_attr)) 6129 return 0; 6130 6131 for (ix = 0; VEC_iterate (dw_attr_node, die1->die_attr, ix, a1); ix++) 6132 if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark)) 6133 return 0; 6134 6135 c1 = die1->die_child; 6136 c2 = die2->die_child; 6137 if (! c1) 6138 { 6139 if (c2) 6140 return 0; 6141 } 6142 else 6143 for (;;) 6144 { 6145 if (!same_die_p (c1, c2, mark)) 6146 return 0; 6147 c1 = c1->die_sib; 6148 c2 = c2->die_sib; 6149 if (c1 == die1->die_child) 6150 { 6151 if (c2 == die2->die_child) 6152 break; 6153 else 6154 return 0; 6155 } 6156 } 6157 6158 return 1; 6159} 6160 6161/* Do the dies look the same? Wrapper around same_die_p. */ 6162 6163static int 6164same_die_p_wrap (dw_die_ref die1, dw_die_ref die2) 6165{ 6166 int mark = 0; 6167 int ret = same_die_p (die1, die2, &mark); 6168 6169 unmark_all_dies (die1); 6170 unmark_all_dies (die2); 6171 6172 return ret; 6173} 6174 6175/* The prefix to attach to symbols on DIEs in the current comdat debug 6176 info section. */ 6177static char *comdat_symbol_id; 6178 6179/* The index of the current symbol within the current comdat CU. */ 6180static unsigned int comdat_symbol_number; 6181 6182/* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its 6183 children, and set comdat_symbol_id accordingly. */ 6184 6185static void 6186compute_section_prefix (dw_die_ref unit_die) 6187{ 6188 const char *die_name = get_AT_string (unit_die, DW_AT_name); 6189 const char *base = die_name ? lbasename (die_name) : "anonymous"; 6190 char *name = alloca (strlen (base) + 64); 6191 char *p; 6192 int i, mark; 6193 unsigned char checksum[16]; 6194 struct md5_ctx ctx; 6195 6196 /* Compute the checksum of the DIE, then append part of it as hex digits to 6197 the name filename of the unit. */ 6198 6199 md5_init_ctx (&ctx); 6200 mark = 0; 6201 die_checksum (unit_die, &ctx, &mark); 6202 unmark_all_dies (unit_die); 6203 md5_finish_ctx (&ctx, checksum); 6204 6205 sprintf (name, "%s.", base); 6206 clean_symbol_name (name); 6207 6208 p = name + strlen (name); 6209 for (i = 0; i < 4; i++) 6210 { 6211 sprintf (p, "%.2x", checksum[i]); 6212 p += 2; 6213 } 6214 6215 comdat_symbol_id = unit_die->die_symbol = xstrdup (name); 6216 comdat_symbol_number = 0; 6217} 6218 6219/* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */ 6220 6221static int 6222is_type_die (dw_die_ref die) 6223{ 6224 switch (die->die_tag) 6225 { 6226 case DW_TAG_array_type: 6227 case DW_TAG_class_type: 6228 case DW_TAG_enumeration_type: 6229 case DW_TAG_pointer_type: 6230 case DW_TAG_reference_type: 6231 case DW_TAG_string_type: 6232 case DW_TAG_structure_type: 6233 case DW_TAG_subroutine_type: 6234 case DW_TAG_union_type: 6235 case DW_TAG_ptr_to_member_type: 6236 case DW_TAG_set_type: 6237 case DW_TAG_subrange_type: 6238 case DW_TAG_base_type: 6239 case DW_TAG_const_type: 6240 case DW_TAG_file_type: 6241 case DW_TAG_packed_type: 6242 case DW_TAG_volatile_type: 6243 case DW_TAG_typedef: 6244 return 1; 6245 default: 6246 return 0; 6247 } 6248} 6249 6250/* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU. 6251 Basically, we want to choose the bits that are likely to be shared between 6252 compilations (types) and leave out the bits that are specific to individual 6253 compilations (functions). */ 6254 6255static int 6256is_comdat_die (dw_die_ref c) 6257{ 6258 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as 6259 we do for stabs. The advantage is a greater likelihood of sharing between 6260 objects that don't include headers in the same order (and therefore would 6261 put the base types in a different comdat). jason 8/28/00 */ 6262 6263 if (c->die_tag == DW_TAG_base_type) 6264 return 0; 6265 6266 if (c->die_tag == DW_TAG_pointer_type 6267 || c->die_tag == DW_TAG_reference_type 6268 || c->die_tag == DW_TAG_const_type 6269 || c->die_tag == DW_TAG_volatile_type) 6270 { 6271 dw_die_ref t = get_AT_ref (c, DW_AT_type); 6272 6273 return t ? is_comdat_die (t) : 0; 6274 } 6275 6276 return is_type_die (c); 6277} 6278 6279/* Returns 1 iff C is the sort of DIE that might be referred to from another 6280 compilation unit. */ 6281 6282static int 6283is_symbol_die (dw_die_ref c) 6284{ 6285 return (is_type_die (c) 6286 || (get_AT (c, DW_AT_declaration) 6287 && !get_AT (c, DW_AT_specification)) 6288 || c->die_tag == DW_TAG_namespace); 6289} 6290 6291static char * 6292gen_internal_sym (const char *prefix) 6293{ 6294 char buf[256]; 6295 6296 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++); 6297 return xstrdup (buf); 6298} 6299 6300/* Assign symbols to all worthy DIEs under DIE. */ 6301 6302static void 6303assign_symbol_names (dw_die_ref die) 6304{ 6305 dw_die_ref c; 6306 6307 if (is_symbol_die (die)) 6308 { 6309 if (comdat_symbol_id) 6310 { 6311 char *p = alloca (strlen (comdat_symbol_id) + 64); 6312 6313 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX, 6314 comdat_symbol_id, comdat_symbol_number++); 6315 die->die_symbol = xstrdup (p); 6316 } 6317 else 6318 die->die_symbol = gen_internal_sym ("LDIE"); 6319 } 6320 6321 FOR_EACH_CHILD (die, c, assign_symbol_names (c)); 6322} 6323 6324struct cu_hash_table_entry 6325{ 6326 dw_die_ref cu; 6327 unsigned min_comdat_num, max_comdat_num; 6328 struct cu_hash_table_entry *next; 6329}; 6330 6331/* Routines to manipulate hash table of CUs. */ 6332static hashval_t 6333htab_cu_hash (const void *of) 6334{ 6335 const struct cu_hash_table_entry *entry = of; 6336 6337 return htab_hash_string (entry->cu->die_symbol); 6338} 6339 6340static int 6341htab_cu_eq (const void *of1, const void *of2) 6342{ 6343 const struct cu_hash_table_entry *entry1 = of1; 6344 const struct die_struct *entry2 = of2; 6345 6346 return !strcmp (entry1->cu->die_symbol, entry2->die_symbol); 6347} 6348 6349static void 6350htab_cu_del (void *what) 6351{ 6352 struct cu_hash_table_entry *next, *entry = what; 6353 6354 while (entry) 6355 { 6356 next = entry->next; 6357 free (entry); 6358 entry = next; 6359 } 6360} 6361 6362/* Check whether we have already seen this CU and set up SYM_NUM 6363 accordingly. */ 6364static int 6365check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num) 6366{ 6367 struct cu_hash_table_entry dummy; 6368 struct cu_hash_table_entry **slot, *entry, *last = &dummy; 6369 6370 dummy.max_comdat_num = 0; 6371 6372 slot = (struct cu_hash_table_entry **) 6373 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol), 6374 INSERT); 6375 entry = *slot; 6376 6377 for (; entry; last = entry, entry = entry->next) 6378 { 6379 if (same_die_p_wrap (cu, entry->cu)) 6380 break; 6381 } 6382 6383 if (entry) 6384 { 6385 *sym_num = entry->min_comdat_num; 6386 return 1; 6387 } 6388 6389 entry = XCNEW (struct cu_hash_table_entry); 6390 entry->cu = cu; 6391 entry->min_comdat_num = *sym_num = last->max_comdat_num; 6392 entry->next = *slot; 6393 *slot = entry; 6394 6395 return 0; 6396} 6397 6398/* Record SYM_NUM to record of CU in HTABLE. */ 6399static void 6400record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num) 6401{ 6402 struct cu_hash_table_entry **slot, *entry; 6403 6404 slot = (struct cu_hash_table_entry **) 6405 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol), 6406 NO_INSERT); 6407 entry = *slot; 6408 6409 entry->max_comdat_num = sym_num; 6410} 6411 6412/* Traverse the DIE (which is always comp_unit_die), and set up 6413 additional compilation units for each of the include files we see 6414 bracketed by BINCL/EINCL. */ 6415 6416static void 6417break_out_includes (dw_die_ref die) 6418{ 6419 dw_die_ref c; 6420 dw_die_ref unit = NULL; 6421 limbo_die_node *node, **pnode; 6422 htab_t cu_hash_table; 6423 6424 c = die->die_child; 6425 if (c) do { 6426 dw_die_ref prev = c; 6427 c = c->die_sib; 6428 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL 6429 || (unit && is_comdat_die (c))) 6430 { 6431 dw_die_ref next = c->die_sib; 6432 6433 /* This DIE is for a secondary CU; remove it from the main one. */ 6434 remove_child_with_prev (c, prev); 6435 6436 if (c->die_tag == DW_TAG_GNU_BINCL) 6437 unit = push_new_compile_unit (unit, c); 6438 else if (c->die_tag == DW_TAG_GNU_EINCL) 6439 unit = pop_compile_unit (unit); 6440 else 6441 add_child_die (unit, c); 6442 c = next; 6443 if (c == die->die_child) 6444 break; 6445 } 6446 } while (c != die->die_child); 6447 6448#if 0 6449 /* We can only use this in debugging, since the frontend doesn't check 6450 to make sure that we leave every include file we enter. */ 6451 gcc_assert (!unit); 6452#endif 6453 6454 assign_symbol_names (die); 6455 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del); 6456 for (node = limbo_die_list, pnode = &limbo_die_list; 6457 node; 6458 node = node->next) 6459 { 6460 int is_dupl; 6461 6462 compute_section_prefix (node->die); 6463 is_dupl = check_duplicate_cu (node->die, cu_hash_table, 6464 &comdat_symbol_number); 6465 assign_symbol_names (node->die); 6466 if (is_dupl) 6467 *pnode = node->next; 6468 else 6469 { 6470 pnode = &node->next; 6471 record_comdat_symbol_number (node->die, cu_hash_table, 6472 comdat_symbol_number); 6473 } 6474 } 6475 htab_delete (cu_hash_table); 6476} 6477 6478/* Traverse the DIE and add a sibling attribute if it may have the 6479 effect of speeding up access to siblings. To save some space, 6480 avoid generating sibling attributes for DIE's without children. */ 6481 6482static void 6483add_sibling_attributes (dw_die_ref die) 6484{ 6485 dw_die_ref c; 6486 6487 if (! die->die_child) 6488 return; 6489 6490 if (die->die_parent && die != die->die_parent->die_child) 6491 add_AT_die_ref (die, DW_AT_sibling, die->die_sib); 6492 6493 FOR_EACH_CHILD (die, c, add_sibling_attributes (c)); 6494} 6495 6496/* Output all location lists for the DIE and its children. */ 6497 6498static void 6499output_location_lists (dw_die_ref die) 6500{ 6501 dw_die_ref c; 6502 dw_attr_ref a; 6503 unsigned ix; 6504 6505 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 6506 if (AT_class (a) == dw_val_class_loc_list) 6507 output_loc_list (AT_loc_list (a)); 6508 6509 FOR_EACH_CHILD (die, c, output_location_lists (c)); 6510} 6511 6512/* The format of each DIE (and its attribute value pairs) is encoded in an 6513 abbreviation table. This routine builds the abbreviation table and assigns 6514 a unique abbreviation id for each abbreviation entry. The children of each 6515 die are visited recursively. */ 6516 6517static void 6518build_abbrev_table (dw_die_ref die) 6519{ 6520 unsigned long abbrev_id; 6521 unsigned int n_alloc; 6522 dw_die_ref c; 6523 dw_attr_ref a; 6524 unsigned ix; 6525 6526 /* Scan the DIE references, and mark as external any that refer to 6527 DIEs from other CUs (i.e. those which are not marked). */ 6528 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 6529 if (AT_class (a) == dw_val_class_die_ref 6530 && AT_ref (a)->die_mark == 0) 6531 { 6532 gcc_assert (AT_ref (a)->die_symbol); 6533 6534 set_AT_ref_external (a, 1); 6535 } 6536 6537 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id) 6538 { 6539 dw_die_ref abbrev = abbrev_die_table[abbrev_id]; 6540 dw_attr_ref die_a, abbrev_a; 6541 unsigned ix; 6542 bool ok = true; 6543 6544 if (abbrev->die_tag != die->die_tag) 6545 continue; 6546 if ((abbrev->die_child != NULL) != (die->die_child != NULL)) 6547 continue; 6548 6549 if (VEC_length (dw_attr_node, abbrev->die_attr) 6550 != VEC_length (dw_attr_node, die->die_attr)) 6551 continue; 6552 6553 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, die_a); ix++) 6554 { 6555 abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix); 6556 if ((abbrev_a->dw_attr != die_a->dw_attr) 6557 || (value_format (abbrev_a) != value_format (die_a))) 6558 { 6559 ok = false; 6560 break; 6561 } 6562 } 6563 if (ok) 6564 break; 6565 } 6566 6567 if (abbrev_id >= abbrev_die_table_in_use) 6568 { 6569 if (abbrev_die_table_in_use >= abbrev_die_table_allocated) 6570 { 6571 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT; 6572 abbrev_die_table = ggc_realloc (abbrev_die_table, 6573 sizeof (dw_die_ref) * n_alloc); 6574 6575 memset (&abbrev_die_table[abbrev_die_table_allocated], 0, 6576 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref)); 6577 abbrev_die_table_allocated = n_alloc; 6578 } 6579 6580 ++abbrev_die_table_in_use; 6581 abbrev_die_table[abbrev_id] = die; 6582 } 6583 6584 die->die_abbrev = abbrev_id; 6585 FOR_EACH_CHILD (die, c, build_abbrev_table (c)); 6586} 6587 6588/* Return the power-of-two number of bytes necessary to represent VALUE. */ 6589 6590static int 6591constant_size (long unsigned int value) 6592{ 6593 int log; 6594 6595 if (value == 0) 6596 log = 0; 6597 else 6598 log = floor_log2 (value); 6599 6600 log = log / 8; 6601 log = 1 << (floor_log2 (log) + 1); 6602 6603 return log; 6604} 6605 6606/* Return the size of a DIE as it is represented in the 6607 .debug_info section. */ 6608 6609static unsigned long 6610size_of_die (dw_die_ref die) 6611{ 6612 unsigned long size = 0; 6613 dw_attr_ref a; 6614 unsigned ix; 6615 6616 size += size_of_uleb128 (die->die_abbrev); 6617 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 6618 { 6619 switch (AT_class (a)) 6620 { 6621 case dw_val_class_addr: 6622 size += DWARF2_ADDR_SIZE; 6623 break; 6624 case dw_val_class_offset: 6625 size += DWARF_OFFSET_SIZE; 6626 break; 6627 case dw_val_class_loc: 6628 { 6629 unsigned long lsize = size_of_locs (AT_loc (a)); 6630 6631 /* Block length. */ 6632 size += constant_size (lsize); 6633 size += lsize; 6634 } 6635 break; 6636 case dw_val_class_loc_list: 6637 size += DWARF_OFFSET_SIZE; 6638 break; 6639 case dw_val_class_range_list: 6640 size += DWARF_OFFSET_SIZE; 6641 break; 6642 case dw_val_class_const: 6643 size += size_of_sleb128 (AT_int (a)); 6644 break; 6645 case dw_val_class_unsigned_const: 6646 size += constant_size (AT_unsigned (a)); 6647 break; 6648 case dw_val_class_long_long: 6649 size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */ 6650 break; 6651 case dw_val_class_vec: 6652 size += 1 + (a->dw_attr_val.v.val_vec.length 6653 * a->dw_attr_val.v.val_vec.elt_size); /* block */ 6654 break; 6655 case dw_val_class_flag: 6656 size += 1; 6657 break; 6658 case dw_val_class_die_ref: 6659 if (AT_ref_external (a)) 6660 size += DWARF2_ADDR_SIZE; 6661 else 6662 size += DWARF_OFFSET_SIZE; 6663 break; 6664 case dw_val_class_fde_ref: 6665 size += DWARF_OFFSET_SIZE; 6666 break; 6667 case dw_val_class_lbl_id: 6668 size += DWARF2_ADDR_SIZE; 6669 break; 6670 case dw_val_class_lineptr: 6671 case dw_val_class_macptr: 6672 size += DWARF_OFFSET_SIZE; 6673 break; 6674 case dw_val_class_str: 6675 if (AT_string_form (a) == DW_FORM_strp) 6676 size += DWARF_OFFSET_SIZE; 6677 else 6678 size += strlen (a->dw_attr_val.v.val_str->str) + 1; 6679 break; 6680 case dw_val_class_file: 6681 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)); 6682 break; 6683 default: 6684 gcc_unreachable (); 6685 } 6686 } 6687 6688 return size; 6689} 6690 6691/* Size the debugging information associated with a given DIE. Visits the 6692 DIE's children recursively. Updates the global variable next_die_offset, on 6693 each time through. Uses the current value of next_die_offset to update the 6694 die_offset field in each DIE. */ 6695 6696static void 6697calc_die_sizes (dw_die_ref die) 6698{ 6699 dw_die_ref c; 6700 6701 die->die_offset = next_die_offset; 6702 next_die_offset += size_of_die (die); 6703 6704 FOR_EACH_CHILD (die, c, calc_die_sizes (c)); 6705 6706 if (die->die_child != NULL) 6707 /* Count the null byte used to terminate sibling lists. */ 6708 next_die_offset += 1; 6709} 6710 6711/* Set the marks for a die and its children. We do this so 6712 that we know whether or not a reference needs to use FORM_ref_addr; only 6713 DIEs in the same CU will be marked. We used to clear out the offset 6714 and use that as the flag, but ran into ordering problems. */ 6715 6716static void 6717mark_dies (dw_die_ref die) 6718{ 6719 dw_die_ref c; 6720 6721 gcc_assert (!die->die_mark); 6722 6723 die->die_mark = 1; 6724 FOR_EACH_CHILD (die, c, mark_dies (c)); 6725} 6726 6727/* Clear the marks for a die and its children. */ 6728 6729static void 6730unmark_dies (dw_die_ref die) 6731{ 6732 dw_die_ref c; 6733 6734 gcc_assert (die->die_mark); 6735 6736 die->die_mark = 0; 6737 FOR_EACH_CHILD (die, c, unmark_dies (c)); 6738} 6739 6740/* Clear the marks for a die, its children and referred dies. */ 6741 6742static void 6743unmark_all_dies (dw_die_ref die) 6744{ 6745 dw_die_ref c; 6746 dw_attr_ref a; 6747 unsigned ix; 6748 6749 if (!die->die_mark) 6750 return; 6751 die->die_mark = 0; 6752 6753 FOR_EACH_CHILD (die, c, unmark_all_dies (c)); 6754 6755 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 6756 if (AT_class (a) == dw_val_class_die_ref) 6757 unmark_all_dies (AT_ref (a)); 6758} 6759 6760/* Return the size of the .debug_pubnames or .debug_pubtypes table 6761 generated for the compilation unit. */ 6762 6763static unsigned long 6764size_of_pubnames (VEC (pubname_entry, gc) * names) 6765{ 6766 unsigned long size; 6767 unsigned i; 6768 pubname_ref p; 6769 6770 size = DWARF_PUBNAMES_HEADER_SIZE; 6771 for (i = 0; VEC_iterate (pubname_entry, names, i, p); i++) 6772 if (names != pubtype_table 6773 || p->die->die_offset != 0 6774 || !flag_eliminate_unused_debug_types) 6775 size += strlen (p->name) + DWARF_OFFSET_SIZE + 1; 6776 6777 size += DWARF_OFFSET_SIZE; 6778 return size; 6779} 6780 6781/* Return the size of the information in the .debug_aranges section. */ 6782 6783static unsigned long 6784size_of_aranges (void) 6785{ 6786 unsigned long size; 6787 6788 size = DWARF_ARANGES_HEADER_SIZE; 6789 6790 /* Count the address/length pair for this compilation unit. */ 6791 size += 2 * DWARF2_ADDR_SIZE; 6792 size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use; 6793 6794 /* Count the two zero words used to terminated the address range table. */ 6795 size += 2 * DWARF2_ADDR_SIZE; 6796 return size; 6797} 6798 6799/* Select the encoding of an attribute value. */ 6800 6801static enum dwarf_form 6802value_format (dw_attr_ref a) 6803{ 6804 switch (a->dw_attr_val.val_class) 6805 { 6806 case dw_val_class_addr: 6807 return DW_FORM_addr; 6808 case dw_val_class_range_list: 6809 case dw_val_class_offset: 6810 case dw_val_class_loc_list: 6811 switch (DWARF_OFFSET_SIZE) 6812 { 6813 case 4: 6814 return DW_FORM_data4; 6815 case 8: 6816 return DW_FORM_data8; 6817 default: 6818 gcc_unreachable (); 6819 } 6820 case dw_val_class_loc: 6821 switch (constant_size (size_of_locs (AT_loc (a)))) 6822 { 6823 case 1: 6824 return DW_FORM_block1; 6825 case 2: 6826 return DW_FORM_block2; 6827 default: 6828 gcc_unreachable (); 6829 } 6830 case dw_val_class_const: 6831 return DW_FORM_sdata; 6832 case dw_val_class_unsigned_const: 6833 switch (constant_size (AT_unsigned (a))) 6834 { 6835 case 1: 6836 return DW_FORM_data1; 6837 case 2: 6838 return DW_FORM_data2; 6839 case 4: 6840 return DW_FORM_data4; 6841 case 8: 6842 return DW_FORM_data8; 6843 default: 6844 gcc_unreachable (); 6845 } 6846 case dw_val_class_long_long: 6847 return DW_FORM_block1; 6848 case dw_val_class_vec: 6849 return DW_FORM_block1; 6850 case dw_val_class_flag: 6851 return DW_FORM_flag; 6852 case dw_val_class_die_ref: 6853 if (AT_ref_external (a)) 6854 return DW_FORM_ref_addr; 6855 else 6856 return DW_FORM_ref; 6857 case dw_val_class_fde_ref: 6858 return DW_FORM_data; 6859 case dw_val_class_lbl_id: 6860 return DW_FORM_addr; 6861 case dw_val_class_lineptr: 6862 case dw_val_class_macptr: 6863 return DW_FORM_data; 6864 case dw_val_class_str: 6865 return AT_string_form (a); 6866 case dw_val_class_file: 6867 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file))) 6868 { 6869 case 1: 6870 return DW_FORM_data1; 6871 case 2: 6872 return DW_FORM_data2; 6873 case 4: 6874 return DW_FORM_data4; 6875 default: 6876 gcc_unreachable (); 6877 } 6878 6879 default: 6880 gcc_unreachable (); 6881 } 6882} 6883 6884/* Output the encoding of an attribute value. */ 6885 6886static void 6887output_value_format (dw_attr_ref a) 6888{ 6889 enum dwarf_form form = value_format (a); 6890 6891 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form)); 6892} 6893 6894/* Output the .debug_abbrev section which defines the DIE abbreviation 6895 table. */ 6896 6897static void 6898output_abbrev_section (void) 6899{ 6900 unsigned long abbrev_id; 6901 6902 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id) 6903 { 6904 dw_die_ref abbrev = abbrev_die_table[abbrev_id]; 6905 unsigned ix; 6906 dw_attr_ref a_attr; 6907 6908 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)"); 6909 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)", 6910 dwarf_tag_name (abbrev->die_tag)); 6911 6912 if (abbrev->die_child != NULL) 6913 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes"); 6914 else 6915 dw2_asm_output_data (1, DW_children_no, "DW_children_no"); 6916 6917 for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr); 6918 ix++) 6919 { 6920 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)", 6921 dwarf_attr_name (a_attr->dw_attr)); 6922 output_value_format (a_attr); 6923 } 6924 6925 dw2_asm_output_data (1, 0, NULL); 6926 dw2_asm_output_data (1, 0, NULL); 6927 } 6928 6929 /* Terminate the table. */ 6930 dw2_asm_output_data (1, 0, NULL); 6931} 6932 6933/* Output a symbol we can use to refer to this DIE from another CU. */ 6934 6935static inline void 6936output_die_symbol (dw_die_ref die) 6937{ 6938 char *sym = die->die_symbol; 6939 6940 if (sym == 0) 6941 return; 6942 6943 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0) 6944 /* We make these global, not weak; if the target doesn't support 6945 .linkonce, it doesn't support combining the sections, so debugging 6946 will break. */ 6947 targetm.asm_out.globalize_label (asm_out_file, sym); 6948 6949 ASM_OUTPUT_LABEL (asm_out_file, sym); 6950} 6951 6952/* Return a new location list, given the begin and end range, and the 6953 expression. gensym tells us whether to generate a new internal symbol for 6954 this location list node, which is done for the head of the list only. */ 6955 6956static inline dw_loc_list_ref 6957new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end, 6958 const char *section, unsigned int gensym) 6959{ 6960 dw_loc_list_ref retlist = ggc_alloc_cleared (sizeof (dw_loc_list_node)); 6961 6962 retlist->begin = begin; 6963 retlist->end = end; 6964 retlist->expr = expr; 6965 retlist->section = section; 6966 if (gensym) 6967 retlist->ll_symbol = gen_internal_sym ("LLST"); 6968 6969 return retlist; 6970} 6971 6972/* Add a location description expression to a location list. */ 6973 6974static inline void 6975add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr, 6976 const char *begin, const char *end, 6977 const char *section) 6978{ 6979 dw_loc_list_ref *d; 6980 6981 /* Find the end of the chain. */ 6982 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next) 6983 ; 6984 6985 /* Add a new location list node to the list. */ 6986 *d = new_loc_list (descr, begin, end, section, 0); 6987} 6988 6989static void 6990dwarf2out_switch_text_section (void) 6991{ 6992 dw_fde_ref fde; 6993 6994 gcc_assert (cfun); 6995 6996 fde = &fde_table[fde_table_in_use - 1]; 6997 fde->dw_fde_switched_sections = true; 6998 fde->dw_fde_hot_section_label = cfun->hot_section_label; 6999 fde->dw_fde_hot_section_end_label = cfun->hot_section_end_label; 7000 fde->dw_fde_unlikely_section_label = cfun->cold_section_label; 7001 fde->dw_fde_unlikely_section_end_label = cfun->cold_section_end_label; 7002 have_multiple_function_sections = true; 7003 7004 /* Reset the current label on switching text sections, so that we 7005 don't attempt to advance_loc4 between labels in different sections. */ 7006 fde->dw_fde_current_label = NULL; 7007} 7008 7009/* Output the location list given to us. */ 7010 7011static void 7012output_loc_list (dw_loc_list_ref list_head) 7013{ 7014 dw_loc_list_ref curr = list_head; 7015 7016 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol); 7017 7018 /* Walk the location list, and output each range + expression. */ 7019 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next) 7020 { 7021 unsigned long size; 7022 if (!have_multiple_function_sections) 7023 { 7024 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section, 7025 "Location list begin address (%s)", 7026 list_head->ll_symbol); 7027 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section, 7028 "Location list end address (%s)", 7029 list_head->ll_symbol); 7030 } 7031 else 7032 { 7033 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin, 7034 "Location list begin address (%s)", 7035 list_head->ll_symbol); 7036 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end, 7037 "Location list end address (%s)", 7038 list_head->ll_symbol); 7039 } 7040 size = size_of_locs (curr->expr); 7041 7042 /* Output the block length for this list of location operations. */ 7043 gcc_assert (size <= 0xffff); 7044 dw2_asm_output_data (2, size, "%s", "Location expression size"); 7045 7046 output_loc_sequence (curr->expr); 7047 } 7048 7049 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, 7050 "Location list terminator begin (%s)", 7051 list_head->ll_symbol); 7052 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, 7053 "Location list terminator end (%s)", 7054 list_head->ll_symbol); 7055} 7056 7057/* Output the DIE and its attributes. Called recursively to generate 7058 the definitions of each child DIE. */ 7059 7060static void 7061output_die (dw_die_ref die) 7062{ 7063 dw_attr_ref a; 7064 dw_die_ref c; 7065 unsigned long size; 7066 unsigned ix; 7067 7068 /* If someone in another CU might refer to us, set up a symbol for 7069 them to point to. */ 7070 if (die->die_symbol) 7071 output_die_symbol (die); 7072 7073 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)", 7074 (unsigned long)die->die_offset, 7075 dwarf_tag_name (die->die_tag)); 7076 7077 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 7078 { 7079 const char *name = dwarf_attr_name (a->dw_attr); 7080 7081 switch (AT_class (a)) 7082 { 7083 case dw_val_class_addr: 7084 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name); 7085 break; 7086 7087 case dw_val_class_offset: 7088 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset, 7089 "%s", name); 7090 break; 7091 7092 case dw_val_class_range_list: 7093 { 7094 char *p = strchr (ranges_section_label, '\0'); 7095 7096 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX, 7097 a->dw_attr_val.v.val_offset); 7098 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label, 7099 debug_ranges_section, "%s", name); 7100 *p = '\0'; 7101 } 7102 break; 7103 7104 case dw_val_class_loc: 7105 size = size_of_locs (AT_loc (a)); 7106 7107 /* Output the block length for this list of location operations. */ 7108 dw2_asm_output_data (constant_size (size), size, "%s", name); 7109 7110 output_loc_sequence (AT_loc (a)); 7111 break; 7112 7113 case dw_val_class_const: 7114 /* ??? It would be slightly more efficient to use a scheme like is 7115 used for unsigned constants below, but gdb 4.x does not sign 7116 extend. Gdb 5.x does sign extend. */ 7117 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name); 7118 break; 7119 7120 case dw_val_class_unsigned_const: 7121 dw2_asm_output_data (constant_size (AT_unsigned (a)), 7122 AT_unsigned (a), "%s", name); 7123 break; 7124 7125 case dw_val_class_long_long: 7126 { 7127 unsigned HOST_WIDE_INT first, second; 7128 7129 dw2_asm_output_data (1, 7130 2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR, 7131 "%s", name); 7132 7133 if (WORDS_BIG_ENDIAN) 7134 { 7135 first = a->dw_attr_val.v.val_long_long.hi; 7136 second = a->dw_attr_val.v.val_long_long.low; 7137 } 7138 else 7139 { 7140 first = a->dw_attr_val.v.val_long_long.low; 7141 second = a->dw_attr_val.v.val_long_long.hi; 7142 } 7143 7144 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR, 7145 first, "long long constant"); 7146 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR, 7147 second, NULL); 7148 } 7149 break; 7150 7151 case dw_val_class_vec: 7152 { 7153 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size; 7154 unsigned int len = a->dw_attr_val.v.val_vec.length; 7155 unsigned int i; 7156 unsigned char *p; 7157 7158 dw2_asm_output_data (1, len * elt_size, "%s", name); 7159 if (elt_size > sizeof (HOST_WIDE_INT)) 7160 { 7161 elt_size /= 2; 7162 len *= 2; 7163 } 7164 for (i = 0, p = a->dw_attr_val.v.val_vec.array; 7165 i < len; 7166 i++, p += elt_size) 7167 dw2_asm_output_data (elt_size, extract_int (p, elt_size), 7168 "fp or vector constant word %u", i); 7169 break; 7170 } 7171 7172 case dw_val_class_flag: 7173 dw2_asm_output_data (1, AT_flag (a), "%s", name); 7174 break; 7175 7176 case dw_val_class_loc_list: 7177 { 7178 char *sym = AT_loc_list (a)->ll_symbol; 7179 7180 gcc_assert (sym); 7181 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section, 7182 "%s", name); 7183 } 7184 break; 7185 7186 case dw_val_class_die_ref: 7187 if (AT_ref_external (a)) 7188 { 7189 char *sym = AT_ref (a)->die_symbol; 7190 7191 gcc_assert (sym); 7192 dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, debug_info_section, 7193 "%s", name); 7194 } 7195 else 7196 { 7197 gcc_assert (AT_ref (a)->die_offset); 7198 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset, 7199 "%s", name); 7200 } 7201 break; 7202 7203 case dw_val_class_fde_ref: 7204 { 7205 char l1[20]; 7206 7207 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL, 7208 a->dw_attr_val.v.val_fde_index * 2); 7209 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section, 7210 "%s", name); 7211 } 7212 break; 7213 7214 case dw_val_class_lbl_id: 7215 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name); 7216 break; 7217 7218 case dw_val_class_lineptr: 7219 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a), 7220 debug_line_section, "%s", name); 7221 break; 7222 7223 case dw_val_class_macptr: 7224 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a), 7225 debug_macinfo_section, "%s", name); 7226 break; 7227 7228 case dw_val_class_str: 7229 if (AT_string_form (a) == DW_FORM_strp) 7230 dw2_asm_output_offset (DWARF_OFFSET_SIZE, 7231 a->dw_attr_val.v.val_str->label, 7232 debug_str_section, 7233 "%s: \"%s\"", name, AT_string (a)); 7234 else 7235 dw2_asm_output_nstring (AT_string (a), -1, "%s", name); 7236 break; 7237 7238 case dw_val_class_file: 7239 { 7240 int f = maybe_emit_file (a->dw_attr_val.v.val_file); 7241 7242 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name, 7243 a->dw_attr_val.v.val_file->filename); 7244 break; 7245 } 7246 7247 default: 7248 gcc_unreachable (); 7249 } 7250 } 7251 7252 FOR_EACH_CHILD (die, c, output_die (c)); 7253 7254 /* Add null byte to terminate sibling list. */ 7255 if (die->die_child != NULL) 7256 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx", 7257 (unsigned long) die->die_offset); 7258} 7259 7260/* Output the compilation unit that appears at the beginning of the 7261 .debug_info section, and precedes the DIE descriptions. */ 7262 7263static void 7264output_compilation_unit_header (void) 7265{ 7266 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 7267 dw2_asm_output_data (4, 0xffffffff, 7268 "Initial length escape value indicating 64-bit DWARF extension"); 7269 dw2_asm_output_data (DWARF_OFFSET_SIZE, 7270 next_die_offset - DWARF_INITIAL_LENGTH_SIZE, 7271 "Length of Compilation Unit Info"); 7272 dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number"); 7273 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label, 7274 debug_abbrev_section, 7275 "Offset Into Abbrev. Section"); 7276 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)"); 7277} 7278 7279/* Output the compilation unit DIE and its children. */ 7280 7281static void 7282output_comp_unit (dw_die_ref die, int output_if_empty) 7283{ 7284 const char *secname; 7285 char *oldsym, *tmp; 7286 7287 /* Unless we are outputting main CU, we may throw away empty ones. */ 7288 if (!output_if_empty && die->die_child == NULL) 7289 return; 7290 7291 /* Even if there are no children of this DIE, we must output the information 7292 about the compilation unit. Otherwise, on an empty translation unit, we 7293 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm' 7294 will then complain when examining the file. First mark all the DIEs in 7295 this CU so we know which get local refs. */ 7296 mark_dies (die); 7297 7298 build_abbrev_table (die); 7299 7300 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */ 7301 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE; 7302 calc_die_sizes (die); 7303 7304 oldsym = die->die_symbol; 7305 if (oldsym) 7306 { 7307 tmp = alloca (strlen (oldsym) + 24); 7308 7309 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym); 7310 secname = tmp; 7311 die->die_symbol = NULL; 7312 switch_to_section (get_section (secname, SECTION_DEBUG, NULL)); 7313 } 7314 else 7315 switch_to_section (debug_info_section); 7316 7317 /* Output debugging information. */ 7318 output_compilation_unit_header (); 7319 output_die (die); 7320 7321 /* Leave the marks on the main CU, so we can check them in 7322 output_pubnames. */ 7323 if (oldsym) 7324 { 7325 unmark_dies (die); 7326 die->die_symbol = oldsym; 7327 } 7328} 7329 7330/* Return the DWARF2/3 pubname associated with a decl. */ 7331 7332static const char * 7333dwarf2_name (tree decl, int scope) 7334{ 7335 return lang_hooks.dwarf_name (decl, scope ? 1 : 0); 7336} 7337 7338/* Add a new entry to .debug_pubnames if appropriate. */ 7339 7340static void 7341add_pubname (tree decl, dw_die_ref die) 7342{ 7343 pubname_entry e; 7344 7345 if (! TREE_PUBLIC (decl)) 7346 return; 7347 7348 e.die = die; 7349 e.name = xstrdup (dwarf2_name (decl, 1)); 7350 VEC_safe_push (pubname_entry, gc, pubname_table, &e); 7351} 7352 7353/* Add a new entry to .debug_pubtypes if appropriate. */ 7354 7355static void 7356add_pubtype (tree decl, dw_die_ref die) 7357{ 7358 pubname_entry e; 7359 7360 e.name = NULL; 7361 if ((TREE_PUBLIC (decl) 7362 || die->die_parent == comp_unit_die) 7363 && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl))) 7364 { 7365 e.die = die; 7366 if (TYPE_P (decl)) 7367 { 7368 if (TYPE_NAME (decl)) 7369 { 7370 if (TREE_CODE (TYPE_NAME (decl)) == IDENTIFIER_NODE) 7371 e.name = xstrdup ((const char *) IDENTIFIER_POINTER 7372 (TYPE_NAME (decl))); 7373 else if (TREE_CODE (TYPE_NAME (decl)) == TYPE_DECL 7374 && DECL_NAME (TYPE_NAME (decl))) 7375 e.name = xstrdup ((const char *) IDENTIFIER_POINTER 7376 (DECL_NAME (TYPE_NAME (decl)))); 7377 else 7378 e.name = xstrdup ((const char *) get_AT_string (die, DW_AT_name)); 7379 } 7380 } 7381 else 7382 e.name = xstrdup (dwarf2_name (decl, 1)); 7383 7384 /* If we don't have a name for the type, there's no point in adding 7385 it to the table. */ 7386 if (e.name && e.name[0] != '\0') 7387 VEC_safe_push (pubname_entry, gc, pubtype_table, &e); 7388 } 7389} 7390 7391/* Output the public names table used to speed up access to externally 7392 visible names; or the public types table used to find type definitions. */ 7393 7394static void 7395output_pubnames (VEC (pubname_entry, gc) * names) 7396{ 7397 unsigned i; 7398 unsigned long pubnames_length = size_of_pubnames (names); 7399 pubname_ref pub; 7400 7401 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 7402 dw2_asm_output_data (4, 0xffffffff, 7403 "Initial length escape value indicating 64-bit DWARF extension"); 7404 if (names == pubname_table) 7405 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length, 7406 "Length of Public Names Info"); 7407 else 7408 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length, 7409 "Length of Public Type Names Info"); 7410 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version"); 7411 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label, 7412 debug_info_section, 7413 "Offset of Compilation Unit Info"); 7414 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset, 7415 "Compilation Unit Length"); 7416 7417 for (i = 0; VEC_iterate (pubname_entry, names, i, pub); i++) 7418 { 7419 /* We shouldn't see pubnames for DIEs outside of the main CU. */ 7420 if (names == pubname_table) 7421 gcc_assert (pub->die->die_mark); 7422 7423 if (names != pubtype_table 7424 || pub->die->die_offset != 0 7425 || !flag_eliminate_unused_debug_types) 7426 { 7427 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset, 7428 "DIE offset"); 7429 7430 dw2_asm_output_nstring (pub->name, -1, "external name"); 7431 } 7432 } 7433 7434 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL); 7435} 7436 7437/* Add a new entry to .debug_aranges if appropriate. */ 7438 7439static void 7440add_arange (tree decl, dw_die_ref die) 7441{ 7442 if (! DECL_SECTION_NAME (decl)) 7443 return; 7444 7445 if (arange_table_in_use == arange_table_allocated) 7446 { 7447 arange_table_allocated += ARANGE_TABLE_INCREMENT; 7448 arange_table = ggc_realloc (arange_table, 7449 (arange_table_allocated 7450 * sizeof (dw_die_ref))); 7451 memset (arange_table + arange_table_in_use, 0, 7452 ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref)); 7453 } 7454 7455 arange_table[arange_table_in_use++] = die; 7456} 7457 7458/* Output the information that goes into the .debug_aranges table. 7459 Namely, define the beginning and ending address range of the 7460 text section generated for this compilation unit. */ 7461 7462static void 7463output_aranges (void) 7464{ 7465 unsigned i; 7466 unsigned long aranges_length = size_of_aranges (); 7467 7468 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 7469 dw2_asm_output_data (4, 0xffffffff, 7470 "Initial length escape value indicating 64-bit DWARF extension"); 7471 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length, 7472 "Length of Address Ranges Info"); 7473 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version"); 7474 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label, 7475 debug_info_section, 7476 "Offset of Compilation Unit Info"); 7477 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address"); 7478 dw2_asm_output_data (1, 0, "Size of Segment Descriptor"); 7479 7480 /* We need to align to twice the pointer size here. */ 7481 if (DWARF_ARANGES_PAD_SIZE) 7482 { 7483 /* Pad using a 2 byte words so that padding is correct for any 7484 pointer size. */ 7485 dw2_asm_output_data (2, 0, "Pad to %d byte boundary", 7486 2 * DWARF2_ADDR_SIZE); 7487 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2) 7488 dw2_asm_output_data (2, 0, NULL); 7489 } 7490 7491 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address"); 7492 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label, 7493 text_section_label, "Length"); 7494 if (flag_reorder_blocks_and_partition) 7495 { 7496 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label, 7497 "Address"); 7498 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label, 7499 cold_text_section_label, "Length"); 7500 } 7501 7502 for (i = 0; i < arange_table_in_use; i++) 7503 { 7504 dw_die_ref die = arange_table[i]; 7505 7506 /* We shouldn't see aranges for DIEs outside of the main CU. */ 7507 gcc_assert (die->die_mark); 7508 7509 if (die->die_tag == DW_TAG_subprogram) 7510 { 7511 dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die), 7512 "Address"); 7513 dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die), 7514 get_AT_low_pc (die), "Length"); 7515 } 7516 else 7517 { 7518 /* A static variable; extract the symbol from DW_AT_location. 7519 Note that this code isn't currently hit, as we only emit 7520 aranges for functions (jason 9/23/99). */ 7521 dw_attr_ref a = get_AT (die, DW_AT_location); 7522 dw_loc_descr_ref loc; 7523 7524 gcc_assert (a && AT_class (a) == dw_val_class_loc); 7525 7526 loc = AT_loc (a); 7527 gcc_assert (loc->dw_loc_opc == DW_OP_addr); 7528 7529 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, 7530 loc->dw_loc_oprnd1.v.val_addr, "Address"); 7531 dw2_asm_output_data (DWARF2_ADDR_SIZE, 7532 get_AT_unsigned (die, DW_AT_byte_size), 7533 "Length"); 7534 } 7535 } 7536 7537 /* Output the terminator words. */ 7538 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 7539 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 7540} 7541 7542/* Add a new entry to .debug_ranges. Return the offset at which it 7543 was placed. */ 7544 7545static unsigned int 7546add_ranges (tree block) 7547{ 7548 unsigned int in_use = ranges_table_in_use; 7549 7550 if (in_use == ranges_table_allocated) 7551 { 7552 ranges_table_allocated += RANGES_TABLE_INCREMENT; 7553 ranges_table 7554 = ggc_realloc (ranges_table, (ranges_table_allocated 7555 * sizeof (struct dw_ranges_struct))); 7556 memset (ranges_table + ranges_table_in_use, 0, 7557 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct)); 7558 } 7559 7560 ranges_table[in_use].block_num = (block ? BLOCK_NUMBER (block) : 0); 7561 ranges_table_in_use = in_use + 1; 7562 7563 return in_use * 2 * DWARF2_ADDR_SIZE; 7564} 7565 7566static void 7567output_ranges (void) 7568{ 7569 unsigned i; 7570 static const char *const start_fmt = "Offset 0x%x"; 7571 const char *fmt = start_fmt; 7572 7573 for (i = 0; i < ranges_table_in_use; i++) 7574 { 7575 int block_num = ranges_table[i].block_num; 7576 7577 if (block_num) 7578 { 7579 char blabel[MAX_ARTIFICIAL_LABEL_BYTES]; 7580 char elabel[MAX_ARTIFICIAL_LABEL_BYTES]; 7581 7582 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num); 7583 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num); 7584 7585 /* If all code is in the text section, then the compilation 7586 unit base address defaults to DW_AT_low_pc, which is the 7587 base of the text section. */ 7588 if (!have_multiple_function_sections) 7589 { 7590 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel, 7591 text_section_label, 7592 fmt, i * 2 * DWARF2_ADDR_SIZE); 7593 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel, 7594 text_section_label, NULL); 7595 } 7596 7597 /* Otherwise, we add a DW_AT_entry_pc attribute to force the 7598 compilation unit base address to zero, which allows us to 7599 use absolute addresses, and not worry about whether the 7600 target supports cross-section arithmetic. */ 7601 else 7602 { 7603 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel, 7604 fmt, i * 2 * DWARF2_ADDR_SIZE); 7605 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL); 7606 } 7607 7608 fmt = NULL; 7609 } 7610 else 7611 { 7612 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 7613 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 7614 fmt = start_fmt; 7615 } 7616 } 7617} 7618 7619/* Data structure containing information about input files. */ 7620struct file_info 7621{ 7622 const char *path; /* Complete file name. */ 7623 const char *fname; /* File name part. */ 7624 int length; /* Length of entire string. */ 7625 struct dwarf_file_data * file_idx; /* Index in input file table. */ 7626 int dir_idx; /* Index in directory table. */ 7627}; 7628 7629/* Data structure containing information about directories with source 7630 files. */ 7631struct dir_info 7632{ 7633 const char *path; /* Path including directory name. */ 7634 int length; /* Path length. */ 7635 int prefix; /* Index of directory entry which is a prefix. */ 7636 int count; /* Number of files in this directory. */ 7637 int dir_idx; /* Index of directory used as base. */ 7638}; 7639 7640/* Callback function for file_info comparison. We sort by looking at 7641 the directories in the path. */ 7642 7643static int 7644file_info_cmp (const void *p1, const void *p2) 7645{ 7646 const struct file_info *s1 = p1; 7647 const struct file_info *s2 = p2; 7648 unsigned char *cp1; 7649 unsigned char *cp2; 7650 7651 /* Take care of file names without directories. We need to make sure that 7652 we return consistent values to qsort since some will get confused if 7653 we return the same value when identical operands are passed in opposite 7654 orders. So if neither has a directory, return 0 and otherwise return 7655 1 or -1 depending on which one has the directory. */ 7656 if ((s1->path == s1->fname || s2->path == s2->fname)) 7657 return (s2->path == s2->fname) - (s1->path == s1->fname); 7658 7659 cp1 = (unsigned char *) s1->path; 7660 cp2 = (unsigned char *) s2->path; 7661 7662 while (1) 7663 { 7664 ++cp1; 7665 ++cp2; 7666 /* Reached the end of the first path? If so, handle like above. */ 7667 if ((cp1 == (unsigned char *) s1->fname) 7668 || (cp2 == (unsigned char *) s2->fname)) 7669 return ((cp2 == (unsigned char *) s2->fname) 7670 - (cp1 == (unsigned char *) s1->fname)); 7671 7672 /* Character of current path component the same? */ 7673 else if (*cp1 != *cp2) 7674 return *cp1 - *cp2; 7675 } 7676} 7677 7678struct file_name_acquire_data 7679{ 7680 struct file_info *files; 7681 int used_files; 7682 int max_files; 7683}; 7684 7685/* Traversal function for the hash table. */ 7686 7687static int 7688file_name_acquire (void ** slot, void *data) 7689{ 7690 struct file_name_acquire_data *fnad = data; 7691 struct dwarf_file_data *d = *slot; 7692 struct file_info *fi; 7693 const char *f; 7694 7695 gcc_assert (fnad->max_files >= d->emitted_number); 7696 7697 if (! d->emitted_number) 7698 return 1; 7699 7700 gcc_assert (fnad->max_files != fnad->used_files); 7701 7702 fi = fnad->files + fnad->used_files++; 7703 7704 /* Skip all leading "./". */ 7705 f = d->filename; 7706 while (f[0] == '.' && f[1] == '/') 7707 f += 2; 7708 7709 /* Create a new array entry. */ 7710 fi->path = f; 7711 fi->length = strlen (f); 7712 fi->file_idx = d; 7713 7714 /* Search for the file name part. */ 7715 f = strrchr (f, '/'); 7716 fi->fname = f == NULL ? fi->path : f + 1; 7717 return 1; 7718} 7719 7720/* Output the directory table and the file name table. We try to minimize 7721 the total amount of memory needed. A heuristic is used to avoid large 7722 slowdowns with many input files. */ 7723 7724static void 7725output_file_names (void) 7726{ 7727 struct file_name_acquire_data fnad; 7728 int numfiles; 7729 struct file_info *files; 7730 struct dir_info *dirs; 7731 int *saved; 7732 int *savehere; 7733 int *backmap; 7734 int ndirs; 7735 int idx_offset; 7736 int i; 7737 int idx; 7738 7739 if (!last_emitted_file) 7740 { 7741 dw2_asm_output_data (1, 0, "End directory table"); 7742 dw2_asm_output_data (1, 0, "End file name table"); 7743 return; 7744 } 7745 7746 numfiles = last_emitted_file->emitted_number; 7747 7748 /* Allocate the various arrays we need. */ 7749 files = alloca (numfiles * sizeof (struct file_info)); 7750 dirs = alloca (numfiles * sizeof (struct dir_info)); 7751 7752 fnad.files = files; 7753 fnad.used_files = 0; 7754 fnad.max_files = numfiles; 7755 htab_traverse (file_table, file_name_acquire, &fnad); 7756 gcc_assert (fnad.used_files == fnad.max_files); 7757 7758 qsort (files, numfiles, sizeof (files[0]), file_info_cmp); 7759 7760 /* Find all the different directories used. */ 7761 dirs[0].path = files[0].path; 7762 dirs[0].length = files[0].fname - files[0].path; 7763 dirs[0].prefix = -1; 7764 dirs[0].count = 1; 7765 dirs[0].dir_idx = 0; 7766 files[0].dir_idx = 0; 7767 ndirs = 1; 7768 7769 for (i = 1; i < numfiles; i++) 7770 if (files[i].fname - files[i].path == dirs[ndirs - 1].length 7771 && memcmp (dirs[ndirs - 1].path, files[i].path, 7772 dirs[ndirs - 1].length) == 0) 7773 { 7774 /* Same directory as last entry. */ 7775 files[i].dir_idx = ndirs - 1; 7776 ++dirs[ndirs - 1].count; 7777 } 7778 else 7779 { 7780 int j; 7781 7782 /* This is a new directory. */ 7783 dirs[ndirs].path = files[i].path; 7784 dirs[ndirs].length = files[i].fname - files[i].path; 7785 dirs[ndirs].count = 1; 7786 dirs[ndirs].dir_idx = ndirs; 7787 files[i].dir_idx = ndirs; 7788 7789 /* Search for a prefix. */ 7790 dirs[ndirs].prefix = -1; 7791 for (j = 0; j < ndirs; j++) 7792 if (dirs[j].length < dirs[ndirs].length 7793 && dirs[j].length > 1 7794 && (dirs[ndirs].prefix == -1 7795 || dirs[j].length > dirs[dirs[ndirs].prefix].length) 7796 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0) 7797 dirs[ndirs].prefix = j; 7798 7799 ++ndirs; 7800 } 7801 7802 /* Now to the actual work. We have to find a subset of the directories which 7803 allow expressing the file name using references to the directory table 7804 with the least amount of characters. We do not do an exhaustive search 7805 where we would have to check out every combination of every single 7806 possible prefix. Instead we use a heuristic which provides nearly optimal 7807 results in most cases and never is much off. */ 7808 saved = alloca (ndirs * sizeof (int)); 7809 savehere = alloca (ndirs * sizeof (int)); 7810 7811 memset (saved, '\0', ndirs * sizeof (saved[0])); 7812 for (i = 0; i < ndirs; i++) 7813 { 7814 int j; 7815 int total; 7816 7817 /* We can always save some space for the current directory. But this 7818 does not mean it will be enough to justify adding the directory. */ 7819 savehere[i] = dirs[i].length; 7820 total = (savehere[i] - saved[i]) * dirs[i].count; 7821 7822 for (j = i + 1; j < ndirs; j++) 7823 { 7824 savehere[j] = 0; 7825 if (saved[j] < dirs[i].length) 7826 { 7827 /* Determine whether the dirs[i] path is a prefix of the 7828 dirs[j] path. */ 7829 int k; 7830 7831 k = dirs[j].prefix; 7832 while (k != -1 && k != (int) i) 7833 k = dirs[k].prefix; 7834 7835 if (k == (int) i) 7836 { 7837 /* Yes it is. We can possibly save some memory by 7838 writing the filenames in dirs[j] relative to 7839 dirs[i]. */ 7840 savehere[j] = dirs[i].length; 7841 total += (savehere[j] - saved[j]) * dirs[j].count; 7842 } 7843 } 7844 } 7845 7846 /* Check whether we can save enough to justify adding the dirs[i] 7847 directory. */ 7848 if (total > dirs[i].length + 1) 7849 { 7850 /* It's worthwhile adding. */ 7851 for (j = i; j < ndirs; j++) 7852 if (savehere[j] > 0) 7853 { 7854 /* Remember how much we saved for this directory so far. */ 7855 saved[j] = savehere[j]; 7856 7857 /* Remember the prefix directory. */ 7858 dirs[j].dir_idx = i; 7859 } 7860 } 7861 } 7862 7863 /* Emit the directory name table. */ 7864 idx = 1; 7865 idx_offset = dirs[0].length > 0 ? 1 : 0; 7866 for (i = 1 - idx_offset; i < ndirs; i++) 7867 dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1, 7868 "Directory Entry: 0x%x", i + idx_offset); 7869 7870 dw2_asm_output_data (1, 0, "End directory table"); 7871 7872 /* We have to emit them in the order of emitted_number since that's 7873 used in the debug info generation. To do this efficiently we 7874 generate a back-mapping of the indices first. */ 7875 backmap = alloca (numfiles * sizeof (int)); 7876 for (i = 0; i < numfiles; i++) 7877 backmap[files[i].file_idx->emitted_number - 1] = i; 7878 7879 /* Now write all the file names. */ 7880 for (i = 0; i < numfiles; i++) 7881 { 7882 int file_idx = backmap[i]; 7883 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx; 7884 7885 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1, 7886 "File Entry: 0x%x", (unsigned) i + 1); 7887 7888 /* Include directory index. */ 7889 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL); 7890 7891 /* Modification time. */ 7892 dw2_asm_output_data_uleb128 (0, NULL); 7893 7894 /* File length in bytes. */ 7895 dw2_asm_output_data_uleb128 (0, NULL); 7896 } 7897 7898 dw2_asm_output_data (1, 0, "End file name table"); 7899} 7900 7901 7902/* Output the source line number correspondence information. This 7903 information goes into the .debug_line section. */ 7904 7905static void 7906output_line_info (void) 7907{ 7908 char l1[20], l2[20], p1[20], p2[20]; 7909 char line_label[MAX_ARTIFICIAL_LABEL_BYTES]; 7910 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES]; 7911 unsigned opc; 7912 unsigned n_op_args; 7913 unsigned long lt_index; 7914 unsigned long current_line; 7915 long line_offset; 7916 long line_delta; 7917 unsigned long current_file; 7918 unsigned long function; 7919 7920 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0); 7921 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0); 7922 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0); 7923 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0); 7924 7925 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 7926 dw2_asm_output_data (4, 0xffffffff, 7927 "Initial length escape value indicating 64-bit DWARF extension"); 7928 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1, 7929 "Length of Source Line Info"); 7930 ASM_OUTPUT_LABEL (asm_out_file, l1); 7931 7932 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version"); 7933 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length"); 7934 ASM_OUTPUT_LABEL (asm_out_file, p1); 7935 7936 /* Define the architecture-dependent minimum instruction length (in 7937 bytes). In this implementation of DWARF, this field is used for 7938 information purposes only. Since GCC generates assembly language, 7939 we have no a priori knowledge of how many instruction bytes are 7940 generated for each source line, and therefore can use only the 7941 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information 7942 commands. Accordingly, we fix this as `1', which is "correct 7943 enough" for all architectures, and don't let the target override. */ 7944 dw2_asm_output_data (1, 1, 7945 "Minimum Instruction Length"); 7946 7947 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START, 7948 "Default is_stmt_start flag"); 7949 dw2_asm_output_data (1, DWARF_LINE_BASE, 7950 "Line Base Value (Special Opcodes)"); 7951 dw2_asm_output_data (1, DWARF_LINE_RANGE, 7952 "Line Range Value (Special Opcodes)"); 7953 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE, 7954 "Special Opcode Base"); 7955 7956 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++) 7957 { 7958 switch (opc) 7959 { 7960 case DW_LNS_advance_pc: 7961 case DW_LNS_advance_line: 7962 case DW_LNS_set_file: 7963 case DW_LNS_set_column: 7964 case DW_LNS_fixed_advance_pc: 7965 n_op_args = 1; 7966 break; 7967 default: 7968 n_op_args = 0; 7969 break; 7970 } 7971 7972 dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args", 7973 opc, n_op_args); 7974 } 7975 7976 /* Write out the information about the files we use. */ 7977 output_file_names (); 7978 ASM_OUTPUT_LABEL (asm_out_file, p2); 7979 7980 /* We used to set the address register to the first location in the text 7981 section here, but that didn't accomplish anything since we already 7982 have a line note for the opening brace of the first function. */ 7983 7984 /* Generate the line number to PC correspondence table, encoded as 7985 a series of state machine operations. */ 7986 current_file = 1; 7987 current_line = 1; 7988 7989 if (cfun && in_cold_section_p) 7990 strcpy (prev_line_label, cfun->cold_section_label); 7991 else 7992 strcpy (prev_line_label, text_section_label); 7993 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index) 7994 { 7995 dw_line_info_ref line_info = &line_info_table[lt_index]; 7996 7997#if 0 7998 /* Disable this optimization for now; GDB wants to see two line notes 7999 at the beginning of a function so it can find the end of the 8000 prologue. */ 8001 8002 /* Don't emit anything for redundant notes. Just updating the 8003 address doesn't accomplish anything, because we already assume 8004 that anything after the last address is this line. */ 8005 if (line_info->dw_line_num == current_line 8006 && line_info->dw_file_num == current_file) 8007 continue; 8008#endif 8009 8010 /* Emit debug info for the address of the current line. 8011 8012 Unfortunately, we have little choice here currently, and must always 8013 use the most general form. GCC does not know the address delta 8014 itself, so we can't use DW_LNS_advance_pc. Many ports do have length 8015 attributes which will give an upper bound on the address range. We 8016 could perhaps use length attributes to determine when it is safe to 8017 use DW_LNS_fixed_advance_pc. */ 8018 8019 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index); 8020 if (0) 8021 { 8022 /* This can handle deltas up to 0xffff. This takes 3 bytes. */ 8023 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, 8024 "DW_LNS_fixed_advance_pc"); 8025 dw2_asm_output_delta (2, line_label, prev_line_label, NULL); 8026 } 8027 else 8028 { 8029 /* This can handle any delta. This takes 8030 4+DWARF2_ADDR_SIZE bytes. */ 8031 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 8032 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 8033 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 8034 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL); 8035 } 8036 8037 strcpy (prev_line_label, line_label); 8038 8039 /* Emit debug info for the source file of the current line, if 8040 different from the previous line. */ 8041 if (line_info->dw_file_num != current_file) 8042 { 8043 current_file = line_info->dw_file_num; 8044 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file"); 8045 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file); 8046 } 8047 8048 /* Emit debug info for the current line number, choosing the encoding 8049 that uses the least amount of space. */ 8050 if (line_info->dw_line_num != current_line) 8051 { 8052 line_offset = line_info->dw_line_num - current_line; 8053 line_delta = line_offset - DWARF_LINE_BASE; 8054 current_line = line_info->dw_line_num; 8055 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1)) 8056 /* This can handle deltas from -10 to 234, using the current 8057 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This 8058 takes 1 byte. */ 8059 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta, 8060 "line %lu", current_line); 8061 else 8062 { 8063 /* This can handle any delta. This takes at least 4 bytes, 8064 depending on the value being encoded. */ 8065 dw2_asm_output_data (1, DW_LNS_advance_line, 8066 "advance to line %lu", current_line); 8067 dw2_asm_output_data_sleb128 (line_offset, NULL); 8068 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); 8069 } 8070 } 8071 else 8072 /* We still need to start a new row, so output a copy insn. */ 8073 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); 8074 } 8075 8076 /* Emit debug info for the address of the end of the function. */ 8077 if (0) 8078 { 8079 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, 8080 "DW_LNS_fixed_advance_pc"); 8081 dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL); 8082 } 8083 else 8084 { 8085 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 8086 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 8087 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 8088 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL); 8089 } 8090 8091 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence"); 8092 dw2_asm_output_data_uleb128 (1, NULL); 8093 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL); 8094 8095 function = 0; 8096 current_file = 1; 8097 current_line = 1; 8098 for (lt_index = 0; lt_index < separate_line_info_table_in_use;) 8099 { 8100 dw_separate_line_info_ref line_info 8101 = &separate_line_info_table[lt_index]; 8102 8103#if 0 8104 /* Don't emit anything for redundant notes. */ 8105 if (line_info->dw_line_num == current_line 8106 && line_info->dw_file_num == current_file 8107 && line_info->function == function) 8108 goto cont; 8109#endif 8110 8111 /* Emit debug info for the address of the current line. If this is 8112 a new function, or the first line of a function, then we need 8113 to handle it differently. */ 8114 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL, 8115 lt_index); 8116 if (function != line_info->function) 8117 { 8118 function = line_info->function; 8119 8120 /* Set the address register to the first line in the function. */ 8121 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 8122 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 8123 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 8124 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL); 8125 } 8126 else 8127 { 8128 /* ??? See the DW_LNS_advance_pc comment above. */ 8129 if (0) 8130 { 8131 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, 8132 "DW_LNS_fixed_advance_pc"); 8133 dw2_asm_output_delta (2, line_label, prev_line_label, NULL); 8134 } 8135 else 8136 { 8137 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 8138 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 8139 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 8140 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL); 8141 } 8142 } 8143 8144 strcpy (prev_line_label, line_label); 8145 8146 /* Emit debug info for the source file of the current line, if 8147 different from the previous line. */ 8148 if (line_info->dw_file_num != current_file) 8149 { 8150 current_file = line_info->dw_file_num; 8151 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file"); 8152 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file); 8153 } 8154 8155 /* Emit debug info for the current line number, choosing the encoding 8156 that uses the least amount of space. */ 8157 if (line_info->dw_line_num != current_line) 8158 { 8159 line_offset = line_info->dw_line_num - current_line; 8160 line_delta = line_offset - DWARF_LINE_BASE; 8161 current_line = line_info->dw_line_num; 8162 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1)) 8163 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta, 8164 "line %lu", current_line); 8165 else 8166 { 8167 dw2_asm_output_data (1, DW_LNS_advance_line, 8168 "advance to line %lu", current_line); 8169 dw2_asm_output_data_sleb128 (line_offset, NULL); 8170 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); 8171 } 8172 } 8173 else 8174 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); 8175 8176#if 0 8177 cont: 8178#endif 8179 8180 lt_index++; 8181 8182 /* If we're done with a function, end its sequence. */ 8183 if (lt_index == separate_line_info_table_in_use 8184 || separate_line_info_table[lt_index].function != function) 8185 { 8186 current_file = 1; 8187 current_line = 1; 8188 8189 /* Emit debug info for the address of the end of the function. */ 8190 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function); 8191 if (0) 8192 { 8193 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, 8194 "DW_LNS_fixed_advance_pc"); 8195 dw2_asm_output_delta (2, line_label, prev_line_label, NULL); 8196 } 8197 else 8198 { 8199 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 8200 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 8201 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 8202 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL); 8203 } 8204 8205 /* Output the marker for the end of this sequence. */ 8206 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence"); 8207 dw2_asm_output_data_uleb128 (1, NULL); 8208 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL); 8209 } 8210 } 8211 8212 /* Output the marker for the end of the line number info. */ 8213 ASM_OUTPUT_LABEL (asm_out_file, l2); 8214} 8215 8216/* Given a pointer to a tree node for some base type, return a pointer to 8217 a DIE that describes the given type. 8218 8219 This routine must only be called for GCC type nodes that correspond to 8220 Dwarf base (fundamental) types. */ 8221 8222static dw_die_ref 8223base_type_die (tree type) 8224{ 8225 dw_die_ref base_type_result; 8226 enum dwarf_type encoding; 8227 8228 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE) 8229 return 0; 8230 8231 switch (TREE_CODE (type)) 8232 { 8233 case INTEGER_TYPE: 8234 if (TYPE_STRING_FLAG (type)) 8235 { 8236 if (TYPE_UNSIGNED (type)) 8237 encoding = DW_ATE_unsigned_char; 8238 else 8239 encoding = DW_ATE_signed_char; 8240 } 8241 else if (TYPE_UNSIGNED (type)) 8242 encoding = DW_ATE_unsigned; 8243 else 8244 encoding = DW_ATE_signed; 8245 break; 8246 8247 case REAL_TYPE: 8248 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type))) 8249 encoding = DW_ATE_decimal_float; 8250 else 8251 encoding = DW_ATE_float; 8252 break; 8253 8254 /* Dwarf2 doesn't know anything about complex ints, so use 8255 a user defined type for it. */ 8256 case COMPLEX_TYPE: 8257 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE) 8258 encoding = DW_ATE_complex_float; 8259 else 8260 encoding = DW_ATE_lo_user; 8261 break; 8262 8263 case BOOLEAN_TYPE: 8264 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */ 8265 encoding = DW_ATE_boolean; 8266 break; 8267 8268 default: 8269 /* No other TREE_CODEs are Dwarf fundamental types. */ 8270 gcc_unreachable (); 8271 } 8272 8273 base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type); 8274 8275 /* This probably indicates a bug. */ 8276 if (! TYPE_NAME (type)) 8277 add_name_attribute (base_type_result, "__unknown__"); 8278 8279 add_AT_unsigned (base_type_result, DW_AT_byte_size, 8280 int_size_in_bytes (type)); 8281 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding); 8282 8283 return base_type_result; 8284} 8285 8286/* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to 8287 the Dwarf "root" type for the given input type. The Dwarf "root" type of 8288 a given type is generally the same as the given type, except that if the 8289 given type is a pointer or reference type, then the root type of the given 8290 type is the root type of the "basis" type for the pointer or reference 8291 type. (This definition of the "root" type is recursive.) Also, the root 8292 type of a `const' qualified type or a `volatile' qualified type is the 8293 root type of the given type without the qualifiers. */ 8294 8295static tree 8296root_type (tree type) 8297{ 8298 if (TREE_CODE (type) == ERROR_MARK) 8299 return error_mark_node; 8300 8301 switch (TREE_CODE (type)) 8302 { 8303 case ERROR_MARK: 8304 return error_mark_node; 8305 8306 /* APPLE LOCAL radar 5732232 - blocks */ 8307 case BLOCK_POINTER_TYPE: 8308 case POINTER_TYPE: 8309 case REFERENCE_TYPE: 8310 return type_main_variant (root_type (TREE_TYPE (type))); 8311 8312 default: 8313 return type_main_variant (type); 8314 } 8315} 8316 8317/* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the 8318 given input type is a Dwarf "fundamental" type. Otherwise return null. */ 8319 8320static inline int 8321is_base_type (tree type) 8322{ 8323 switch (TREE_CODE (type)) 8324 { 8325 case ERROR_MARK: 8326 case VOID_TYPE: 8327 case INTEGER_TYPE: 8328 case REAL_TYPE: 8329 case COMPLEX_TYPE: 8330 case BOOLEAN_TYPE: 8331 return 1; 8332 8333 case ARRAY_TYPE: 8334 case RECORD_TYPE: 8335 case UNION_TYPE: 8336 case QUAL_UNION_TYPE: 8337 case ENUMERAL_TYPE: 8338 case FUNCTION_TYPE: 8339 case METHOD_TYPE: 8340 /* APPLE LOCAL radar 5732232 - blocks */ 8341 case BLOCK_POINTER_TYPE: 8342 case POINTER_TYPE: 8343 case REFERENCE_TYPE: 8344 case OFFSET_TYPE: 8345 case LANG_TYPE: 8346 case VECTOR_TYPE: 8347 return 0; 8348 8349 default: 8350 gcc_unreachable (); 8351 } 8352 8353 return 0; 8354} 8355 8356/* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE 8357 node, return the size in bits for the type if it is a constant, or else 8358 return the alignment for the type if the type's size is not constant, or 8359 else return BITS_PER_WORD if the type actually turns out to be an 8360 ERROR_MARK node. */ 8361 8362static inline unsigned HOST_WIDE_INT 8363simple_type_size_in_bits (tree type) 8364{ 8365 if (TREE_CODE (type) == ERROR_MARK) 8366 return BITS_PER_WORD; 8367 else if (TYPE_SIZE (type) == NULL_TREE) 8368 return 0; 8369 else if (host_integerp (TYPE_SIZE (type), 1)) 8370 return tree_low_cst (TYPE_SIZE (type), 1); 8371 else 8372 return TYPE_ALIGN (type); 8373} 8374 8375/* Return true if the debug information for the given type should be 8376 emitted as a subrange type. */ 8377 8378static inline bool 8379is_subrange_type (tree type) 8380{ 8381 tree subtype = TREE_TYPE (type); 8382 8383 /* Subrange types are identified by the fact that they are integer 8384 types, and that they have a subtype which is either an integer type 8385 or an enumeral type. */ 8386 8387 if (TREE_CODE (type) != INTEGER_TYPE 8388 || subtype == NULL_TREE) 8389 return false; 8390 8391 if (TREE_CODE (subtype) != INTEGER_TYPE 8392 && TREE_CODE (subtype) != ENUMERAL_TYPE) 8393 return false; 8394 8395 if (TREE_CODE (type) == TREE_CODE (subtype) 8396 && int_size_in_bytes (type) == int_size_in_bytes (subtype) 8397 && TYPE_MIN_VALUE (type) != NULL 8398 && TYPE_MIN_VALUE (subtype) != NULL 8399 && tree_int_cst_equal (TYPE_MIN_VALUE (type), TYPE_MIN_VALUE (subtype)) 8400 && TYPE_MAX_VALUE (type) != NULL 8401 && TYPE_MAX_VALUE (subtype) != NULL 8402 && tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype))) 8403 { 8404 /* The type and its subtype have the same representation. If in 8405 addition the two types also have the same name, then the given 8406 type is not a subrange type, but rather a plain base type. */ 8407 /* FIXME: brobecker/2004-03-22: 8408 Sizetype INTEGER_CSTs nodes are canonicalized. It should 8409 therefore be sufficient to check the TYPE_SIZE node pointers 8410 rather than checking the actual size. Unfortunately, we have 8411 found some cases, such as in the Ada "integer" type, where 8412 this is not the case. Until this problem is solved, we need to 8413 keep checking the actual size. */ 8414 tree type_name = TYPE_NAME (type); 8415 tree subtype_name = TYPE_NAME (subtype); 8416 8417 if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL) 8418 type_name = DECL_NAME (type_name); 8419 8420 if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL) 8421 subtype_name = DECL_NAME (subtype_name); 8422 8423 if (type_name == subtype_name) 8424 return false; 8425 } 8426 8427 return true; 8428} 8429 8430/* Given a pointer to a tree node for a subrange type, return a pointer 8431 to a DIE that describes the given type. */ 8432 8433static dw_die_ref 8434subrange_type_die (tree type, dw_die_ref context_die) 8435{ 8436 dw_die_ref subrange_die; 8437 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type); 8438 8439 if (context_die == NULL) 8440 context_die = comp_unit_die; 8441 8442 subrange_die = new_die (DW_TAG_subrange_type, context_die, type); 8443 8444 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes) 8445 { 8446 /* The size of the subrange type and its base type do not match, 8447 so we need to generate a size attribute for the subrange type. */ 8448 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes); 8449 } 8450 8451 if (TYPE_MIN_VALUE (type) != NULL) 8452 add_bound_info (subrange_die, DW_AT_lower_bound, 8453 TYPE_MIN_VALUE (type)); 8454 if (TYPE_MAX_VALUE (type) != NULL) 8455 add_bound_info (subrange_die, DW_AT_upper_bound, 8456 TYPE_MAX_VALUE (type)); 8457 8458 return subrange_die; 8459} 8460 8461/* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging 8462 entry that chains various modifiers in front of the given type. */ 8463 8464static dw_die_ref 8465modified_type_die (tree type, int is_const_type, int is_volatile_type, 8466 dw_die_ref context_die) 8467{ 8468 enum tree_code code = TREE_CODE (type); 8469 dw_die_ref mod_type_die; 8470 dw_die_ref sub_die = NULL; 8471 tree item_type = NULL; 8472 tree qualified_type; 8473 tree name; 8474 8475 if (code == ERROR_MARK) 8476 return NULL; 8477 8478 /* See if we already have the appropriately qualified variant of 8479 this type. */ 8480 qualified_type 8481 = get_qualified_type (type, 8482 ((is_const_type ? TYPE_QUAL_CONST : 0) 8483 | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0))); 8484 8485 /* If we do, then we can just use its DIE, if it exists. */ 8486 if (qualified_type) 8487 { 8488 mod_type_die = lookup_type_die (qualified_type); 8489 if (mod_type_die) 8490 return mod_type_die; 8491 } 8492 8493 name = qualified_type ? TYPE_NAME (qualified_type) : NULL; 8494 8495 /* Handle C typedef types. */ 8496 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name)) 8497 { 8498 tree dtype = TREE_TYPE (name); 8499 8500 if (qualified_type == dtype) 8501 { 8502 /* For a named type, use the typedef. */ 8503 gen_type_die (qualified_type, context_die); 8504 return lookup_type_die (qualified_type); 8505 } 8506 else if (is_const_type < TYPE_READONLY (dtype) 8507 || is_volatile_type < TYPE_VOLATILE (dtype) 8508 || (is_const_type <= TYPE_READONLY (dtype) 8509 && is_volatile_type <= TYPE_VOLATILE (dtype) 8510 && DECL_ORIGINAL_TYPE (name) != type)) 8511 /* cv-unqualified version of named type. Just use the unnamed 8512 type to which it refers. */ 8513 return modified_type_die (DECL_ORIGINAL_TYPE (name), 8514 is_const_type, is_volatile_type, 8515 context_die); 8516 /* Else cv-qualified version of named type; fall through. */ 8517 } 8518 8519 if (is_const_type) 8520 { 8521 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type); 8522 sub_die = modified_type_die (type, 0, is_volatile_type, context_die); 8523 } 8524 else if (is_volatile_type) 8525 { 8526 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type); 8527 sub_die = modified_type_die (type, 0, 0, context_die); 8528 } 8529 /* APPLE LOCAL radar 5732232 - blocks */ 8530 else if (code == POINTER_TYPE || code == BLOCK_POINTER_TYPE) 8531 { 8532 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type); 8533 add_AT_unsigned (mod_type_die, DW_AT_byte_size, 8534 simple_type_size_in_bits (type) / BITS_PER_UNIT); 8535 item_type = TREE_TYPE (type); 8536 } 8537 else if (code == REFERENCE_TYPE) 8538 { 8539 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type); 8540 add_AT_unsigned (mod_type_die, DW_AT_byte_size, 8541 simple_type_size_in_bits (type) / BITS_PER_UNIT); 8542 item_type = TREE_TYPE (type); 8543 } 8544 else if (is_subrange_type (type)) 8545 { 8546 mod_type_die = subrange_type_die (type, context_die); 8547 item_type = TREE_TYPE (type); 8548 } 8549 else if (is_base_type (type)) 8550 mod_type_die = base_type_die (type); 8551 else 8552 { 8553 gen_type_die (type, context_die); 8554 8555 /* We have to get the type_main_variant here (and pass that to the 8556 `lookup_type_die' routine) because the ..._TYPE node we have 8557 might simply be a *copy* of some original type node (where the 8558 copy was created to help us keep track of typedef names) and 8559 that copy might have a different TYPE_UID from the original 8560 ..._TYPE node. */ 8561 if (TREE_CODE (type) != VECTOR_TYPE) 8562 return lookup_type_die (type_main_variant (type)); 8563 else 8564 /* Vectors have the debugging information in the type, 8565 not the main variant. */ 8566 return lookup_type_die (type); 8567 } 8568 8569 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those, 8570 don't output a DW_TAG_typedef, since there isn't one in the 8571 user's program; just attach a DW_AT_name to the type. */ 8572 if (name 8573 && (TREE_CODE (name) != TYPE_DECL || TREE_TYPE (name) == qualified_type)) 8574 { 8575 if (TREE_CODE (name) == TYPE_DECL) 8576 /* Could just call add_name_and_src_coords_attributes here, 8577 but since this is a builtin type it doesn't have any 8578 useful source coordinates anyway. */ 8579 name = DECL_NAME (name); 8580 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name)); 8581 } 8582 8583 if (qualified_type) 8584 equate_type_number_to_die (qualified_type, mod_type_die); 8585 8586 if (item_type) 8587 /* We must do this after the equate_type_number_to_die call, in case 8588 this is a recursive type. This ensures that the modified_type_die 8589 recursion will terminate even if the type is recursive. Recursive 8590 types are possible in Ada. */ 8591 sub_die = modified_type_die (item_type, 8592 TYPE_READONLY (item_type), 8593 TYPE_VOLATILE (item_type), 8594 context_die); 8595 8596 if (sub_die != NULL) 8597 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die); 8598 8599 return mod_type_die; 8600} 8601 8602/* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is 8603 an enumerated type. */ 8604 8605static inline int 8606type_is_enum (tree type) 8607{ 8608 return TREE_CODE (type) == ENUMERAL_TYPE; 8609} 8610 8611/* Return the DBX register number described by a given RTL node. */ 8612 8613static unsigned int 8614dbx_reg_number (rtx rtl) 8615{ 8616 unsigned regno = REGNO (rtl); 8617 8618 gcc_assert (regno < FIRST_PSEUDO_REGISTER); 8619 8620#ifdef LEAF_REG_REMAP 8621 if (current_function_uses_only_leaf_regs) 8622 { 8623 int leaf_reg = LEAF_REG_REMAP (regno); 8624 if (leaf_reg != -1) 8625 regno = (unsigned) leaf_reg; 8626 } 8627#endif 8628 8629 return DBX_REGISTER_NUMBER (regno); 8630} 8631 8632/* Optionally add a DW_OP_piece term to a location description expression. 8633 DW_OP_piece is only added if the location description expression already 8634 doesn't end with DW_OP_piece. */ 8635 8636static void 8637add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size) 8638{ 8639 dw_loc_descr_ref loc; 8640 8641 if (*list_head != NULL) 8642 { 8643 /* Find the end of the chain. */ 8644 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next) 8645 ; 8646 8647 if (loc->dw_loc_opc != DW_OP_piece) 8648 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0); 8649 } 8650} 8651 8652/* Return a location descriptor that designates a machine register or 8653 zero if there is none. */ 8654 8655static dw_loc_descr_ref 8656reg_loc_descriptor (rtx rtl) 8657{ 8658 rtx regs; 8659 8660 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER) 8661 return 0; 8662 8663 regs = targetm.dwarf_register_span (rtl); 8664 8665 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs) 8666 return multiple_reg_loc_descriptor (rtl, regs); 8667 else 8668 return one_reg_loc_descriptor (dbx_reg_number (rtl)); 8669} 8670 8671/* Return a location descriptor that designates a machine register for 8672 a given hard register number. */ 8673 8674static dw_loc_descr_ref 8675one_reg_loc_descriptor (unsigned int regno) 8676{ 8677 if (regno <= 31) 8678 return new_loc_descr (DW_OP_reg0 + regno, 0, 0); 8679 else 8680 return new_loc_descr (DW_OP_regx, regno, 0); 8681} 8682 8683/* Given an RTL of a register, return a location descriptor that 8684 designates a value that spans more than one register. */ 8685 8686static dw_loc_descr_ref 8687multiple_reg_loc_descriptor (rtx rtl, rtx regs) 8688{ 8689 int nregs, size, i; 8690 unsigned reg; 8691 dw_loc_descr_ref loc_result = NULL; 8692 8693 reg = REGNO (rtl); 8694#ifdef LEAF_REG_REMAP 8695 if (current_function_uses_only_leaf_regs) 8696 { 8697 int leaf_reg = LEAF_REG_REMAP (reg); 8698 if (leaf_reg != -1) 8699 reg = (unsigned) leaf_reg; 8700 } 8701#endif 8702 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl)); 8703 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)]; 8704 8705 /* Simple, contiguous registers. */ 8706 if (regs == NULL_RTX) 8707 { 8708 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs; 8709 8710 loc_result = NULL; 8711 while (nregs--) 8712 { 8713 dw_loc_descr_ref t; 8714 8715 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg)); 8716 add_loc_descr (&loc_result, t); 8717 add_loc_descr_op_piece (&loc_result, size); 8718 ++reg; 8719 } 8720 return loc_result; 8721 } 8722 8723 /* Now onto stupid register sets in non contiguous locations. */ 8724 8725 gcc_assert (GET_CODE (regs) == PARALLEL); 8726 8727 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0))); 8728 loc_result = NULL; 8729 8730 for (i = 0; i < XVECLEN (regs, 0); ++i) 8731 { 8732 dw_loc_descr_ref t; 8733 8734 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i))); 8735 add_loc_descr (&loc_result, t); 8736 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0))); 8737 add_loc_descr_op_piece (&loc_result, size); 8738 } 8739 return loc_result; 8740} 8741 8742/* Return a location descriptor that designates a constant. */ 8743 8744static dw_loc_descr_ref 8745int_loc_descriptor (HOST_WIDE_INT i) 8746{ 8747 enum dwarf_location_atom op; 8748 8749 /* Pick the smallest representation of a constant, rather than just 8750 defaulting to the LEB encoding. */ 8751 if (i >= 0) 8752 { 8753 if (i <= 31) 8754 op = DW_OP_lit0 + i; 8755 else if (i <= 0xff) 8756 op = DW_OP_const1u; 8757 else if (i <= 0xffff) 8758 op = DW_OP_const2u; 8759 else if (HOST_BITS_PER_WIDE_INT == 32 8760 || i <= 0xffffffff) 8761 op = DW_OP_const4u; 8762 else 8763 op = DW_OP_constu; 8764 } 8765 else 8766 { 8767 if (i >= -0x80) 8768 op = DW_OP_const1s; 8769 else if (i >= -0x8000) 8770 op = DW_OP_const2s; 8771 else if (HOST_BITS_PER_WIDE_INT == 32 8772 || i >= -0x80000000) 8773 op = DW_OP_const4s; 8774 else 8775 op = DW_OP_consts; 8776 } 8777 8778 return new_loc_descr (op, i, 0); 8779} 8780 8781/* Return a location descriptor that designates a base+offset location. */ 8782 8783static dw_loc_descr_ref 8784based_loc_descr (rtx reg, HOST_WIDE_INT offset) 8785{ 8786 unsigned int regno; 8787 8788 /* We only use "frame base" when we're sure we're talking about the 8789 post-prologue local stack frame. We do this by *not* running 8790 register elimination until this point, and recognizing the special 8791 argument pointer and soft frame pointer rtx's. */ 8792 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx) 8793 { 8794 rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX); 8795 8796 if (elim != reg) 8797 { 8798 if (GET_CODE (elim) == PLUS) 8799 { 8800 offset += INTVAL (XEXP (elim, 1)); 8801 elim = XEXP (elim, 0); 8802 } 8803 gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx 8804 : stack_pointer_rtx)); 8805 offset += frame_pointer_fb_offset; 8806 8807 return new_loc_descr (DW_OP_fbreg, offset, 0); 8808 } 8809 } 8810 8811 regno = dbx_reg_number (reg); 8812 if (regno <= 31) 8813 return new_loc_descr (DW_OP_breg0 + regno, offset, 0); 8814 else 8815 return new_loc_descr (DW_OP_bregx, regno, offset); 8816} 8817 8818/* Return true if this RTL expression describes a base+offset calculation. */ 8819 8820static inline int 8821is_based_loc (rtx rtl) 8822{ 8823 return (GET_CODE (rtl) == PLUS 8824 && ((REG_P (XEXP (rtl, 0)) 8825 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER 8826 && GET_CODE (XEXP (rtl, 1)) == CONST_INT))); 8827} 8828 8829/* The following routine converts the RTL for a variable or parameter 8830 (resident in memory) into an equivalent Dwarf representation of a 8831 mechanism for getting the address of that same variable onto the top of a 8832 hypothetical "address evaluation" stack. 8833 8834 When creating memory location descriptors, we are effectively transforming 8835 the RTL for a memory-resident object into its Dwarf postfix expression 8836 equivalent. This routine recursively descends an RTL tree, turning 8837 it into Dwarf postfix code as it goes. 8838 8839 MODE is the mode of the memory reference, needed to handle some 8840 autoincrement addressing modes. 8841 8842 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the 8843 location list for RTL. 8844 8845 Return 0 if we can't represent the location. */ 8846 8847static dw_loc_descr_ref 8848mem_loc_descriptor (rtx rtl, enum machine_mode mode) 8849{ 8850 dw_loc_descr_ref mem_loc_result = NULL; 8851 enum dwarf_location_atom op; 8852 8853 /* Note that for a dynamically sized array, the location we will generate a 8854 description of here will be the lowest numbered location which is 8855 actually within the array. That's *not* necessarily the same as the 8856 zeroth element of the array. */ 8857 8858 rtl = targetm.delegitimize_address (rtl); 8859 8860 switch (GET_CODE (rtl)) 8861 { 8862 case POST_INC: 8863 case POST_DEC: 8864 case POST_MODIFY: 8865 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we 8866 just fall into the SUBREG code. */ 8867 8868 /* ... fall through ... */ 8869 8870 case SUBREG: 8871 /* The case of a subreg may arise when we have a local (register) 8872 variable or a formal (register) parameter which doesn't quite fill 8873 up an entire register. For now, just assume that it is 8874 legitimate to make the Dwarf info refer to the whole register which 8875 contains the given subreg. */ 8876 rtl = XEXP (rtl, 0); 8877 8878 /* ... fall through ... */ 8879 8880 case REG: 8881 /* Whenever a register number forms a part of the description of the 8882 method for calculating the (dynamic) address of a memory resident 8883 object, DWARF rules require the register number be referred to as 8884 a "base register". This distinction is not based in any way upon 8885 what category of register the hardware believes the given register 8886 belongs to. This is strictly DWARF terminology we're dealing with 8887 here. Note that in cases where the location of a memory-resident 8888 data object could be expressed as: OP_ADD (OP_BASEREG (basereg), 8889 OP_CONST (0)) the actual DWARF location descriptor that we generate 8890 may just be OP_BASEREG (basereg). This may look deceptively like 8891 the object in question was allocated to a register (rather than in 8892 memory) so DWARF consumers need to be aware of the subtle 8893 distinction between OP_REG and OP_BASEREG. */ 8894 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER) 8895 mem_loc_result = based_loc_descr (rtl, 0); 8896 break; 8897 8898 case MEM: 8899 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl)); 8900 if (mem_loc_result != 0) 8901 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0)); 8902 break; 8903 8904 case LO_SUM: 8905 rtl = XEXP (rtl, 1); 8906 8907 /* ... fall through ... */ 8908 8909 case LABEL_REF: 8910 /* Some ports can transform a symbol ref into a label ref, because 8911 the symbol ref is too far away and has to be dumped into a constant 8912 pool. */ 8913 case CONST: 8914 case SYMBOL_REF: 8915 /* Alternatively, the symbol in the constant pool might be referenced 8916 by a different symbol. */ 8917 if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl)) 8918 { 8919 bool marked; 8920 rtx tmp = get_pool_constant_mark (rtl, &marked); 8921 8922 if (GET_CODE (tmp) == SYMBOL_REF) 8923 { 8924 rtl = tmp; 8925 if (CONSTANT_POOL_ADDRESS_P (tmp)) 8926 get_pool_constant_mark (tmp, &marked); 8927 else 8928 marked = true; 8929 } 8930 8931 /* If all references to this pool constant were optimized away, 8932 it was not output and thus we can't represent it. 8933 FIXME: might try to use DW_OP_const_value here, though 8934 DW_OP_piece complicates it. */ 8935 if (!marked) 8936 return 0; 8937 } 8938 8939 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0); 8940 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr; 8941 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl; 8942 VEC_safe_push (rtx, gc, used_rtx_array, rtl); 8943 break; 8944 8945 case PRE_MODIFY: 8946 /* Extract the PLUS expression nested inside and fall into 8947 PLUS code below. */ 8948 rtl = XEXP (rtl, 1); 8949 goto plus; 8950 8951 case PRE_INC: 8952 case PRE_DEC: 8953 /* Turn these into a PLUS expression and fall into the PLUS code 8954 below. */ 8955 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0), 8956 GEN_INT (GET_CODE (rtl) == PRE_INC 8957 ? GET_MODE_UNIT_SIZE (mode) 8958 : -GET_MODE_UNIT_SIZE (mode))); 8959 8960 /* ... fall through ... */ 8961 8962 case PLUS: 8963 plus: 8964 if (is_based_loc (rtl)) 8965 mem_loc_result = based_loc_descr (XEXP (rtl, 0), 8966 INTVAL (XEXP (rtl, 1))); 8967 else 8968 { 8969 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode); 8970 if (mem_loc_result == 0) 8971 break; 8972 8973 if (GET_CODE (XEXP (rtl, 1)) == CONST_INT 8974 && INTVAL (XEXP (rtl, 1)) >= 0) 8975 add_loc_descr (&mem_loc_result, 8976 new_loc_descr (DW_OP_plus_uconst, 8977 INTVAL (XEXP (rtl, 1)), 0)); 8978 else 8979 { 8980 add_loc_descr (&mem_loc_result, 8981 mem_loc_descriptor (XEXP (rtl, 1), mode)); 8982 add_loc_descr (&mem_loc_result, 8983 new_loc_descr (DW_OP_plus, 0, 0)); 8984 } 8985 } 8986 break; 8987 8988 /* If a pseudo-reg is optimized away, it is possible for it to 8989 be replaced with a MEM containing a multiply or shift. */ 8990 case MULT: 8991 op = DW_OP_mul; 8992 goto do_binop; 8993 8994 case ASHIFT: 8995 op = DW_OP_shl; 8996 goto do_binop; 8997 8998 case ASHIFTRT: 8999 op = DW_OP_shra; 9000 goto do_binop; 9001 9002 case LSHIFTRT: 9003 op = DW_OP_shr; 9004 goto do_binop; 9005 9006 do_binop: 9007 { 9008 dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode); 9009 dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode); 9010 9011 if (op0 == 0 || op1 == 0) 9012 break; 9013 9014 mem_loc_result = op0; 9015 add_loc_descr (&mem_loc_result, op1); 9016 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0)); 9017 break; 9018 } 9019 9020 case CONST_INT: 9021 mem_loc_result = int_loc_descriptor (INTVAL (rtl)); 9022 break; 9023 9024 default: 9025 gcc_unreachable (); 9026 } 9027 9028 return mem_loc_result; 9029} 9030 9031/* Return a descriptor that describes the concatenation of two locations. 9032 This is typically a complex variable. */ 9033 9034static dw_loc_descr_ref 9035concat_loc_descriptor (rtx x0, rtx x1) 9036{ 9037 dw_loc_descr_ref cc_loc_result = NULL; 9038 dw_loc_descr_ref x0_ref = loc_descriptor (x0); 9039 dw_loc_descr_ref x1_ref = loc_descriptor (x1); 9040 9041 if (x0_ref == 0 || x1_ref == 0) 9042 return 0; 9043 9044 cc_loc_result = x0_ref; 9045 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0))); 9046 9047 add_loc_descr (&cc_loc_result, x1_ref); 9048 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1))); 9049 9050 return cc_loc_result; 9051} 9052 9053/* Output a proper Dwarf location descriptor for a variable or parameter 9054 which is either allocated in a register or in a memory location. For a 9055 register, we just generate an OP_REG and the register number. For a 9056 memory location we provide a Dwarf postfix expression describing how to 9057 generate the (dynamic) address of the object onto the address stack. 9058 9059 If we don't know how to describe it, return 0. */ 9060 9061static dw_loc_descr_ref 9062loc_descriptor (rtx rtl) 9063{ 9064 dw_loc_descr_ref loc_result = NULL; 9065 9066 switch (GET_CODE (rtl)) 9067 { 9068 case SUBREG: 9069 /* The case of a subreg may arise when we have a local (register) 9070 variable or a formal (register) parameter which doesn't quite fill 9071 up an entire register. For now, just assume that it is 9072 legitimate to make the Dwarf info refer to the whole register which 9073 contains the given subreg. */ 9074 rtl = SUBREG_REG (rtl); 9075 9076 /* ... fall through ... */ 9077 9078 case REG: 9079 loc_result = reg_loc_descriptor (rtl); 9080 break; 9081 9082 case MEM: 9083 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl)); 9084 break; 9085 9086 case CONCAT: 9087 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1)); 9088 break; 9089 9090 case VAR_LOCATION: 9091 /* Single part. */ 9092 if (GET_CODE (XEXP (rtl, 1)) != PARALLEL) 9093 { 9094 loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0)); 9095 break; 9096 } 9097 9098 rtl = XEXP (rtl, 1); 9099 /* FALLTHRU */ 9100 9101 case PARALLEL: 9102 { 9103 rtvec par_elems = XVEC (rtl, 0); 9104 int num_elem = GET_NUM_ELEM (par_elems); 9105 enum machine_mode mode; 9106 int i; 9107 9108 /* Create the first one, so we have something to add to. */ 9109 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0)); 9110 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0)); 9111 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode)); 9112 for (i = 1; i < num_elem; i++) 9113 { 9114 dw_loc_descr_ref temp; 9115 9116 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0)); 9117 add_loc_descr (&loc_result, temp); 9118 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0)); 9119 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode)); 9120 } 9121 } 9122 break; 9123 9124 default: 9125 gcc_unreachable (); 9126 } 9127 9128 return loc_result; 9129} 9130 9131/* Similar, but generate the descriptor from trees instead of rtl. This comes 9132 up particularly with variable length arrays. WANT_ADDRESS is 2 if this is 9133 a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a 9134 top-level invocation, and we require the address of LOC; is 0 if we require 9135 the value of LOC. */ 9136 9137static dw_loc_descr_ref 9138loc_descriptor_from_tree_1 (tree loc, int want_address) 9139{ 9140 dw_loc_descr_ref ret, ret1; 9141 int have_address = 0; 9142 enum dwarf_location_atom op; 9143 9144 /* ??? Most of the time we do not take proper care for sign/zero 9145 extending the values properly. Hopefully this won't be a real 9146 problem... */ 9147 9148 switch (TREE_CODE (loc)) 9149 { 9150 case ERROR_MARK: 9151 return 0; 9152 9153 case PLACEHOLDER_EXPR: 9154 /* This case involves extracting fields from an object to determine the 9155 position of other fields. We don't try to encode this here. The 9156 only user of this is Ada, which encodes the needed information using 9157 the names of types. */ 9158 return 0; 9159 9160 case CALL_EXPR: 9161 return 0; 9162 9163 case PREINCREMENT_EXPR: 9164 case PREDECREMENT_EXPR: 9165 case POSTINCREMENT_EXPR: 9166 case POSTDECREMENT_EXPR: 9167 /* There are no opcodes for these operations. */ 9168 return 0; 9169 9170 case ADDR_EXPR: 9171 /* If we already want an address, there's nothing we can do. */ 9172 if (want_address) 9173 return 0; 9174 9175 /* Otherwise, process the argument and look for the address. */ 9176 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1); 9177 9178 case VAR_DECL: 9179 if (DECL_THREAD_LOCAL_P (loc)) 9180 { 9181 rtx rtl; 9182 9183 /* If this is not defined, we have no way to emit the data. */ 9184 if (!targetm.asm_out.output_dwarf_dtprel) 9185 return 0; 9186 9187 /* The way DW_OP_GNU_push_tls_address is specified, we can only 9188 look up addresses of objects in the current module. */ 9189 if (DECL_EXTERNAL (loc)) 9190 return 0; 9191 9192 rtl = rtl_for_decl_location (loc); 9193 if (rtl == NULL_RTX) 9194 return 0; 9195 9196 if (!MEM_P (rtl)) 9197 return 0; 9198 rtl = XEXP (rtl, 0); 9199 if (! CONSTANT_P (rtl)) 9200 return 0; 9201 9202 ret = new_loc_descr (INTERNAL_DW_OP_tls_addr, 0, 0); 9203 ret->dw_loc_oprnd1.val_class = dw_val_class_addr; 9204 ret->dw_loc_oprnd1.v.val_addr = rtl; 9205 9206 ret1 = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0); 9207 add_loc_descr (&ret, ret1); 9208 9209 have_address = 1; 9210 break; 9211 } 9212 /* FALLTHRU */ 9213 9214 case PARM_DECL: 9215 if (DECL_HAS_VALUE_EXPR_P (loc)) 9216 return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc), 9217 want_address); 9218 /* FALLTHRU */ 9219 9220 case RESULT_DECL: 9221 case FUNCTION_DECL: 9222 { 9223 rtx rtl = rtl_for_decl_location (loc); 9224 9225 if (rtl == NULL_RTX) 9226 return 0; 9227 else if (GET_CODE (rtl) == CONST_INT) 9228 { 9229 HOST_WIDE_INT val = INTVAL (rtl); 9230 if (TYPE_UNSIGNED (TREE_TYPE (loc))) 9231 val &= GET_MODE_MASK (DECL_MODE (loc)); 9232 ret = int_loc_descriptor (val); 9233 } 9234 else if (GET_CODE (rtl) == CONST_STRING) 9235 return 0; 9236 else if (CONSTANT_P (rtl)) 9237 { 9238 ret = new_loc_descr (DW_OP_addr, 0, 0); 9239 ret->dw_loc_oprnd1.val_class = dw_val_class_addr; 9240 ret->dw_loc_oprnd1.v.val_addr = rtl; 9241 } 9242 else 9243 { 9244 enum machine_mode mode; 9245 9246 /* Certain constructs can only be represented at top-level. */ 9247 if (want_address == 2) 9248 return loc_descriptor (rtl); 9249 9250 mode = GET_MODE (rtl); 9251 if (MEM_P (rtl)) 9252 { 9253 rtl = XEXP (rtl, 0); 9254 have_address = 1; 9255 } 9256 ret = mem_loc_descriptor (rtl, mode); 9257 } 9258 } 9259 break; 9260 9261 case INDIRECT_REF: 9262 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0); 9263 have_address = 1; 9264 break; 9265 9266 case COMPOUND_EXPR: 9267 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address); 9268 9269 case NOP_EXPR: 9270 case CONVERT_EXPR: 9271 case NON_LVALUE_EXPR: 9272 case VIEW_CONVERT_EXPR: 9273 case SAVE_EXPR: 9274 case MODIFY_EXPR: 9275 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), want_address); 9276 9277 case COMPONENT_REF: 9278 case BIT_FIELD_REF: 9279 case ARRAY_REF: 9280 case ARRAY_RANGE_REF: 9281 { 9282 tree obj, offset; 9283 HOST_WIDE_INT bitsize, bitpos, bytepos; 9284 enum machine_mode mode; 9285 int volatilep; 9286 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc)); 9287 9288 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode, 9289 &unsignedp, &volatilep, false); 9290 9291 if (obj == loc) 9292 return 0; 9293 9294 ret = loc_descriptor_from_tree_1 (obj, 1); 9295 if (ret == 0 9296 || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0) 9297 return 0; 9298 9299 if (offset != NULL_TREE) 9300 { 9301 /* Variable offset. */ 9302 add_loc_descr (&ret, loc_descriptor_from_tree_1 (offset, 0)); 9303 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0)); 9304 } 9305 9306 bytepos = bitpos / BITS_PER_UNIT; 9307 if (bytepos > 0) 9308 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0)); 9309 else if (bytepos < 0) 9310 { 9311 add_loc_descr (&ret, int_loc_descriptor (bytepos)); 9312 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0)); 9313 } 9314 9315 have_address = 1; 9316 break; 9317 } 9318 9319 case INTEGER_CST: 9320 if (host_integerp (loc, 0)) 9321 ret = int_loc_descriptor (tree_low_cst (loc, 0)); 9322 else 9323 return 0; 9324 break; 9325 9326 case CONSTRUCTOR: 9327 { 9328 /* Get an RTL for this, if something has been emitted. */ 9329 rtx rtl = lookup_constant_def (loc); 9330 enum machine_mode mode; 9331 9332 if (!rtl || !MEM_P (rtl)) 9333 return 0; 9334 mode = GET_MODE (rtl); 9335 rtl = XEXP (rtl, 0); 9336 ret = mem_loc_descriptor (rtl, mode); 9337 have_address = 1; 9338 break; 9339 } 9340 9341 case TRUTH_AND_EXPR: 9342 case TRUTH_ANDIF_EXPR: 9343 case BIT_AND_EXPR: 9344 op = DW_OP_and; 9345 goto do_binop; 9346 9347 case TRUTH_XOR_EXPR: 9348 case BIT_XOR_EXPR: 9349 op = DW_OP_xor; 9350 goto do_binop; 9351 9352 case TRUTH_OR_EXPR: 9353 case TRUTH_ORIF_EXPR: 9354 case BIT_IOR_EXPR: 9355 op = DW_OP_or; 9356 goto do_binop; 9357 9358 case FLOOR_DIV_EXPR: 9359 case CEIL_DIV_EXPR: 9360 case ROUND_DIV_EXPR: 9361 case TRUNC_DIV_EXPR: 9362 op = DW_OP_div; 9363 goto do_binop; 9364 9365 case MINUS_EXPR: 9366 op = DW_OP_minus; 9367 goto do_binop; 9368 9369 case FLOOR_MOD_EXPR: 9370 case CEIL_MOD_EXPR: 9371 case ROUND_MOD_EXPR: 9372 case TRUNC_MOD_EXPR: 9373 op = DW_OP_mod; 9374 goto do_binop; 9375 9376 case MULT_EXPR: 9377 op = DW_OP_mul; 9378 goto do_binop; 9379 9380 case LSHIFT_EXPR: 9381 op = DW_OP_shl; 9382 goto do_binop; 9383 9384 case RSHIFT_EXPR: 9385 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra); 9386 goto do_binop; 9387 9388 case PLUS_EXPR: 9389 if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST 9390 && host_integerp (TREE_OPERAND (loc, 1), 0)) 9391 { 9392 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0); 9393 if (ret == 0) 9394 return 0; 9395 9396 add_loc_descr (&ret, 9397 new_loc_descr (DW_OP_plus_uconst, 9398 tree_low_cst (TREE_OPERAND (loc, 1), 9399 0), 9400 0)); 9401 break; 9402 } 9403 9404 op = DW_OP_plus; 9405 goto do_binop; 9406 9407 case LE_EXPR: 9408 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 9409 return 0; 9410 9411 op = DW_OP_le; 9412 goto do_binop; 9413 9414 case GE_EXPR: 9415 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 9416 return 0; 9417 9418 op = DW_OP_ge; 9419 goto do_binop; 9420 9421 case LT_EXPR: 9422 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 9423 return 0; 9424 9425 op = DW_OP_lt; 9426 goto do_binop; 9427 9428 case GT_EXPR: 9429 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 9430 return 0; 9431 9432 op = DW_OP_gt; 9433 goto do_binop; 9434 9435 case EQ_EXPR: 9436 op = DW_OP_eq; 9437 goto do_binop; 9438 9439 case NE_EXPR: 9440 op = DW_OP_ne; 9441 goto do_binop; 9442 9443 do_binop: 9444 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0); 9445 ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0); 9446 if (ret == 0 || ret1 == 0) 9447 return 0; 9448 9449 add_loc_descr (&ret, ret1); 9450 add_loc_descr (&ret, new_loc_descr (op, 0, 0)); 9451 break; 9452 9453 case TRUTH_NOT_EXPR: 9454 case BIT_NOT_EXPR: 9455 op = DW_OP_not; 9456 goto do_unop; 9457 9458 case ABS_EXPR: 9459 op = DW_OP_abs; 9460 goto do_unop; 9461 9462 case NEGATE_EXPR: 9463 op = DW_OP_neg; 9464 goto do_unop; 9465 9466 do_unop: 9467 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0); 9468 if (ret == 0) 9469 return 0; 9470 9471 add_loc_descr (&ret, new_loc_descr (op, 0, 0)); 9472 break; 9473 9474 case MIN_EXPR: 9475 case MAX_EXPR: 9476 { 9477 const enum tree_code code = 9478 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR; 9479 9480 loc = build3 (COND_EXPR, TREE_TYPE (loc), 9481 build2 (code, integer_type_node, 9482 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)), 9483 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0)); 9484 } 9485 9486 /* ... fall through ... */ 9487 9488 case COND_EXPR: 9489 { 9490 dw_loc_descr_ref lhs 9491 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0); 9492 dw_loc_descr_ref rhs 9493 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0); 9494 dw_loc_descr_ref bra_node, jump_node, tmp; 9495 9496 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0); 9497 if (ret == 0 || lhs == 0 || rhs == 0) 9498 return 0; 9499 9500 bra_node = new_loc_descr (DW_OP_bra, 0, 0); 9501 add_loc_descr (&ret, bra_node); 9502 9503 add_loc_descr (&ret, rhs); 9504 jump_node = new_loc_descr (DW_OP_skip, 0, 0); 9505 add_loc_descr (&ret, jump_node); 9506 9507 add_loc_descr (&ret, lhs); 9508 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc; 9509 bra_node->dw_loc_oprnd1.v.val_loc = lhs; 9510 9511 /* ??? Need a node to point the skip at. Use a nop. */ 9512 tmp = new_loc_descr (DW_OP_nop, 0, 0); 9513 add_loc_descr (&ret, tmp); 9514 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc; 9515 jump_node->dw_loc_oprnd1.v.val_loc = tmp; 9516 } 9517 break; 9518 9519 case FIX_TRUNC_EXPR: 9520 case FIX_CEIL_EXPR: 9521 case FIX_FLOOR_EXPR: 9522 case FIX_ROUND_EXPR: 9523 return 0; 9524 9525 default: 9526 /* Leave front-end specific codes as simply unknown. This comes 9527 up, for instance, with the C STMT_EXPR. */ 9528 if ((unsigned int) TREE_CODE (loc) 9529 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE) 9530 return 0; 9531 9532#ifdef ENABLE_CHECKING 9533 /* Otherwise this is a generic code; we should just lists all of 9534 these explicitly. We forgot one. */ 9535 gcc_unreachable (); 9536#else 9537 /* In a release build, we want to degrade gracefully: better to 9538 generate incomplete debugging information than to crash. */ 9539 return NULL; 9540#endif 9541 } 9542 9543 /* Show if we can't fill the request for an address. */ 9544 if (want_address && !have_address) 9545 return 0; 9546 9547 /* If we've got an address and don't want one, dereference. */ 9548 if (!want_address && have_address && ret) 9549 { 9550 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc)); 9551 9552 if (size > DWARF2_ADDR_SIZE || size == -1) 9553 return 0; 9554 else if (size == DWARF2_ADDR_SIZE) 9555 op = DW_OP_deref; 9556 else 9557 op = DW_OP_deref_size; 9558 9559 add_loc_descr (&ret, new_loc_descr (op, size, 0)); 9560 } 9561 9562 return ret; 9563} 9564 9565static inline dw_loc_descr_ref 9566loc_descriptor_from_tree (tree loc) 9567{ 9568 return loc_descriptor_from_tree_1 (loc, 2); 9569} 9570 9571/* Given a value, round it up to the lowest multiple of `boundary' 9572 which is not less than the value itself. */ 9573 9574static inline HOST_WIDE_INT 9575ceiling (HOST_WIDE_INT value, unsigned int boundary) 9576{ 9577 return (((value + boundary - 1) / boundary) * boundary); 9578} 9579 9580/* Given a pointer to what is assumed to be a FIELD_DECL node, return a 9581 pointer to the declared type for the relevant field variable, or return 9582 `integer_type_node' if the given node turns out to be an 9583 ERROR_MARK node. */ 9584 9585static inline tree 9586field_type (tree decl) 9587{ 9588 tree type; 9589 9590 if (TREE_CODE (decl) == ERROR_MARK) 9591 return integer_type_node; 9592 9593 type = DECL_BIT_FIELD_TYPE (decl); 9594 if (type == NULL_TREE) 9595 type = TREE_TYPE (decl); 9596 9597 return type; 9598} 9599 9600/* Given a pointer to a tree node, return the alignment in bits for 9601 it, or else return BITS_PER_WORD if the node actually turns out to 9602 be an ERROR_MARK node. */ 9603 9604static inline unsigned 9605simple_type_align_in_bits (tree type) 9606{ 9607 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD; 9608} 9609 9610static inline unsigned 9611simple_decl_align_in_bits (tree decl) 9612{ 9613 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD; 9614} 9615 9616/* Given a pointer to a FIELD_DECL, compute and return the byte offset of the 9617 lowest addressed byte of the "containing object" for the given FIELD_DECL, 9618 or return 0 if we are unable to determine what that offset is, either 9619 because the argument turns out to be a pointer to an ERROR_MARK node, or 9620 because the offset is actually variable. (We can't handle the latter case 9621 just yet). */ 9622 9623static HOST_WIDE_INT 9624field_byte_offset (tree decl) 9625{ 9626 unsigned int type_align_in_bits; 9627 unsigned int decl_align_in_bits; 9628 unsigned HOST_WIDE_INT type_size_in_bits; 9629 HOST_WIDE_INT object_offset_in_bits; 9630 tree type; 9631 tree field_size_tree; 9632 HOST_WIDE_INT bitpos_int; 9633 HOST_WIDE_INT deepest_bitpos; 9634 unsigned HOST_WIDE_INT field_size_in_bits; 9635 9636 if (TREE_CODE (decl) == ERROR_MARK) 9637 return 0; 9638 9639 gcc_assert (TREE_CODE (decl) == FIELD_DECL); 9640 9641 type = field_type (decl); 9642 field_size_tree = DECL_SIZE (decl); 9643 9644 /* The size could be unspecified if there was an error, or for 9645 a flexible array member. */ 9646 if (! field_size_tree) 9647 field_size_tree = bitsize_zero_node; 9648 9649 /* We cannot yet cope with fields whose positions are variable, so 9650 for now, when we see such things, we simply return 0. Someday, we may 9651 be able to handle such cases, but it will be damn difficult. */ 9652 if (! host_integerp (bit_position (decl), 0)) 9653 return 0; 9654 9655 bitpos_int = int_bit_position (decl); 9656 9657 /* If we don't know the size of the field, pretend it's a full word. */ 9658 if (host_integerp (field_size_tree, 1)) 9659 field_size_in_bits = tree_low_cst (field_size_tree, 1); 9660 else 9661 field_size_in_bits = BITS_PER_WORD; 9662 9663 type_size_in_bits = simple_type_size_in_bits (type); 9664 type_align_in_bits = simple_type_align_in_bits (type); 9665 decl_align_in_bits = simple_decl_align_in_bits (decl); 9666 9667 /* The GCC front-end doesn't make any attempt to keep track of the starting 9668 bit offset (relative to the start of the containing structure type) of the 9669 hypothetical "containing object" for a bit-field. Thus, when computing 9670 the byte offset value for the start of the "containing object" of a 9671 bit-field, we must deduce this information on our own. This can be rather 9672 tricky to do in some cases. For example, handling the following structure 9673 type definition when compiling for an i386/i486 target (which only aligns 9674 long long's to 32-bit boundaries) can be very tricky: 9675 9676 struct S { int field1; long long field2:31; }; 9677 9678 Fortunately, there is a simple rule-of-thumb which can be used in such 9679 cases. When compiling for an i386/i486, GCC will allocate 8 bytes for the 9680 structure shown above. It decides to do this based upon one simple rule 9681 for bit-field allocation. GCC allocates each "containing object" for each 9682 bit-field at the first (i.e. lowest addressed) legitimate alignment 9683 boundary (based upon the required minimum alignment for the declared type 9684 of the field) which it can possibly use, subject to the condition that 9685 there is still enough available space remaining in the containing object 9686 (when allocated at the selected point) to fully accommodate all of the 9687 bits of the bit-field itself. 9688 9689 This simple rule makes it obvious why GCC allocates 8 bytes for each 9690 object of the structure type shown above. When looking for a place to 9691 allocate the "containing object" for `field2', the compiler simply tries 9692 to allocate a 64-bit "containing object" at each successive 32-bit 9693 boundary (starting at zero) until it finds a place to allocate that 64- 9694 bit field such that at least 31 contiguous (and previously unallocated) 9695 bits remain within that selected 64 bit field. (As it turns out, for the 9696 example above, the compiler finds it is OK to allocate the "containing 9697 object" 64-bit field at bit-offset zero within the structure type.) 9698 9699 Here we attempt to work backwards from the limited set of facts we're 9700 given, and we try to deduce from those facts, where GCC must have believed 9701 that the containing object started (within the structure type). The value 9702 we deduce is then used (by the callers of this routine) to generate 9703 DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields 9704 and, in the case of DW_AT_location, regular fields as well). */ 9705 9706 /* Figure out the bit-distance from the start of the structure to the 9707 "deepest" bit of the bit-field. */ 9708 deepest_bitpos = bitpos_int + field_size_in_bits; 9709 9710 /* This is the tricky part. Use some fancy footwork to deduce where the 9711 lowest addressed bit of the containing object must be. */ 9712 object_offset_in_bits = deepest_bitpos - type_size_in_bits; 9713 9714 /* Round up to type_align by default. This works best for bitfields. */ 9715 object_offset_in_bits += type_align_in_bits - 1; 9716 object_offset_in_bits /= type_align_in_bits; 9717 object_offset_in_bits *= type_align_in_bits; 9718 9719 if (object_offset_in_bits > bitpos_int) 9720 { 9721 /* Sigh, the decl must be packed. */ 9722 object_offset_in_bits = deepest_bitpos - type_size_in_bits; 9723 9724 /* Round up to decl_align instead. */ 9725 object_offset_in_bits += decl_align_in_bits - 1; 9726 object_offset_in_bits /= decl_align_in_bits; 9727 object_offset_in_bits *= decl_align_in_bits; 9728 } 9729 9730 return object_offset_in_bits / BITS_PER_UNIT; 9731} 9732 9733/* The following routines define various Dwarf attributes and any data 9734 associated with them. */ 9735 9736/* Add a location description attribute value to a DIE. 9737 9738 This emits location attributes suitable for whole variables and 9739 whole parameters. Note that the location attributes for struct fields are 9740 generated by the routine `data_member_location_attribute' below. */ 9741 9742static inline void 9743add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind, 9744 dw_loc_descr_ref descr) 9745{ 9746 if (descr != 0) 9747 add_AT_loc (die, attr_kind, descr); 9748} 9749 9750/* Attach the specialized form of location attribute used for data members of 9751 struct and union types. In the special case of a FIELD_DECL node which 9752 represents a bit-field, the "offset" part of this special location 9753 descriptor must indicate the distance in bytes from the lowest-addressed 9754 byte of the containing struct or union type to the lowest-addressed byte of 9755 the "containing object" for the bit-field. (See the `field_byte_offset' 9756 function above). 9757 9758 For any given bit-field, the "containing object" is a hypothetical object 9759 (of some integral or enum type) within which the given bit-field lives. The 9760 type of this hypothetical "containing object" is always the same as the 9761 declared type of the individual bit-field itself (for GCC anyway... the 9762 DWARF spec doesn't actually mandate this). Note that it is the size (in 9763 bytes) of the hypothetical "containing object" which will be given in the 9764 DW_AT_byte_size attribute for this bit-field. (See the 9765 `byte_size_attribute' function below.) It is also used when calculating the 9766 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute' 9767 function below.) */ 9768 9769static void 9770add_data_member_location_attribute (dw_die_ref die, tree decl) 9771{ 9772 HOST_WIDE_INT offset; 9773 dw_loc_descr_ref loc_descr = 0; 9774 9775 if (TREE_CODE (decl) == TREE_BINFO) 9776 { 9777 /* We're working on the TAG_inheritance for a base class. */ 9778 if (BINFO_VIRTUAL_P (decl) && is_cxx ()) 9779 { 9780 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they 9781 aren't at a fixed offset from all (sub)objects of the same 9782 type. We need to extract the appropriate offset from our 9783 vtable. The following dwarf expression means 9784 9785 BaseAddr = ObAddr + *((*ObAddr) - Offset) 9786 9787 This is specific to the V3 ABI, of course. */ 9788 9789 dw_loc_descr_ref tmp; 9790 9791 /* Make a copy of the object address. */ 9792 tmp = new_loc_descr (DW_OP_dup, 0, 0); 9793 add_loc_descr (&loc_descr, tmp); 9794 9795 /* Extract the vtable address. */ 9796 tmp = new_loc_descr (DW_OP_deref, 0, 0); 9797 add_loc_descr (&loc_descr, tmp); 9798 9799 /* Calculate the address of the offset. */ 9800 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0); 9801 gcc_assert (offset < 0); 9802 9803 tmp = int_loc_descriptor (-offset); 9804 add_loc_descr (&loc_descr, tmp); 9805 tmp = new_loc_descr (DW_OP_minus, 0, 0); 9806 add_loc_descr (&loc_descr, tmp); 9807 9808 /* Extract the offset. */ 9809 tmp = new_loc_descr (DW_OP_deref, 0, 0); 9810 add_loc_descr (&loc_descr, tmp); 9811 9812 /* Add it to the object address. */ 9813 tmp = new_loc_descr (DW_OP_plus, 0, 0); 9814 add_loc_descr (&loc_descr, tmp); 9815 } 9816 else 9817 offset = tree_low_cst (BINFO_OFFSET (decl), 0); 9818 } 9819 else 9820 offset = field_byte_offset (decl); 9821 9822 if (! loc_descr) 9823 { 9824 enum dwarf_location_atom op; 9825 9826 /* The DWARF2 standard says that we should assume that the structure 9827 address is already on the stack, so we can specify a structure field 9828 address by using DW_OP_plus_uconst. */ 9829 9830#ifdef MIPS_DEBUGGING_INFO 9831 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst 9832 operator correctly. It works only if we leave the offset on the 9833 stack. */ 9834 op = DW_OP_constu; 9835#else 9836 op = DW_OP_plus_uconst; 9837#endif 9838 9839 loc_descr = new_loc_descr (op, offset, 0); 9840 } 9841 9842 add_AT_loc (die, DW_AT_data_member_location, loc_descr); 9843} 9844 9845/* Writes integer values to dw_vec_const array. */ 9846 9847static void 9848insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest) 9849{ 9850 while (size != 0) 9851 { 9852 *dest++ = val & 0xff; 9853 val >>= 8; 9854 --size; 9855 } 9856} 9857 9858/* Reads integers from dw_vec_const array. Inverse of insert_int. */ 9859 9860static HOST_WIDE_INT 9861extract_int (const unsigned char *src, unsigned int size) 9862{ 9863 HOST_WIDE_INT val = 0; 9864 9865 src += size; 9866 while (size != 0) 9867 { 9868 val <<= 8; 9869 val |= *--src & 0xff; 9870 --size; 9871 } 9872 return val; 9873} 9874 9875/* Writes floating point values to dw_vec_const array. */ 9876 9877static void 9878insert_float (rtx rtl, unsigned char *array) 9879{ 9880 REAL_VALUE_TYPE rv; 9881 long val[4]; 9882 int i; 9883 9884 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl); 9885 real_to_target (val, &rv, GET_MODE (rtl)); 9886 9887 /* real_to_target puts 32-bit pieces in each long. Pack them. */ 9888 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++) 9889 { 9890 insert_int (val[i], 4, array); 9891 array += 4; 9892 } 9893} 9894 9895/* Attach a DW_AT_const_value attribute for a variable or a parameter which 9896 does not have a "location" either in memory or in a register. These 9897 things can arise in GNU C when a constant is passed as an actual parameter 9898 to an inlined function. They can also arise in C++ where declared 9899 constants do not necessarily get memory "homes". */ 9900 9901static void 9902add_const_value_attribute (dw_die_ref die, rtx rtl) 9903{ 9904 switch (GET_CODE (rtl)) 9905 { 9906 case CONST_INT: 9907 { 9908 HOST_WIDE_INT val = INTVAL (rtl); 9909 9910 if (val < 0) 9911 add_AT_int (die, DW_AT_const_value, val); 9912 else 9913 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val); 9914 } 9915 break; 9916 9917 case CONST_DOUBLE: 9918 /* Note that a CONST_DOUBLE rtx could represent either an integer or a 9919 floating-point constant. A CONST_DOUBLE is used whenever the 9920 constant requires more than one word in order to be adequately 9921 represented. We output CONST_DOUBLEs as blocks. */ 9922 { 9923 enum machine_mode mode = GET_MODE (rtl); 9924 9925 if (SCALAR_FLOAT_MODE_P (mode)) 9926 { 9927 unsigned int length = GET_MODE_SIZE (mode); 9928 unsigned char *array = ggc_alloc (length); 9929 9930 insert_float (rtl, array); 9931 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array); 9932 } 9933 else 9934 { 9935 /* ??? We really should be using HOST_WIDE_INT throughout. */ 9936 gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT); 9937 9938 add_AT_long_long (die, DW_AT_const_value, 9939 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl)); 9940 } 9941 } 9942 break; 9943 9944 case CONST_VECTOR: 9945 { 9946 enum machine_mode mode = GET_MODE (rtl); 9947 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode); 9948 unsigned int length = CONST_VECTOR_NUNITS (rtl); 9949 unsigned char *array = ggc_alloc (length * elt_size); 9950 unsigned int i; 9951 unsigned char *p; 9952 9953 switch (GET_MODE_CLASS (mode)) 9954 { 9955 case MODE_VECTOR_INT: 9956 for (i = 0, p = array; i < length; i++, p += elt_size) 9957 { 9958 rtx elt = CONST_VECTOR_ELT (rtl, i); 9959 HOST_WIDE_INT lo, hi; 9960 9961 switch (GET_CODE (elt)) 9962 { 9963 case CONST_INT: 9964 lo = INTVAL (elt); 9965 hi = -(lo < 0); 9966 break; 9967 9968 case CONST_DOUBLE: 9969 lo = CONST_DOUBLE_LOW (elt); 9970 hi = CONST_DOUBLE_HIGH (elt); 9971 break; 9972 9973 default: 9974 gcc_unreachable (); 9975 } 9976 9977 if (elt_size <= sizeof (HOST_WIDE_INT)) 9978 insert_int (lo, elt_size, p); 9979 else 9980 { 9981 unsigned char *p0 = p; 9982 unsigned char *p1 = p + sizeof (HOST_WIDE_INT); 9983 9984 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT)); 9985 if (WORDS_BIG_ENDIAN) 9986 { 9987 p0 = p1; 9988 p1 = p; 9989 } 9990 insert_int (lo, sizeof (HOST_WIDE_INT), p0); 9991 insert_int (hi, sizeof (HOST_WIDE_INT), p1); 9992 } 9993 } 9994 break; 9995 9996 case MODE_VECTOR_FLOAT: 9997 for (i = 0, p = array; i < length; i++, p += elt_size) 9998 { 9999 rtx elt = CONST_VECTOR_ELT (rtl, i); 10000 insert_float (elt, p); 10001 } 10002 break; 10003 10004 default: 10005 gcc_unreachable (); 10006 } 10007 10008 add_AT_vec (die, DW_AT_const_value, length, elt_size, array); 10009 } 10010 break; 10011 10012 case CONST_STRING: 10013 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0)); 10014 break; 10015 10016 case SYMBOL_REF: 10017 case LABEL_REF: 10018 case CONST: 10019 add_AT_addr (die, DW_AT_const_value, rtl); 10020 VEC_safe_push (rtx, gc, used_rtx_array, rtl); 10021 break; 10022 10023 case PLUS: 10024 /* In cases where an inlined instance of an inline function is passed 10025 the address of an `auto' variable (which is local to the caller) we 10026 can get a situation where the DECL_RTL of the artificial local 10027 variable (for the inlining) which acts as a stand-in for the 10028 corresponding formal parameter (of the inline function) will look 10029 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not 10030 exactly a compile-time constant expression, but it isn't the address 10031 of the (artificial) local variable either. Rather, it represents the 10032 *value* which the artificial local variable always has during its 10033 lifetime. We currently have no way to represent such quasi-constant 10034 values in Dwarf, so for now we just punt and generate nothing. */ 10035 break; 10036 10037 default: 10038 /* No other kinds of rtx should be possible here. */ 10039 gcc_unreachable (); 10040 } 10041 10042} 10043 10044/* Determine whether the evaluation of EXPR references any variables 10045 or functions which aren't otherwise used (and therefore may not be 10046 output). */ 10047static tree 10048reference_to_unused (tree * tp, int * walk_subtrees, 10049 void * data ATTRIBUTE_UNUSED) 10050{ 10051 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp)) 10052 *walk_subtrees = 0; 10053 10054 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp) 10055 && ! TREE_ASM_WRITTEN (*tp)) 10056 return *tp; 10057 else if (!flag_unit_at_a_time) 10058 return NULL_TREE; 10059 else if (!cgraph_global_info_ready 10060 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL)) 10061 return *tp; 10062 else if (DECL_P (*tp) && TREE_CODE (*tp) == VAR_DECL) 10063 { 10064 struct cgraph_varpool_node *node = cgraph_varpool_node (*tp); 10065 if (!node->needed) 10066 return *tp; 10067 } 10068 else if (DECL_P (*tp) && TREE_CODE (*tp) == FUNCTION_DECL 10069 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp))) 10070 { 10071 struct cgraph_node *node = cgraph_node (*tp); 10072 if (!node->output) 10073 return *tp; 10074 } 10075 10076 return NULL_TREE; 10077} 10078 10079/* Generate an RTL constant from a decl initializer INIT with decl type TYPE, 10080 for use in a later add_const_value_attribute call. */ 10081 10082static rtx 10083rtl_for_decl_init (tree init, tree type) 10084{ 10085 rtx rtl = NULL_RTX; 10086 10087 /* If a variable is initialized with a string constant without embedded 10088 zeros, build CONST_STRING. */ 10089 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE) 10090 { 10091 tree enttype = TREE_TYPE (type); 10092 tree domain = TYPE_DOMAIN (type); 10093 enum machine_mode mode = TYPE_MODE (enttype); 10094 10095 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1 10096 && domain 10097 && integer_zerop (TYPE_MIN_VALUE (domain)) 10098 && compare_tree_int (TYPE_MAX_VALUE (domain), 10099 TREE_STRING_LENGTH (init) - 1) == 0 10100 && ((size_t) TREE_STRING_LENGTH (init) 10101 == strlen (TREE_STRING_POINTER (init)) + 1)) 10102 rtl = gen_rtx_CONST_STRING (VOIDmode, 10103 ggc_strdup (TREE_STRING_POINTER (init))); 10104 } 10105 /* Other aggregates, and complex values, could be represented using 10106 CONCAT: FIXME! */ 10107 else if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE) 10108 ; 10109 /* Vectors only work if their mode is supported by the target. 10110 FIXME: generic vectors ought to work too. */ 10111 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_MODE (type) == BLKmode) 10112 ; 10113 /* If the initializer is something that we know will expand into an 10114 immediate RTL constant, expand it now. We must be careful not to 10115 reference variables which won't be output. */ 10116 else if (initializer_constant_valid_p (init, type) 10117 && ! walk_tree (&init, reference_to_unused, NULL, NULL)) 10118 { 10119 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if 10120 possible. */ 10121 if (TREE_CODE (type) == VECTOR_TYPE) 10122 switch (TREE_CODE (init)) 10123 { 10124 case VECTOR_CST: 10125 break; 10126 case CONSTRUCTOR: 10127 if (TREE_CONSTANT (init)) 10128 { 10129 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (init); 10130 bool constant_p = true; 10131 tree value; 10132 unsigned HOST_WIDE_INT ix; 10133 10134 /* Even when ctor is constant, it might contain non-*_CST 10135 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't 10136 belong into VECTOR_CST nodes. */ 10137 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value) 10138 if (!CONSTANT_CLASS_P (value)) 10139 { 10140 constant_p = false; 10141 break; 10142 } 10143 10144 if (constant_p) 10145 { 10146 init = build_vector_from_ctor (type, elts); 10147 break; 10148 } 10149 } 10150 /* FALLTHRU */ 10151 10152 default: 10153 return NULL; 10154 } 10155 10156 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER); 10157 10158 /* If expand_expr returns a MEM, it wasn't immediate. */ 10159 gcc_assert (!rtl || !MEM_P (rtl)); 10160 } 10161 10162 return rtl; 10163} 10164 10165/* Generate RTL for the variable DECL to represent its location. */ 10166 10167static rtx 10168rtl_for_decl_location (tree decl) 10169{ 10170 rtx rtl; 10171 10172 /* Here we have to decide where we are going to say the parameter "lives" 10173 (as far as the debugger is concerned). We only have a couple of 10174 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL. 10175 10176 DECL_RTL normally indicates where the parameter lives during most of the 10177 activation of the function. If optimization is enabled however, this 10178 could be either NULL or else a pseudo-reg. Both of those cases indicate 10179 that the parameter doesn't really live anywhere (as far as the code 10180 generation parts of GCC are concerned) during most of the function's 10181 activation. That will happen (for example) if the parameter is never 10182 referenced within the function. 10183 10184 We could just generate a location descriptor here for all non-NULL 10185 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be 10186 a little nicer than that if we also consider DECL_INCOMING_RTL in cases 10187 where DECL_RTL is NULL or is a pseudo-reg. 10188 10189 Note however that we can only get away with using DECL_INCOMING_RTL as 10190 a backup substitute for DECL_RTL in certain limited cases. In cases 10191 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl), 10192 we can be sure that the parameter was passed using the same type as it is 10193 declared to have within the function, and that its DECL_INCOMING_RTL 10194 points us to a place where a value of that type is passed. 10195 10196 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different, 10197 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL 10198 because in these cases DECL_INCOMING_RTL points us to a value of some 10199 type which is *different* from the type of the parameter itself. Thus, 10200 if we tried to use DECL_INCOMING_RTL to generate a location attribute in 10201 such cases, the debugger would end up (for example) trying to fetch a 10202 `float' from a place which actually contains the first part of a 10203 `double'. That would lead to really incorrect and confusing 10204 output at debug-time. 10205 10206 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL 10207 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There 10208 are a couple of exceptions however. On little-endian machines we can 10209 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is 10210 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is 10211 an integral type that is smaller than TREE_TYPE (decl). These cases arise 10212 when (on a little-endian machine) a non-prototyped function has a 10213 parameter declared to be of type `short' or `char'. In such cases, 10214 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will 10215 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the 10216 passed `int' value. If the debugger then uses that address to fetch 10217 a `short' or a `char' (on a little-endian machine) the result will be 10218 the correct data, so we allow for such exceptional cases below. 10219 10220 Note that our goal here is to describe the place where the given formal 10221 parameter lives during most of the function's activation (i.e. between the 10222 end of the prologue and the start of the epilogue). We'll do that as best 10223 as we can. Note however that if the given formal parameter is modified 10224 sometime during the execution of the function, then a stack backtrace (at 10225 debug-time) will show the function as having been called with the *new* 10226 value rather than the value which was originally passed in. This happens 10227 rarely enough that it is not a major problem, but it *is* a problem, and 10228 I'd like to fix it. 10229 10230 A future version of dwarf2out.c may generate two additional attributes for 10231 any given DW_TAG_formal_parameter DIE which will describe the "passed 10232 type" and the "passed location" for the given formal parameter in addition 10233 to the attributes we now generate to indicate the "declared type" and the 10234 "active location" for each parameter. This additional set of attributes 10235 could be used by debuggers for stack backtraces. Separately, note that 10236 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also. 10237 This happens (for example) for inlined-instances of inline function formal 10238 parameters which are never referenced. This really shouldn't be 10239 happening. All PARM_DECL nodes should get valid non-NULL 10240 DECL_INCOMING_RTL values. FIXME. */ 10241 10242 /* Use DECL_RTL as the "location" unless we find something better. */ 10243 rtl = DECL_RTL_IF_SET (decl); 10244 10245 /* When generating abstract instances, ignore everything except 10246 constants, symbols living in memory, and symbols living in 10247 fixed registers. */ 10248 if (! reload_completed) 10249 { 10250 if (rtl 10251 && (CONSTANT_P (rtl) 10252 || (MEM_P (rtl) 10253 && CONSTANT_P (XEXP (rtl, 0))) 10254 || (REG_P (rtl) 10255 && TREE_CODE (decl) == VAR_DECL 10256 && TREE_STATIC (decl)))) 10257 { 10258 rtl = targetm.delegitimize_address (rtl); 10259 return rtl; 10260 } 10261 rtl = NULL_RTX; 10262 } 10263 else if (TREE_CODE (decl) == PARM_DECL) 10264 { 10265 if (rtl == NULL_RTX || is_pseudo_reg (rtl)) 10266 { 10267 tree declared_type = TREE_TYPE (decl); 10268 tree passed_type = DECL_ARG_TYPE (decl); 10269 enum machine_mode dmode = TYPE_MODE (declared_type); 10270 enum machine_mode pmode = TYPE_MODE (passed_type); 10271 10272 /* This decl represents a formal parameter which was optimized out. 10273 Note that DECL_INCOMING_RTL may be NULL in here, but we handle 10274 all cases where (rtl == NULL_RTX) just below. */ 10275 if (dmode == pmode) 10276 rtl = DECL_INCOMING_RTL (decl); 10277 else if (SCALAR_INT_MODE_P (dmode) 10278 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode) 10279 && DECL_INCOMING_RTL (decl)) 10280 { 10281 rtx inc = DECL_INCOMING_RTL (decl); 10282 if (REG_P (inc)) 10283 rtl = inc; 10284 else if (MEM_P (inc)) 10285 { 10286 if (BYTES_BIG_ENDIAN) 10287 rtl = adjust_address_nv (inc, dmode, 10288 GET_MODE_SIZE (pmode) 10289 - GET_MODE_SIZE (dmode)); 10290 else 10291 rtl = inc; 10292 } 10293 } 10294 } 10295 10296 /* If the parm was passed in registers, but lives on the stack, then 10297 make a big endian correction if the mode of the type of the 10298 parameter is not the same as the mode of the rtl. */ 10299 /* ??? This is the same series of checks that are made in dbxout.c before 10300 we reach the big endian correction code there. It isn't clear if all 10301 of these checks are necessary here, but keeping them all is the safe 10302 thing to do. */ 10303 else if (MEM_P (rtl) 10304 && XEXP (rtl, 0) != const0_rtx 10305 && ! CONSTANT_P (XEXP (rtl, 0)) 10306 /* Not passed in memory. */ 10307 && !MEM_P (DECL_INCOMING_RTL (decl)) 10308 /* Not passed by invisible reference. */ 10309 && (!REG_P (XEXP (rtl, 0)) 10310 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM 10311 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM 10312#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM 10313 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM 10314#endif 10315 ) 10316 /* Big endian correction check. */ 10317 && BYTES_BIG_ENDIAN 10318 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl) 10319 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))) 10320 < UNITS_PER_WORD)) 10321 { 10322 int offset = (UNITS_PER_WORD 10323 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))); 10324 10325 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)), 10326 plus_constant (XEXP (rtl, 0), offset)); 10327 } 10328 } 10329 else if (TREE_CODE (decl) == VAR_DECL 10330 && rtl 10331 && MEM_P (rtl) 10332 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl)) 10333 && BYTES_BIG_ENDIAN) 10334 { 10335 int rsize = GET_MODE_SIZE (GET_MODE (rtl)); 10336 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))); 10337 10338 /* If a variable is declared "register" yet is smaller than 10339 a register, then if we store the variable to memory, it 10340 looks like we're storing a register-sized value, when in 10341 fact we are not. We need to adjust the offset of the 10342 storage location to reflect the actual value's bytes, 10343 else gdb will not be able to display it. */ 10344 if (rsize > dsize) 10345 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)), 10346 plus_constant (XEXP (rtl, 0), rsize-dsize)); 10347 } 10348 10349 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant, 10350 and will have been substituted directly into all expressions that use it. 10351 C does not have such a concept, but C++ and other languages do. */ 10352 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl)) 10353 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl)); 10354 10355 if (rtl) 10356 rtl = targetm.delegitimize_address (rtl); 10357 10358 /* If we don't look past the constant pool, we risk emitting a 10359 reference to a constant pool entry that isn't referenced from 10360 code, and thus is not emitted. */ 10361 if (rtl) 10362 rtl = avoid_constant_pool_reference (rtl); 10363 10364 return rtl; 10365} 10366 10367/* We need to figure out what section we should use as the base for the 10368 address ranges where a given location is valid. 10369 1. If this particular DECL has a section associated with it, use that. 10370 2. If this function has a section associated with it, use that. 10371 3. Otherwise, use the text section. 10372 XXX: If you split a variable across multiple sections, we won't notice. */ 10373 10374static const char * 10375secname_for_decl (tree decl) 10376{ 10377 const char *secname; 10378 10379 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl)) 10380 { 10381 tree sectree = DECL_SECTION_NAME (decl); 10382 secname = TREE_STRING_POINTER (sectree); 10383 } 10384 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl)) 10385 { 10386 tree sectree = DECL_SECTION_NAME (current_function_decl); 10387 secname = TREE_STRING_POINTER (sectree); 10388 } 10389 else if (cfun && in_cold_section_p) 10390 secname = cfun->cold_section_label; 10391 else 10392 secname = text_section_label; 10393 10394 return secname; 10395} 10396 10397/* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value 10398 data attribute for a variable or a parameter. We generate the 10399 DW_AT_const_value attribute only in those cases where the given variable 10400 or parameter does not have a true "location" either in memory or in a 10401 register. This can happen (for example) when a constant is passed as an 10402 actual argument in a call to an inline function. (It's possible that 10403 these things can crop up in other ways also.) Note that one type of 10404 constant value which can be passed into an inlined function is a constant 10405 pointer. This can happen for example if an actual argument in an inlined 10406 function call evaluates to a compile-time constant address. */ 10407 10408static void 10409add_location_or_const_value_attribute (dw_die_ref die, tree decl, 10410 enum dwarf_attribute attr) 10411{ 10412 rtx rtl; 10413 dw_loc_descr_ref descr; 10414 var_loc_list *loc_list; 10415 struct var_loc_node *node; 10416 if (TREE_CODE (decl) == ERROR_MARK) 10417 return; 10418 10419 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL 10420 || TREE_CODE (decl) == RESULT_DECL); 10421 10422 /* See if we possibly have multiple locations for this variable. */ 10423 loc_list = lookup_decl_loc (decl); 10424 10425 /* If it truly has multiple locations, the first and last node will 10426 differ. */ 10427 if (loc_list && loc_list->first != loc_list->last) 10428 { 10429 const char *endname, *secname; 10430 dw_loc_list_ref list; 10431 rtx varloc; 10432 10433 /* Now that we know what section we are using for a base, 10434 actually construct the list of locations. 10435 The first location information is what is passed to the 10436 function that creates the location list, and the remaining 10437 locations just get added on to that list. 10438 Note that we only know the start address for a location 10439 (IE location changes), so to build the range, we use 10440 the range [current location start, next location start]. 10441 This means we have to special case the last node, and generate 10442 a range of [last location start, end of function label]. */ 10443 10444 node = loc_list->first; 10445 varloc = NOTE_VAR_LOCATION (node->var_loc_note); 10446 secname = secname_for_decl (decl); 10447 10448 list = new_loc_list (loc_descriptor (varloc), 10449 node->label, node->next->label, secname, 1); 10450 node = node->next; 10451 10452 for (; node->next; node = node->next) 10453 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX) 10454 { 10455 /* The variable has a location between NODE->LABEL and 10456 NODE->NEXT->LABEL. */ 10457 varloc = NOTE_VAR_LOCATION (node->var_loc_note); 10458 add_loc_descr_to_loc_list (&list, loc_descriptor (varloc), 10459 node->label, node->next->label, secname); 10460 } 10461 10462 /* If the variable has a location at the last label 10463 it keeps its location until the end of function. */ 10464 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX) 10465 { 10466 char label_id[MAX_ARTIFICIAL_LABEL_BYTES]; 10467 10468 varloc = NOTE_VAR_LOCATION (node->var_loc_note); 10469 if (!current_function_decl) 10470 endname = text_end_label; 10471 else 10472 { 10473 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL, 10474 current_function_funcdef_no); 10475 endname = ggc_strdup (label_id); 10476 } 10477 add_loc_descr_to_loc_list (&list, loc_descriptor (varloc), 10478 node->label, endname, secname); 10479 } 10480 10481 /* Finally, add the location list to the DIE, and we are done. */ 10482 add_AT_loc_list (die, attr, list); 10483 return; 10484 } 10485 10486 /* Try to get some constant RTL for this decl, and use that as the value of 10487 the location. */ 10488 10489 rtl = rtl_for_decl_location (decl); 10490 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)) 10491 { 10492 add_const_value_attribute (die, rtl); 10493 return; 10494 } 10495 10496 /* If we have tried to generate the location otherwise, and it 10497 didn't work out (we wouldn't be here if we did), and we have a one entry 10498 location list, try generating a location from that. */ 10499 if (loc_list && loc_list->first) 10500 { 10501 node = loc_list->first; 10502 descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note)); 10503 if (descr) 10504 { 10505 add_AT_location_description (die, attr, descr); 10506 return; 10507 } 10508 } 10509 10510 /* We couldn't get any rtl, so try directly generating the location 10511 description from the tree. */ 10512 descr = loc_descriptor_from_tree (decl); 10513 if (descr) 10514 { 10515 add_AT_location_description (die, attr, descr); 10516 return; 10517 } 10518 /* None of that worked, so it must not really have a location; 10519 try adding a constant value attribute from the DECL_INITIAL. */ 10520 tree_add_const_value_attribute (die, decl); 10521} 10522 10523/* If we don't have a copy of this variable in memory for some reason (such 10524 as a C++ member constant that doesn't have an out-of-line definition), 10525 we should tell the debugger about the constant value. */ 10526 10527static void 10528tree_add_const_value_attribute (dw_die_ref var_die, tree decl) 10529{ 10530 tree init = DECL_INITIAL (decl); 10531 tree type = TREE_TYPE (decl); 10532 rtx rtl; 10533 10534 if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init) 10535 /* OK */; 10536 else 10537 return; 10538 10539 rtl = rtl_for_decl_init (init, type); 10540 if (rtl) 10541 add_const_value_attribute (var_die, rtl); 10542} 10543 10544/* Convert the CFI instructions for the current function into a 10545 location list. This is used for DW_AT_frame_base when we targeting 10546 a dwarf2 consumer that does not support the dwarf3 10547 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA 10548 expressions. */ 10549 10550static dw_loc_list_ref 10551convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset) 10552{ 10553 dw_fde_ref fde; 10554 dw_loc_list_ref list, *list_tail; 10555 dw_cfi_ref cfi; 10556 dw_cfa_location last_cfa, next_cfa; 10557 const char *start_label, *last_label, *section; 10558 10559 fde = &fde_table[fde_table_in_use - 1]; 10560 10561 section = secname_for_decl (current_function_decl); 10562 list_tail = &list; 10563 list = NULL; 10564 10565 next_cfa.reg = INVALID_REGNUM; 10566 next_cfa.offset = 0; 10567 next_cfa.indirect = 0; 10568 next_cfa.base_offset = 0; 10569 10570 start_label = fde->dw_fde_begin; 10571 10572 /* ??? Bald assumption that the CIE opcode list does not contain 10573 advance opcodes. */ 10574 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next) 10575 lookup_cfa_1 (cfi, &next_cfa); 10576 10577 last_cfa = next_cfa; 10578 last_label = start_label; 10579 10580 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next) 10581 switch (cfi->dw_cfi_opc) 10582 { 10583 case DW_CFA_set_loc: 10584 case DW_CFA_advance_loc1: 10585 case DW_CFA_advance_loc2: 10586 case DW_CFA_advance_loc4: 10587 if (!cfa_equal_p (&last_cfa, &next_cfa)) 10588 { 10589 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset), 10590 start_label, last_label, section, 10591 list == NULL); 10592 10593 list_tail = &(*list_tail)->dw_loc_next; 10594 last_cfa = next_cfa; 10595 start_label = last_label; 10596 } 10597 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 10598 break; 10599 10600 case DW_CFA_advance_loc: 10601 /* The encoding is complex enough that we should never emit this. */ 10602 case DW_CFA_remember_state: 10603 case DW_CFA_restore_state: 10604 /* We don't handle these two in this function. It would be possible 10605 if it were to be required. */ 10606 gcc_unreachable (); 10607 10608 default: 10609 lookup_cfa_1 (cfi, &next_cfa); 10610 break; 10611 } 10612 10613 if (!cfa_equal_p (&last_cfa, &next_cfa)) 10614 { 10615 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset), 10616 start_label, last_label, section, 10617 list == NULL); 10618 list_tail = &(*list_tail)->dw_loc_next; 10619 start_label = last_label; 10620 } 10621 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset), 10622 start_label, fde->dw_fde_end, section, 10623 list == NULL); 10624 10625 return list; 10626} 10627 10628/* Compute a displacement from the "steady-state frame pointer" to the 10629 frame base (often the same as the CFA), and store it in 10630 frame_pointer_fb_offset. OFFSET is added to the displacement 10631 before the latter is negated. */ 10632 10633static void 10634compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset) 10635{ 10636 rtx reg, elim; 10637 10638#ifdef FRAME_POINTER_CFA_OFFSET 10639 reg = frame_pointer_rtx; 10640 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl); 10641#else 10642 reg = arg_pointer_rtx; 10643 offset += ARG_POINTER_CFA_OFFSET (current_function_decl); 10644#endif 10645 10646 elim = eliminate_regs (reg, VOIDmode, NULL_RTX); 10647 if (GET_CODE (elim) == PLUS) 10648 { 10649 offset += INTVAL (XEXP (elim, 1)); 10650 elim = XEXP (elim, 0); 10651 } 10652 gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx 10653 : stack_pointer_rtx)); 10654 10655 frame_pointer_fb_offset = -offset; 10656} 10657 10658/* Generate a DW_AT_name attribute given some string value to be included as 10659 the value of the attribute. */ 10660 10661static void 10662add_name_attribute (dw_die_ref die, const char *name_string) 10663{ 10664 if (name_string != NULL && *name_string != 0) 10665 { 10666 if (demangle_name_func) 10667 name_string = (*demangle_name_func) (name_string); 10668 10669 add_AT_string (die, DW_AT_name, name_string); 10670 } 10671} 10672 10673/* Generate a DW_AT_comp_dir attribute for DIE. */ 10674 10675static void 10676add_comp_dir_attribute (dw_die_ref die) 10677{ 10678 const char *wd = get_src_pwd (); 10679 if (wd != NULL) 10680 add_AT_string (die, DW_AT_comp_dir, wd); 10681} 10682 10683/* Given a tree node describing an array bound (either lower or upper) output 10684 a representation for that bound. */ 10685 10686static void 10687add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound) 10688{ 10689 switch (TREE_CODE (bound)) 10690 { 10691 case ERROR_MARK: 10692 return; 10693 10694 /* All fixed-bounds are represented by INTEGER_CST nodes. */ 10695 case INTEGER_CST: 10696 if (! host_integerp (bound, 0) 10697 || (bound_attr == DW_AT_lower_bound 10698 && (((is_c_family () || is_java ()) && integer_zerop (bound)) 10699 || (is_fortran () && integer_onep (bound))))) 10700 /* Use the default. */ 10701 ; 10702 else 10703 add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0)); 10704 break; 10705 10706 case CONVERT_EXPR: 10707 case NOP_EXPR: 10708 case NON_LVALUE_EXPR: 10709 case VIEW_CONVERT_EXPR: 10710 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0)); 10711 break; 10712 10713 case SAVE_EXPR: 10714 break; 10715 10716 case VAR_DECL: 10717 case PARM_DECL: 10718 case RESULT_DECL: 10719 { 10720 dw_die_ref decl_die = lookup_decl_die (bound); 10721 10722 /* ??? Can this happen, or should the variable have been bound 10723 first? Probably it can, since I imagine that we try to create 10724 the types of parameters in the order in which they exist in 10725 the list, and won't have created a forward reference to a 10726 later parameter. */ 10727 if (decl_die != NULL) 10728 add_AT_die_ref (subrange_die, bound_attr, decl_die); 10729 break; 10730 } 10731 10732 default: 10733 { 10734 /* Otherwise try to create a stack operation procedure to 10735 evaluate the value of the array bound. */ 10736 10737 dw_die_ref ctx, decl_die; 10738 dw_loc_descr_ref loc; 10739 10740 loc = loc_descriptor_from_tree (bound); 10741 if (loc == NULL) 10742 break; 10743 10744 if (current_function_decl == 0) 10745 ctx = comp_unit_die; 10746 else 10747 ctx = lookup_decl_die (current_function_decl); 10748 10749 decl_die = new_die (DW_TAG_variable, ctx, bound); 10750 add_AT_flag (decl_die, DW_AT_artificial, 1); 10751 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx); 10752 add_AT_loc (decl_die, DW_AT_location, loc); 10753 10754 add_AT_die_ref (subrange_die, bound_attr, decl_die); 10755 break; 10756 } 10757 } 10758} 10759 10760/* Note that the block of subscript information for an array type also 10761 includes information about the element type of type given array type. */ 10762 10763static void 10764add_subscript_info (dw_die_ref type_die, tree type) 10765{ 10766#ifndef MIPS_DEBUGGING_INFO 10767 unsigned dimension_number; 10768#endif 10769 tree lower, upper; 10770 dw_die_ref subrange_die; 10771 10772 /* The GNU compilers represent multidimensional array types as sequences of 10773 one dimensional array types whose element types are themselves array 10774 types. Here we squish that down, so that each multidimensional array 10775 type gets only one array_type DIE in the Dwarf debugging info. The draft 10776 Dwarf specification say that we are allowed to do this kind of 10777 compression in C (because there is no difference between an array or 10778 arrays and a multidimensional array in C) but for other source languages 10779 (e.g. Ada) we probably shouldn't do this. */ 10780 10781 /* ??? The SGI dwarf reader fails for multidimensional arrays with a 10782 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10]. 10783 We work around this by disabling this feature. See also 10784 gen_array_type_die. */ 10785#ifndef MIPS_DEBUGGING_INFO 10786 for (dimension_number = 0; 10787 TREE_CODE (type) == ARRAY_TYPE; 10788 type = TREE_TYPE (type), dimension_number++) 10789#endif 10790 { 10791 tree domain = TYPE_DOMAIN (type); 10792 10793 /* Arrays come in three flavors: Unspecified bounds, fixed bounds, 10794 and (in GNU C only) variable bounds. Handle all three forms 10795 here. */ 10796 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL); 10797 if (domain) 10798 { 10799 /* We have an array type with specified bounds. */ 10800 lower = TYPE_MIN_VALUE (domain); 10801 upper = TYPE_MAX_VALUE (domain); 10802 10803 /* Define the index type. */ 10804 if (TREE_TYPE (domain)) 10805 { 10806 /* ??? This is probably an Ada unnamed subrange type. Ignore the 10807 TREE_TYPE field. We can't emit debug info for this 10808 because it is an unnamed integral type. */ 10809 if (TREE_CODE (domain) == INTEGER_TYPE 10810 && TYPE_NAME (domain) == NULL_TREE 10811 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE 10812 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE) 10813 ; 10814 else 10815 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0, 10816 type_die); 10817 } 10818 10819 /* ??? If upper is NULL, the array has unspecified length, 10820 but it does have a lower bound. This happens with Fortran 10821 dimension arr(N:*) 10822 Since the debugger is definitely going to need to know N 10823 to produce useful results, go ahead and output the lower 10824 bound solo, and hope the debugger can cope. */ 10825 10826 add_bound_info (subrange_die, DW_AT_lower_bound, lower); 10827 if (upper) 10828 add_bound_info (subrange_die, DW_AT_upper_bound, upper); 10829 } 10830 10831 /* Otherwise we have an array type with an unspecified length. The 10832 DWARF-2 spec does not say how to handle this; let's just leave out the 10833 bounds. */ 10834 } 10835} 10836 10837static void 10838add_byte_size_attribute (dw_die_ref die, tree tree_node) 10839{ 10840 unsigned size; 10841 10842 switch (TREE_CODE (tree_node)) 10843 { 10844 case ERROR_MARK: 10845 size = 0; 10846 break; 10847 case ENUMERAL_TYPE: 10848 case RECORD_TYPE: 10849 case UNION_TYPE: 10850 case QUAL_UNION_TYPE: 10851 size = int_size_in_bytes (tree_node); 10852 break; 10853 case FIELD_DECL: 10854 /* For a data member of a struct or union, the DW_AT_byte_size is 10855 generally given as the number of bytes normally allocated for an 10856 object of the *declared* type of the member itself. This is true 10857 even for bit-fields. */ 10858 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT; 10859 break; 10860 default: 10861 gcc_unreachable (); 10862 } 10863 10864 /* Note that `size' might be -1 when we get to this point. If it is, that 10865 indicates that the byte size of the entity in question is variable. We 10866 have no good way of expressing this fact in Dwarf at the present time. 10867 GCC/35998: Avoid passing negative sizes to Dtrace and gdb. */ 10868 add_AT_unsigned (die, DW_AT_byte_size, (size != (unsigned)-1 ? size : 0)); 10869} 10870 10871/* For a FIELD_DECL node which represents a bit-field, output an attribute 10872 which specifies the distance in bits from the highest order bit of the 10873 "containing object" for the bit-field to the highest order bit of the 10874 bit-field itself. 10875 10876 For any given bit-field, the "containing object" is a hypothetical object 10877 (of some integral or enum type) within which the given bit-field lives. The 10878 type of this hypothetical "containing object" is always the same as the 10879 declared type of the individual bit-field itself. The determination of the 10880 exact location of the "containing object" for a bit-field is rather 10881 complicated. It's handled by the `field_byte_offset' function (above). 10882 10883 Note that it is the size (in bytes) of the hypothetical "containing object" 10884 which will be given in the DW_AT_byte_size attribute for this bit-field. 10885 (See `byte_size_attribute' above). */ 10886 10887static inline void 10888add_bit_offset_attribute (dw_die_ref die, tree decl) 10889{ 10890 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl); 10891 tree type = DECL_BIT_FIELD_TYPE (decl); 10892 HOST_WIDE_INT bitpos_int; 10893 HOST_WIDE_INT highest_order_object_bit_offset; 10894 HOST_WIDE_INT highest_order_field_bit_offset; 10895 HOST_WIDE_INT unsigned bit_offset; 10896 10897 /* Must be a field and a bit field. */ 10898 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL); 10899 10900 /* We can't yet handle bit-fields whose offsets are variable, so if we 10901 encounter such things, just return without generating any attribute 10902 whatsoever. Likewise for variable or too large size. */ 10903 if (! host_integerp (bit_position (decl), 0) 10904 || ! host_integerp (DECL_SIZE (decl), 1)) 10905 return; 10906 10907 bitpos_int = int_bit_position (decl); 10908 10909 /* Note that the bit offset is always the distance (in bits) from the 10910 highest-order bit of the "containing object" to the highest-order bit of 10911 the bit-field itself. Since the "high-order end" of any object or field 10912 is different on big-endian and little-endian machines, the computation 10913 below must take account of these differences. */ 10914 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT; 10915 highest_order_field_bit_offset = bitpos_int; 10916 10917 if (! BYTES_BIG_ENDIAN) 10918 { 10919 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0); 10920 highest_order_object_bit_offset += simple_type_size_in_bits (type); 10921 } 10922 10923 bit_offset 10924 = (! BYTES_BIG_ENDIAN 10925 ? highest_order_object_bit_offset - highest_order_field_bit_offset 10926 : highest_order_field_bit_offset - highest_order_object_bit_offset); 10927 10928 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset); 10929} 10930 10931/* For a FIELD_DECL node which represents a bit field, output an attribute 10932 which specifies the length in bits of the given field. */ 10933 10934static inline void 10935add_bit_size_attribute (dw_die_ref die, tree decl) 10936{ 10937 /* Must be a field and a bit field. */ 10938 gcc_assert (TREE_CODE (decl) == FIELD_DECL 10939 && DECL_BIT_FIELD_TYPE (decl)); 10940 10941 if (host_integerp (DECL_SIZE (decl), 1)) 10942 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1)); 10943} 10944 10945/* If the compiled language is ANSI C, then add a 'prototyped' 10946 attribute, if arg types are given for the parameters of a function. */ 10947 10948static inline void 10949add_prototyped_attribute (dw_die_ref die, tree func_type) 10950{ 10951 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89 10952 && TYPE_ARG_TYPES (func_type) != NULL) 10953 add_AT_flag (die, DW_AT_prototyped, 1); 10954} 10955 10956/* Add an 'abstract_origin' attribute below a given DIE. The DIE is found 10957 by looking in either the type declaration or object declaration 10958 equate table. */ 10959 10960static inline void 10961add_abstract_origin_attribute (dw_die_ref die, tree origin) 10962{ 10963 dw_die_ref origin_die = NULL; 10964 10965 if (TREE_CODE (origin) != FUNCTION_DECL) 10966 { 10967 /* We may have gotten separated from the block for the inlined 10968 function, if we're in an exception handler or some such; make 10969 sure that the abstract function has been written out. 10970 10971 Doing this for nested functions is wrong, however; functions are 10972 distinct units, and our context might not even be inline. */ 10973 tree fn = origin; 10974 10975 if (TYPE_P (fn)) 10976 fn = TYPE_STUB_DECL (fn); 10977 10978 fn = decl_function_context (fn); 10979 if (fn) 10980 dwarf2out_abstract_function (fn); 10981 } 10982 10983 if (DECL_P (origin)) 10984 origin_die = lookup_decl_die (origin); 10985 else if (TYPE_P (origin)) 10986 origin_die = lookup_type_die (origin); 10987 10988 /* XXX: Functions that are never lowered don't always have correct block 10989 trees (in the case of java, they simply have no block tree, in some other 10990 languages). For these functions, there is nothing we can really do to 10991 output correct debug info for inlined functions in all cases. Rather 10992 than die, we'll just produce deficient debug info now, in that we will 10993 have variables without a proper abstract origin. In the future, when all 10994 functions are lowered, we should re-add a gcc_assert (origin_die) 10995 here. */ 10996 10997 if (origin_die) 10998 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die); 10999} 11000 11001/* We do not currently support the pure_virtual attribute. */ 11002 11003static inline void 11004add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl) 11005{ 11006 if (DECL_VINDEX (func_decl)) 11007 { 11008 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual); 11009 11010 if (host_integerp (DECL_VINDEX (func_decl), 0)) 11011 add_AT_loc (die, DW_AT_vtable_elem_location, 11012 new_loc_descr (DW_OP_constu, 11013 tree_low_cst (DECL_VINDEX (func_decl), 0), 11014 0)); 11015 11016 /* GNU extension: Record what type this method came from originally. */ 11017 if (debug_info_level > DINFO_LEVEL_TERSE) 11018 add_AT_die_ref (die, DW_AT_containing_type, 11019 lookup_type_die (DECL_CONTEXT (func_decl))); 11020 } 11021} 11022 11023/* Add source coordinate attributes for the given decl. */ 11024 11025static void 11026add_src_coords_attributes (dw_die_ref die, tree decl) 11027{ 11028 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl)); 11029 11030 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file)); 11031 add_AT_unsigned (die, DW_AT_decl_line, s.line); 11032} 11033 11034/* Add a DW_AT_name attribute and source coordinate attribute for the 11035 given decl, but only if it actually has a name. */ 11036 11037static void 11038add_name_and_src_coords_attributes (dw_die_ref die, tree decl) 11039{ 11040 tree decl_name; 11041 11042 decl_name = DECL_NAME (decl); 11043 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL) 11044 { 11045 add_name_attribute (die, dwarf2_name (decl, 0)); 11046 if (! DECL_ARTIFICIAL (decl)) 11047 add_src_coords_attributes (die, decl); 11048 11049 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL) 11050 && TREE_PUBLIC (decl) 11051 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl) 11052 && !DECL_ABSTRACT (decl) 11053 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))) 11054 add_AT_string (die, DW_AT_MIPS_linkage_name, 11055 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); 11056 } 11057 11058#ifdef VMS_DEBUGGING_INFO 11059 /* Get the function's name, as described by its RTL. This may be different 11060 from the DECL_NAME name used in the source file. */ 11061 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl)) 11062 { 11063 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address, 11064 XEXP (DECL_RTL (decl), 0)); 11065 VEC_safe_push (tree, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0)); 11066 } 11067#endif 11068} 11069 11070/* Push a new declaration scope. */ 11071 11072static void 11073push_decl_scope (tree scope) 11074{ 11075 VEC_safe_push (tree, gc, decl_scope_table, scope); 11076} 11077 11078/* Pop a declaration scope. */ 11079 11080static inline void 11081pop_decl_scope (void) 11082{ 11083 VEC_pop (tree, decl_scope_table); 11084} 11085 11086/* Return the DIE for the scope that immediately contains this type. 11087 Non-named types get global scope. Named types nested in other 11088 types get their containing scope if it's open, or global scope 11089 otherwise. All other types (i.e. function-local named types) get 11090 the current active scope. */ 11091 11092static dw_die_ref 11093scope_die_for (tree t, dw_die_ref context_die) 11094{ 11095 dw_die_ref scope_die = NULL; 11096 tree containing_scope; 11097 int i; 11098 11099 /* Non-types always go in the current scope. */ 11100 gcc_assert (TYPE_P (t)); 11101 11102 containing_scope = TYPE_CONTEXT (t); 11103 11104 /* Use the containing namespace if it was passed in (for a declaration). */ 11105 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL) 11106 { 11107 if (context_die == lookup_decl_die (containing_scope)) 11108 /* OK */; 11109 else 11110 containing_scope = NULL_TREE; 11111 } 11112 11113 /* Ignore function type "scopes" from the C frontend. They mean that 11114 a tagged type is local to a parmlist of a function declarator, but 11115 that isn't useful to DWARF. */ 11116 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE) 11117 containing_scope = NULL_TREE; 11118 11119 if (containing_scope == NULL_TREE) 11120 scope_die = comp_unit_die; 11121 else if (TYPE_P (containing_scope)) 11122 { 11123 /* For types, we can just look up the appropriate DIE. But 11124 first we check to see if we're in the middle of emitting it 11125 so we know where the new DIE should go. */ 11126 for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i) 11127 if (VEC_index (tree, decl_scope_table, i) == containing_scope) 11128 break; 11129 11130 if (i < 0) 11131 { 11132 gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE 11133 || TREE_ASM_WRITTEN (containing_scope)); 11134 11135 /* If none of the current dies are suitable, we get file scope. */ 11136 scope_die = comp_unit_die; 11137 } 11138 else 11139 scope_die = lookup_type_die (containing_scope); 11140 } 11141 else 11142 scope_die = context_die; 11143 11144 return scope_die; 11145} 11146 11147/* Returns nonzero if CONTEXT_DIE is internal to a function. */ 11148 11149static inline int 11150local_scope_p (dw_die_ref context_die) 11151{ 11152 for (; context_die; context_die = context_die->die_parent) 11153 if (context_die->die_tag == DW_TAG_inlined_subroutine 11154 || context_die->die_tag == DW_TAG_subprogram) 11155 return 1; 11156 11157 return 0; 11158} 11159 11160/* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding 11161 whether or not to treat a DIE in this context as a declaration. */ 11162 11163static inline int 11164class_or_namespace_scope_p (dw_die_ref context_die) 11165{ 11166 return (context_die 11167 && (context_die->die_tag == DW_TAG_structure_type 11168 || context_die->die_tag == DW_TAG_union_type 11169 || context_die->die_tag == DW_TAG_namespace)); 11170} 11171 11172/* Many forms of DIEs require a "type description" attribute. This 11173 routine locates the proper "type descriptor" die for the type given 11174 by 'type', and adds a DW_AT_type attribute below the given die. */ 11175 11176static void 11177add_type_attribute (dw_die_ref object_die, tree type, int decl_const, 11178 int decl_volatile, dw_die_ref context_die) 11179{ 11180 enum tree_code code = TREE_CODE (type); 11181 dw_die_ref type_die = NULL; 11182 11183/* APPLE LOCAL begin radar 5847213 */ 11184 /* APPLE LOCAL begin radar 5811943 - Fix type of pointers to blocks */ 11185 /* APPLE LOCAL - radar 6113240 */ 11186 /* APPLE LOCAL begin radar 6300081 */ 11187 if (code == BLOCK_POINTER_TYPE && generic_block_literal_struct_type) 11188 { 11189 type = build_pointer_type (generic_block_literal_struct_type); 11190 code = TREE_CODE (type); 11191 } 11192 /* APPLE LOCAL end radar 6300081 */ 11193 /* APPLE LOCAL end radar 5811943 - Fix type of pointers to Blocks */ 11194/* APPLE LOCAL end radar 5847213 */ 11195 11196 /* ??? If this type is an unnamed subrange type of an integral or 11197 floating-point type, use the inner type. This is because we have no 11198 support for unnamed types in base_type_die. This can happen if this is 11199 an Ada subrange type. Correct solution is emit a subrange type die. */ 11200 if ((code == INTEGER_TYPE || code == REAL_TYPE) 11201 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0) 11202 type = TREE_TYPE (type), code = TREE_CODE (type); 11203 11204 if (code == ERROR_MARK 11205 /* Handle a special case. For functions whose return type is void, we 11206 generate *no* type attribute. (Note that no object may have type 11207 `void', so this only applies to function return types). */ 11208 || code == VOID_TYPE) 11209 return; 11210 11211 type_die = modified_type_die (type, 11212 decl_const || TYPE_READONLY (type), 11213 decl_volatile || TYPE_VOLATILE (type), 11214 context_die); 11215 11216 if (type_die != NULL) 11217 add_AT_die_ref (object_die, DW_AT_type, type_die); 11218} 11219 11220/* Given an object die, add the calling convention attribute for the 11221 function call type. */ 11222static void 11223add_calling_convention_attribute (dw_die_ref subr_die, tree type) 11224{ 11225 enum dwarf_calling_convention value = DW_CC_normal; 11226 11227 value = targetm.dwarf_calling_convention (type); 11228 11229 /* Only add the attribute if the backend requests it, and 11230 is not DW_CC_normal. */ 11231 if (value && (value != DW_CC_normal)) 11232 add_AT_unsigned (subr_die, DW_AT_calling_convention, value); 11233} 11234 11235/* Given a tree pointer to a struct, class, union, or enum type node, return 11236 a pointer to the (string) tag name for the given type, or zero if the type 11237 was declared without a tag. */ 11238 11239static const char * 11240type_tag (tree type) 11241{ 11242 const char *name = 0; 11243 11244 if (TYPE_NAME (type) != 0) 11245 { 11246 tree t = 0; 11247 11248 /* Find the IDENTIFIER_NODE for the type name. */ 11249 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) 11250 t = TYPE_NAME (type); 11251 11252 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to 11253 a TYPE_DECL node, regardless of whether or not a `typedef' was 11254 involved. */ 11255 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 11256 && ! DECL_IGNORED_P (TYPE_NAME (type))) 11257 t = DECL_NAME (TYPE_NAME (type)); 11258 11259 /* Now get the name as a string, or invent one. */ 11260 if (t != 0) 11261 name = IDENTIFIER_POINTER (t); 11262 } 11263 11264 return (name == 0 || *name == '\0') ? 0 : name; 11265} 11266 11267/* Return the type associated with a data member, make a special check 11268 for bit field types. */ 11269 11270static inline tree 11271member_declared_type (tree member) 11272{ 11273 return (DECL_BIT_FIELD_TYPE (member) 11274 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member)); 11275} 11276 11277/* Get the decl's label, as described by its RTL. This may be different 11278 from the DECL_NAME name used in the source file. */ 11279 11280#if 0 11281static const char * 11282decl_start_label (tree decl) 11283{ 11284 rtx x; 11285 const char *fnname; 11286 11287 x = DECL_RTL (decl); 11288 gcc_assert (MEM_P (x)); 11289 11290 x = XEXP (x, 0); 11291 gcc_assert (GET_CODE (x) == SYMBOL_REF); 11292 11293 fnname = XSTR (x, 0); 11294 return fnname; 11295} 11296#endif 11297 11298/* These routines generate the internal representation of the DIE's for 11299 the compilation unit. Debugging information is collected by walking 11300 the declaration trees passed in from dwarf2out_decl(). */ 11301 11302static void 11303gen_array_type_die (tree type, dw_die_ref context_die) 11304{ 11305 dw_die_ref scope_die = scope_die_for (type, context_die); 11306 dw_die_ref array_die; 11307 tree element_type; 11308 11309 /* ??? The SGI dwarf reader fails for array of array of enum types unless 11310 the inner array type comes before the outer array type. Thus we must 11311 call gen_type_die before we call new_die. See below also. */ 11312#ifdef MIPS_DEBUGGING_INFO 11313 gen_type_die (TREE_TYPE (type), context_die); 11314#endif 11315 11316 array_die = new_die (DW_TAG_array_type, scope_die, type); 11317 add_name_attribute (array_die, type_tag (type)); 11318 equate_type_number_to_die (type, array_die); 11319 11320 if (TREE_CODE (type) == VECTOR_TYPE) 11321 { 11322 /* The frontend feeds us a representation for the vector as a struct 11323 containing an array. Pull out the array type. */ 11324 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type))); 11325 add_AT_flag (array_die, DW_AT_GNU_vector, 1); 11326 } 11327 11328#if 0 11329 /* We default the array ordering. SDB will probably do 11330 the right things even if DW_AT_ordering is not present. It's not even 11331 an issue until we start to get into multidimensional arrays anyway. If 11332 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays, 11333 then we'll have to put the DW_AT_ordering attribute back in. (But if 11334 and when we find out that we need to put these in, we will only do so 11335 for multidimensional arrays. */ 11336 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major); 11337#endif 11338 11339#ifdef MIPS_DEBUGGING_INFO 11340 /* The SGI compilers handle arrays of unknown bound by setting 11341 AT_declaration and not emitting any subrange DIEs. */ 11342 if (! TYPE_DOMAIN (type)) 11343 add_AT_flag (array_die, DW_AT_declaration, 1); 11344 else 11345#endif 11346 add_subscript_info (array_die, type); 11347 11348 /* Add representation of the type of the elements of this array type. */ 11349 element_type = TREE_TYPE (type); 11350 11351 /* ??? The SGI dwarf reader fails for multidimensional arrays with a 11352 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10]. 11353 We work around this by disabling this feature. See also 11354 add_subscript_info. */ 11355#ifndef MIPS_DEBUGGING_INFO 11356 while (TREE_CODE (element_type) == ARRAY_TYPE) 11357 element_type = TREE_TYPE (element_type); 11358 11359 gen_type_die (element_type, context_die); 11360#endif 11361 11362 add_type_attribute (array_die, element_type, 0, 0, context_die); 11363 11364 if (get_AT (array_die, DW_AT_name)) 11365 add_pubtype (type, array_die); 11366} 11367 11368#if 0 11369static void 11370gen_entry_point_die (tree decl, dw_die_ref context_die) 11371{ 11372 tree origin = decl_ultimate_origin (decl); 11373 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl); 11374 11375 if (origin != NULL) 11376 add_abstract_origin_attribute (decl_die, origin); 11377 else 11378 { 11379 add_name_and_src_coords_attributes (decl_die, decl); 11380 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)), 11381 0, 0, context_die); 11382 } 11383 11384 if (DECL_ABSTRACT (decl)) 11385 equate_decl_number_to_die (decl, decl_die); 11386 else 11387 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl)); 11388} 11389#endif 11390 11391/* Walk through the list of incomplete types again, trying once more to 11392 emit full debugging info for them. */ 11393 11394static void 11395retry_incomplete_types (void) 11396{ 11397 int i; 11398 11399 for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--) 11400 gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die); 11401} 11402 11403/* Generate a DIE to represent an inlined instance of an enumeration type. */ 11404 11405static void 11406gen_inlined_enumeration_type_die (tree type, dw_die_ref context_die) 11407{ 11408 dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type); 11409 11410 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may 11411 be incomplete and such types are not marked. */ 11412 add_abstract_origin_attribute (type_die, type); 11413} 11414 11415/* Generate a DIE to represent an inlined instance of a structure type. */ 11416 11417static void 11418gen_inlined_structure_type_die (tree type, dw_die_ref context_die) 11419{ 11420 dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die, type); 11421 11422 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may 11423 be incomplete and such types are not marked. */ 11424 add_abstract_origin_attribute (type_die, type); 11425} 11426 11427/* Generate a DIE to represent an inlined instance of a union type. */ 11428 11429static void 11430gen_inlined_union_type_die (tree type, dw_die_ref context_die) 11431{ 11432 dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type); 11433 11434 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may 11435 be incomplete and such types are not marked. */ 11436 add_abstract_origin_attribute (type_die, type); 11437} 11438 11439/* Generate a DIE to represent an enumeration type. Note that these DIEs 11440 include all of the information about the enumeration values also. Each 11441 enumerated type name/value is listed as a child of the enumerated type 11442 DIE. */ 11443 11444static dw_die_ref 11445gen_enumeration_type_die (tree type, dw_die_ref context_die) 11446{ 11447 dw_die_ref type_die = lookup_type_die (type); 11448 11449 if (type_die == NULL) 11450 { 11451 type_die = new_die (DW_TAG_enumeration_type, 11452 scope_die_for (type, context_die), type); 11453 equate_type_number_to_die (type, type_die); 11454 add_name_attribute (type_die, type_tag (type)); 11455 } 11456 else if (! TYPE_SIZE (type)) 11457 return type_die; 11458 else 11459 remove_AT (type_die, DW_AT_declaration); 11460 11461 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the 11462 given enum type is incomplete, do not generate the DW_AT_byte_size 11463 attribute or the DW_AT_element_list attribute. */ 11464 if (TYPE_SIZE (type)) 11465 { 11466 tree link; 11467 11468 TREE_ASM_WRITTEN (type) = 1; 11469 add_byte_size_attribute (type_die, type); 11470 if (TYPE_STUB_DECL (type) != NULL_TREE) 11471 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type)); 11472 11473 /* If the first reference to this type was as the return type of an 11474 inline function, then it may not have a parent. Fix this now. */ 11475 if (type_die->die_parent == NULL) 11476 add_child_die (scope_die_for (type, context_die), type_die); 11477 11478 for (link = TYPE_VALUES (type); 11479 link != NULL; link = TREE_CHAIN (link)) 11480 { 11481 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link); 11482 tree value = TREE_VALUE (link); 11483 11484 add_name_attribute (enum_die, 11485 IDENTIFIER_POINTER (TREE_PURPOSE (link))); 11486 11487 if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value)))) 11488 /* DWARF2 does not provide a way of indicating whether or 11489 not enumeration constants are signed or unsigned. GDB 11490 always assumes the values are signed, so we output all 11491 values as if they were signed. That means that 11492 enumeration constants with very large unsigned values 11493 will appear to have negative values in the debugger. */ 11494 add_AT_int (enum_die, DW_AT_const_value, 11495 tree_low_cst (value, tree_int_cst_sgn (value) > 0)); 11496 } 11497 } 11498 else 11499 add_AT_flag (type_die, DW_AT_declaration, 1); 11500 11501 if (get_AT (type_die, DW_AT_name)) 11502 add_pubtype (type, type_die); 11503 11504 return type_die; 11505} 11506 11507/* Generate a DIE to represent either a real live formal parameter decl or to 11508 represent just the type of some formal parameter position in some function 11509 type. 11510 11511 Note that this routine is a bit unusual because its argument may be a 11512 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which 11513 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE 11514 node. If it's the former then this function is being called to output a 11515 DIE to represent a formal parameter object (or some inlining thereof). If 11516 it's the latter, then this function is only being called to output a 11517 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal 11518 argument type of some subprogram type. */ 11519 11520static dw_die_ref 11521gen_formal_parameter_die (tree node, dw_die_ref context_die) 11522{ 11523 dw_die_ref parm_die 11524 = new_die (DW_TAG_formal_parameter, context_die, node); 11525 tree origin; 11526 11527 switch (TREE_CODE_CLASS (TREE_CODE (node))) 11528 { 11529 case tcc_declaration: 11530 origin = decl_ultimate_origin (node); 11531 if (origin != NULL) 11532 add_abstract_origin_attribute (parm_die, origin); 11533 else 11534 { 11535 add_name_and_src_coords_attributes (parm_die, node); 11536 add_type_attribute (parm_die, TREE_TYPE (node), 11537 TREE_READONLY (node), 11538 TREE_THIS_VOLATILE (node), 11539 context_die); 11540 if (DECL_ARTIFICIAL (node)) 11541 add_AT_flag (parm_die, DW_AT_artificial, 1); 11542 } 11543 11544 equate_decl_number_to_die (node, parm_die); 11545 if (! DECL_ABSTRACT (node)) 11546 add_location_or_const_value_attribute (parm_die, node, DW_AT_location); 11547 11548 break; 11549 11550 case tcc_type: 11551 /* We were called with some kind of a ..._TYPE node. */ 11552 add_type_attribute (parm_die, node, 0, 0, context_die); 11553 break; 11554 11555 default: 11556 gcc_unreachable (); 11557 } 11558 11559 return parm_die; 11560} 11561 11562/* Generate a special type of DIE used as a stand-in for a trailing ellipsis 11563 at the end of an (ANSI prototyped) formal parameters list. */ 11564 11565static void 11566gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die) 11567{ 11568 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type); 11569} 11570 11571/* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a 11572 DW_TAG_unspecified_parameters DIE) to represent the types of the formal 11573 parameters as specified in some function type specification (except for 11574 those which appear as part of a function *definition*). */ 11575 11576static void 11577gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die) 11578{ 11579 tree link; 11580 tree formal_type = NULL; 11581 tree first_parm_type; 11582 tree arg; 11583 11584 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL) 11585 { 11586 arg = DECL_ARGUMENTS (function_or_method_type); 11587 function_or_method_type = TREE_TYPE (function_or_method_type); 11588 } 11589 else 11590 arg = NULL_TREE; 11591 11592 first_parm_type = TYPE_ARG_TYPES (function_or_method_type); 11593 11594 /* Make our first pass over the list of formal parameter types and output a 11595 DW_TAG_formal_parameter DIE for each one. */ 11596 for (link = first_parm_type; link; ) 11597 { 11598 dw_die_ref parm_die; 11599 11600 formal_type = TREE_VALUE (link); 11601 if (formal_type == void_type_node) 11602 break; 11603 11604 /* Output a (nameless) DIE to represent the formal parameter itself. */ 11605 parm_die = gen_formal_parameter_die (formal_type, context_die); 11606 if ((TREE_CODE (function_or_method_type) == METHOD_TYPE 11607 && link == first_parm_type) 11608 || (arg && DECL_ARTIFICIAL (arg))) 11609 add_AT_flag (parm_die, DW_AT_artificial, 1); 11610 11611 link = TREE_CHAIN (link); 11612 if (arg) 11613 arg = TREE_CHAIN (arg); 11614 } 11615 11616 /* If this function type has an ellipsis, add a 11617 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */ 11618 if (formal_type != void_type_node) 11619 gen_unspecified_parameters_die (function_or_method_type, context_die); 11620 11621 /* Make our second (and final) pass over the list of formal parameter types 11622 and output DIEs to represent those types (as necessary). */ 11623 for (link = TYPE_ARG_TYPES (function_or_method_type); 11624 link && TREE_VALUE (link); 11625 link = TREE_CHAIN (link)) 11626 gen_type_die (TREE_VALUE (link), context_die); 11627} 11628 11629/* We want to generate the DIE for TYPE so that we can generate the 11630 die for MEMBER, which has been defined; we will need to refer back 11631 to the member declaration nested within TYPE. If we're trying to 11632 generate minimal debug info for TYPE, processing TYPE won't do the 11633 trick; we need to attach the member declaration by hand. */ 11634 11635static void 11636gen_type_die_for_member (tree type, tree member, dw_die_ref context_die) 11637{ 11638 gen_type_die (type, context_die); 11639 11640 /* If we're trying to avoid duplicate debug info, we may not have 11641 emitted the member decl for this function. Emit it now. */ 11642 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type)) 11643 && ! lookup_decl_die (member)) 11644 { 11645 dw_die_ref type_die; 11646 gcc_assert (!decl_ultimate_origin (member)); 11647 11648 push_decl_scope (type); 11649 type_die = lookup_type_die (type); 11650 if (TREE_CODE (member) == FUNCTION_DECL) 11651 gen_subprogram_die (member, type_die); 11652 else if (TREE_CODE (member) == FIELD_DECL) 11653 { 11654 /* Ignore the nameless fields that are used to skip bits but handle 11655 C++ anonymous unions and structs. */ 11656 if (DECL_NAME (member) != NULL_TREE 11657 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE 11658 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE) 11659 { 11660 gen_type_die (member_declared_type (member), type_die); 11661 gen_field_die (member, type_die); 11662 } 11663 } 11664 else 11665 gen_variable_die (member, type_die); 11666 11667 pop_decl_scope (); 11668 } 11669} 11670 11671/* Generate the DWARF2 info for the "abstract" instance of a function which we 11672 may later generate inlined and/or out-of-line instances of. */ 11673 11674static void 11675dwarf2out_abstract_function (tree decl) 11676{ 11677 dw_die_ref old_die; 11678 tree save_fn; 11679 struct function *save_cfun; 11680 tree context; 11681 int was_abstract = DECL_ABSTRACT (decl); 11682 11683 /* Make sure we have the actual abstract inline, not a clone. */ 11684 decl = DECL_ORIGIN (decl); 11685 11686 old_die = lookup_decl_die (decl); 11687 if (old_die && get_AT (old_die, DW_AT_inline)) 11688 /* We've already generated the abstract instance. */ 11689 return; 11690 11691 /* Be sure we've emitted the in-class declaration DIE (if any) first, so 11692 we don't get confused by DECL_ABSTRACT. */ 11693 if (debug_info_level > DINFO_LEVEL_TERSE) 11694 { 11695 context = decl_class_context (decl); 11696 if (context) 11697 gen_type_die_for_member 11698 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die); 11699 } 11700 11701 /* Pretend we've just finished compiling this function. */ 11702 save_fn = current_function_decl; 11703 save_cfun = cfun; 11704 current_function_decl = decl; 11705 cfun = DECL_STRUCT_FUNCTION (decl); 11706 11707 set_decl_abstract_flags (decl, 1); 11708 dwarf2out_decl (decl); 11709 if (! was_abstract) 11710 set_decl_abstract_flags (decl, 0); 11711 11712 current_function_decl = save_fn; 11713 cfun = save_cfun; 11714} 11715 11716/* Helper function of premark_used_types() which gets called through 11717 htab_traverse_resize(). 11718 11719 Marks the DIE of a given type in *SLOT as perennial, so it never gets 11720 marked as unused by prune_unused_types. */ 11721static int 11722premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED) 11723{ 11724 tree type; 11725 dw_die_ref die; 11726 11727 type = *slot; 11728 die = lookup_type_die (type); 11729 if (die != NULL) 11730 die->die_perennial_p = 1; 11731 return 1; 11732} 11733 11734/* Mark all members of used_types_hash as perennial. */ 11735static void 11736premark_used_types (void) 11737{ 11738 if (cfun && cfun->used_types_hash) 11739 htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL); 11740} 11741 11742/* Generate a DIE to represent a declared function (either file-scope or 11743 block-local). */ 11744 11745static void 11746gen_subprogram_die (tree decl, dw_die_ref context_die) 11747{ 11748 char label_id[MAX_ARTIFICIAL_LABEL_BYTES]; 11749 tree origin = decl_ultimate_origin (decl); 11750 dw_die_ref subr_die; 11751 tree fn_arg_types; 11752 tree outer_scope; 11753 dw_die_ref old_die = lookup_decl_die (decl); 11754 int declaration = (current_function_decl != decl 11755 || class_or_namespace_scope_p (context_die)); 11756 11757 premark_used_types (); 11758 11759 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we 11760 started to generate the abstract instance of an inline, decided to output 11761 its containing class, and proceeded to emit the declaration of the inline 11762 from the member list for the class. If so, DECLARATION takes priority; 11763 we'll get back to the abstract instance when done with the class. */ 11764 11765 /* The class-scope declaration DIE must be the primary DIE. */ 11766 if (origin && declaration && class_or_namespace_scope_p (context_die)) 11767 { 11768 origin = NULL; 11769 gcc_assert (!old_die); 11770 } 11771 11772 /* Now that the C++ front end lazily declares artificial member fns, we 11773 might need to retrofit the declaration into its class. */ 11774 if (!declaration && !origin && !old_die 11775 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)) 11776 && !class_or_namespace_scope_p (context_die) 11777 && debug_info_level > DINFO_LEVEL_TERSE) 11778 old_die = force_decl_die (decl); 11779 11780 if (origin != NULL) 11781 { 11782 gcc_assert (!declaration || local_scope_p (context_die)); 11783 11784 /* Fixup die_parent for the abstract instance of a nested 11785 inline function. */ 11786 if (old_die && old_die->die_parent == NULL) 11787 add_child_die (context_die, old_die); 11788 11789 subr_die = new_die (DW_TAG_subprogram, context_die, decl); 11790 add_abstract_origin_attribute (subr_die, origin); 11791 } 11792 else if (old_die) 11793 { 11794 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl)); 11795 struct dwarf_file_data * file_index = lookup_filename (s.file); 11796 11797 if (!get_AT_flag (old_die, DW_AT_declaration) 11798 /* We can have a normal definition following an inline one in the 11799 case of redefinition of GNU C extern inlines. 11800 It seems reasonable to use AT_specification in this case. */ 11801 && !get_AT (old_die, DW_AT_inline)) 11802 { 11803 /* Detect and ignore this case, where we are trying to output 11804 something we have already output. */ 11805 return; 11806 } 11807 11808 /* If the definition comes from the same place as the declaration, 11809 maybe use the old DIE. We always want the DIE for this function 11810 that has the *_pc attributes to be under comp_unit_die so the 11811 debugger can find it. We also need to do this for abstract 11812 instances of inlines, since the spec requires the out-of-line copy 11813 to have the same parent. For local class methods, this doesn't 11814 apply; we just use the old DIE. */ 11815 if ((old_die->die_parent == comp_unit_die || context_die == NULL) 11816 && (DECL_ARTIFICIAL (decl) 11817 || (get_AT_file (old_die, DW_AT_decl_file) == file_index 11818 && (get_AT_unsigned (old_die, DW_AT_decl_line) 11819 == (unsigned) s.line)))) 11820 { 11821 subr_die = old_die; 11822 11823 /* Clear out the declaration attribute and the formal parameters. 11824 Do not remove all children, because it is possible that this 11825 declaration die was forced using force_decl_die(). In such 11826 cases die that forced declaration die (e.g. TAG_imported_module) 11827 is one of the children that we do not want to remove. */ 11828 remove_AT (subr_die, DW_AT_declaration); 11829 remove_child_TAG (subr_die, DW_TAG_formal_parameter); 11830 } 11831 else 11832 { 11833 subr_die = new_die (DW_TAG_subprogram, context_die, decl); 11834 add_AT_specification (subr_die, old_die); 11835 if (get_AT_file (old_die, DW_AT_decl_file) != file_index) 11836 add_AT_file (subr_die, DW_AT_decl_file, file_index); 11837 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line) 11838 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line); 11839 } 11840 } 11841 else 11842 { 11843 subr_die = new_die (DW_TAG_subprogram, context_die, decl); 11844 11845 if (TREE_PUBLIC (decl)) 11846 add_AT_flag (subr_die, DW_AT_external, 1); 11847 11848 add_name_and_src_coords_attributes (subr_die, decl); 11849 if (debug_info_level > DINFO_LEVEL_TERSE) 11850 { 11851 add_prototyped_attribute (subr_die, TREE_TYPE (decl)); 11852 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)), 11853 0, 0, context_die); 11854 } 11855 11856 add_pure_or_virtual_attribute (subr_die, decl); 11857 if (DECL_ARTIFICIAL (decl)) 11858 add_AT_flag (subr_die, DW_AT_artificial, 1); 11859 11860 if (TREE_PROTECTED (decl)) 11861 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected); 11862 else if (TREE_PRIVATE (decl)) 11863 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private); 11864 } 11865 11866 if (declaration) 11867 { 11868 if (!old_die || !get_AT (old_die, DW_AT_inline)) 11869 { 11870 add_AT_flag (subr_die, DW_AT_declaration, 1); 11871 11872 /* The first time we see a member function, it is in the context of 11873 the class to which it belongs. We make sure of this by emitting 11874 the class first. The next time is the definition, which is 11875 handled above. The two may come from the same source text. 11876 11877 Note that force_decl_die() forces function declaration die. It is 11878 later reused to represent definition. */ 11879 equate_decl_number_to_die (decl, subr_die); 11880 } 11881 } 11882 else if (DECL_ABSTRACT (decl)) 11883 { 11884 if (DECL_DECLARED_INLINE_P (decl)) 11885 { 11886 if (cgraph_function_possibly_inlined_p (decl)) 11887 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined); 11888 else 11889 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined); 11890 } 11891 else 11892 { 11893 if (cgraph_function_possibly_inlined_p (decl)) 11894 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined); 11895 else 11896 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined); 11897 } 11898 11899 equate_decl_number_to_die (decl, subr_die); 11900 } 11901 else if (!DECL_EXTERNAL (decl)) 11902 { 11903 HOST_WIDE_INT cfa_fb_offset; 11904 11905 if (!old_die || !get_AT (old_die, DW_AT_inline)) 11906 equate_decl_number_to_die (decl, subr_die); 11907 11908 if (!flag_reorder_blocks_and_partition) 11909 { 11910 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL, 11911 current_function_funcdef_no); 11912 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id); 11913 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL, 11914 current_function_funcdef_no); 11915 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id); 11916 11917 add_pubname (decl, subr_die); 11918 add_arange (decl, subr_die); 11919 } 11920 else 11921 { /* Do nothing for now; maybe need to duplicate die, one for 11922 hot section and ond for cold section, then use the hot/cold 11923 section begin/end labels to generate the aranges... */ 11924 /* 11925 add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label); 11926 add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label); 11927 add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label); 11928 add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label); 11929 11930 add_pubname (decl, subr_die); 11931 add_arange (decl, subr_die); 11932 add_arange (decl, subr_die); 11933 */ 11934 } 11935 11936#ifdef MIPS_DEBUGGING_INFO 11937 /* Add a reference to the FDE for this routine. */ 11938 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde); 11939#endif 11940 11941 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl); 11942 11943 /* We define the "frame base" as the function's CFA. This is more 11944 convenient for several reasons: (1) It's stable across the prologue 11945 and epilogue, which makes it better than just a frame pointer, 11946 (2) With dwarf3, there exists a one-byte encoding that allows us 11947 to reference the .debug_frame data by proxy, but failing that, 11948 (3) We can at least reuse the code inspection and interpretation 11949 code that determines the CFA position at various points in the 11950 function. */ 11951 /* ??? Use some command-line or configury switch to enable the use 11952 of dwarf3 DW_OP_call_frame_cfa. At present there are no dwarf 11953 consumers that understand it; fall back to "pure" dwarf2 and 11954 convert the CFA data into a location list. */ 11955 { 11956 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset); 11957 if (list->dw_loc_next) 11958 add_AT_loc_list (subr_die, DW_AT_frame_base, list); 11959 else 11960 add_AT_loc (subr_die, DW_AT_frame_base, list->expr); 11961 } 11962 11963 /* Compute a displacement from the "steady-state frame pointer" to 11964 the CFA. The former is what all stack slots and argument slots 11965 will reference in the rtl; the later is what we've told the 11966 debugger about. We'll need to adjust all frame_base references 11967 by this displacement. */ 11968 compute_frame_pointer_to_fb_displacement (cfa_fb_offset); 11969 11970 if (cfun->static_chain_decl) 11971 add_AT_location_description (subr_die, DW_AT_static_link, 11972 loc_descriptor_from_tree (cfun->static_chain_decl)); 11973 } 11974 11975 /* Now output descriptions of the arguments for this function. This gets 11976 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list 11977 for a FUNCTION_DECL doesn't indicate cases where there was a trailing 11978 `...' at the end of the formal parameter list. In order to find out if 11979 there was a trailing ellipsis or not, we must instead look at the type 11980 associated with the FUNCTION_DECL. This will be a node of type 11981 FUNCTION_TYPE. If the chain of type nodes hanging off of this 11982 FUNCTION_TYPE node ends with a void_type_node then there should *not* be 11983 an ellipsis at the end. */ 11984 11985 /* In the case where we are describing a mere function declaration, all we 11986 need to do here (and all we *can* do here) is to describe the *types* of 11987 its formal parameters. */ 11988 if (debug_info_level <= DINFO_LEVEL_TERSE) 11989 ; 11990 else if (declaration) 11991 gen_formal_types_die (decl, subr_die); 11992 else 11993 { 11994 /* Generate DIEs to represent all known formal parameters. */ 11995 tree arg_decls = DECL_ARGUMENTS (decl); 11996 tree parm; 11997 11998 /* When generating DIEs, generate the unspecified_parameters DIE 11999 instead if we come across the arg "__builtin_va_alist" */ 12000 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm)) 12001 if (TREE_CODE (parm) == PARM_DECL) 12002 { 12003 if (DECL_NAME (parm) 12004 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)), 12005 "__builtin_va_alist")) 12006 gen_unspecified_parameters_die (parm, subr_die); 12007 else 12008 gen_decl_die (parm, subr_die); 12009 } 12010 12011 /* Decide whether we need an unspecified_parameters DIE at the end. 12012 There are 2 more cases to do this for: 1) the ansi ... declaration - 12013 this is detectable when the end of the arg list is not a 12014 void_type_node 2) an unprototyped function declaration (not a 12015 definition). This just means that we have no info about the 12016 parameters at all. */ 12017 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl)); 12018 if (fn_arg_types != NULL) 12019 { 12020 /* This is the prototyped case, check for.... */ 12021 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node) 12022 gen_unspecified_parameters_die (decl, subr_die); 12023 } 12024 else if (DECL_INITIAL (decl) == NULL_TREE) 12025 gen_unspecified_parameters_die (decl, subr_die); 12026 } 12027 12028 /* Output Dwarf info for all of the stuff within the body of the function 12029 (if it has one - it may be just a declaration). */ 12030 outer_scope = DECL_INITIAL (decl); 12031 12032 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent 12033 a function. This BLOCK actually represents the outermost binding contour 12034 for the function, i.e. the contour in which the function's formal 12035 parameters and labels get declared. Curiously, it appears that the front 12036 end doesn't actually put the PARM_DECL nodes for the current function onto 12037 the BLOCK_VARS list for this outer scope, but are strung off of the 12038 DECL_ARGUMENTS list for the function instead. 12039 12040 The BLOCK_VARS list for the `outer_scope' does provide us with a list of 12041 the LABEL_DECL nodes for the function however, and we output DWARF info 12042 for those in decls_for_scope. Just within the `outer_scope' there will be 12043 a BLOCK node representing the function's outermost pair of curly braces, 12044 and any blocks used for the base and member initializers of a C++ 12045 constructor function. */ 12046 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK) 12047 { 12048 /* Emit a DW_TAG_variable DIE for a named return value. */ 12049 if (DECL_NAME (DECL_RESULT (decl))) 12050 gen_decl_die (DECL_RESULT (decl), subr_die); 12051 12052 current_function_has_inlines = 0; 12053 decls_for_scope (outer_scope, subr_die, 0); 12054 12055#if 0 && defined (MIPS_DEBUGGING_INFO) 12056 if (current_function_has_inlines) 12057 { 12058 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1); 12059 if (! comp_unit_has_inlines) 12060 { 12061 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1); 12062 comp_unit_has_inlines = 1; 12063 } 12064 } 12065#endif 12066 } 12067 /* Add the calling convention attribute if requested. */ 12068 add_calling_convention_attribute (subr_die, TREE_TYPE (decl)); 12069 12070} 12071 12072/* Generate a DIE to represent a declared data object. */ 12073 12074static void 12075gen_variable_die (tree decl, dw_die_ref context_die) 12076{ 12077 tree origin = decl_ultimate_origin (decl); 12078 dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl); 12079 12080 dw_die_ref old_die = lookup_decl_die (decl); 12081 int declaration = (DECL_EXTERNAL (decl) 12082 /* If DECL is COMDAT and has not actually been 12083 emitted, we cannot take its address; there 12084 might end up being no definition anywhere in 12085 the program. For example, consider the C++ 12086 test case: 12087 12088 template <class T> 12089 struct S { static const int i = 7; }; 12090 12091 template <class T> 12092 const int S<T>::i; 12093 12094 int f() { return S<int>::i; } 12095 12096 Here, S<int>::i is not DECL_EXTERNAL, but no 12097 definition is required, so the compiler will 12098 not emit a definition. */ 12099 || (TREE_CODE (decl) == VAR_DECL 12100 && DECL_COMDAT (decl) && !TREE_ASM_WRITTEN (decl)) 12101 || class_or_namespace_scope_p (context_die)); 12102 12103 if (origin != NULL) 12104 add_abstract_origin_attribute (var_die, origin); 12105 12106 /* Loop unrolling can create multiple blocks that refer to the same 12107 static variable, so we must test for the DW_AT_declaration flag. 12108 12109 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to 12110 copy decls and set the DECL_ABSTRACT flag on them instead of 12111 sharing them. 12112 12113 ??? Duplicated blocks have been rewritten to use .debug_ranges. 12114 12115 ??? The declare_in_namespace support causes us to get two DIEs for one 12116 variable, both of which are declarations. We want to avoid considering 12117 one to be a specification, so we must test that this DIE is not a 12118 declaration. */ 12119 else if (old_die && TREE_STATIC (decl) && ! declaration 12120 && get_AT_flag (old_die, DW_AT_declaration) == 1) 12121 { 12122 /* This is a definition of a C++ class level static. */ 12123 add_AT_specification (var_die, old_die); 12124 if (DECL_NAME (decl)) 12125 { 12126 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl)); 12127 struct dwarf_file_data * file_index = lookup_filename (s.file); 12128 12129 if (get_AT_file (old_die, DW_AT_decl_file) != file_index) 12130 add_AT_file (var_die, DW_AT_decl_file, file_index); 12131 12132 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line) 12133 12134 add_AT_unsigned (var_die, DW_AT_decl_line, s.line); 12135 } 12136 } 12137 else 12138 { 12139 add_name_and_src_coords_attributes (var_die, decl); 12140 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl), 12141 TREE_THIS_VOLATILE (decl), context_die); 12142 12143 if (TREE_PUBLIC (decl)) 12144 add_AT_flag (var_die, DW_AT_external, 1); 12145 12146 if (DECL_ARTIFICIAL (decl)) 12147 add_AT_flag (var_die, DW_AT_artificial, 1); 12148 12149 if (TREE_PROTECTED (decl)) 12150 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected); 12151 else if (TREE_PRIVATE (decl)) 12152 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private); 12153 } 12154 12155 if (declaration) 12156 add_AT_flag (var_die, DW_AT_declaration, 1); 12157 12158 if (DECL_ABSTRACT (decl) || declaration) 12159 equate_decl_number_to_die (decl, var_die); 12160 12161 if (! declaration && ! DECL_ABSTRACT (decl)) 12162 { 12163 add_location_or_const_value_attribute (var_die, decl, DW_AT_location); 12164 add_pubname (decl, var_die); 12165 } 12166 else 12167 tree_add_const_value_attribute (var_die, decl); 12168} 12169 12170/* Generate a DIE to represent a label identifier. */ 12171 12172static void 12173gen_label_die (tree decl, dw_die_ref context_die) 12174{ 12175 tree origin = decl_ultimate_origin (decl); 12176 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl); 12177 rtx insn; 12178 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 12179 12180 if (origin != NULL) 12181 add_abstract_origin_attribute (lbl_die, origin); 12182 else 12183 add_name_and_src_coords_attributes (lbl_die, decl); 12184 12185 if (DECL_ABSTRACT (decl)) 12186 equate_decl_number_to_die (decl, lbl_die); 12187 else 12188 { 12189 insn = DECL_RTL_IF_SET (decl); 12190 12191 /* Deleted labels are programmer specified labels which have been 12192 eliminated because of various optimizations. We still emit them 12193 here so that it is possible to put breakpoints on them. */ 12194 if (insn 12195 && (LABEL_P (insn) 12196 || ((NOTE_P (insn) 12197 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL)))) 12198 { 12199 /* When optimization is enabled (via -O) some parts of the compiler 12200 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which 12201 represent source-level labels which were explicitly declared by 12202 the user. This really shouldn't be happening though, so catch 12203 it if it ever does happen. */ 12204 gcc_assert (!INSN_DELETED_P (insn)); 12205 12206 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn)); 12207 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label); 12208 } 12209 } 12210} 12211 12212/* A helper function for gen_inlined_subroutine_die. Add source coordinate 12213 attributes to the DIE for a block STMT, to describe where the inlined 12214 function was called from. This is similar to add_src_coords_attributes. */ 12215 12216static inline void 12217add_call_src_coords_attributes (tree stmt, dw_die_ref die) 12218{ 12219 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt)); 12220 12221 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file)); 12222 add_AT_unsigned (die, DW_AT_call_line, s.line); 12223} 12224 12225/* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die. 12226 Add low_pc and high_pc attributes to the DIE for a block STMT. */ 12227 12228static inline void 12229add_high_low_attributes (tree stmt, dw_die_ref die) 12230{ 12231 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 12232 12233 if (BLOCK_FRAGMENT_CHAIN (stmt)) 12234 { 12235 tree chain; 12236 12237 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt)); 12238 12239 chain = BLOCK_FRAGMENT_CHAIN (stmt); 12240 do 12241 { 12242 add_ranges (chain); 12243 chain = BLOCK_FRAGMENT_CHAIN (chain); 12244 } 12245 while (chain); 12246 add_ranges (NULL); 12247 } 12248 else 12249 { 12250 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL, 12251 BLOCK_NUMBER (stmt)); 12252 add_AT_lbl_id (die, DW_AT_low_pc, label); 12253 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, 12254 BLOCK_NUMBER (stmt)); 12255 add_AT_lbl_id (die, DW_AT_high_pc, label); 12256 } 12257} 12258 12259/* Generate a DIE for a lexical block. */ 12260 12261static void 12262gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth) 12263{ 12264 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt); 12265 12266 if (! BLOCK_ABSTRACT (stmt)) 12267 add_high_low_attributes (stmt, stmt_die); 12268 12269 decls_for_scope (stmt, stmt_die, depth); 12270} 12271 12272/* Generate a DIE for an inlined subprogram. */ 12273 12274static void 12275gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth) 12276{ 12277 tree decl = block_ultimate_origin (stmt); 12278 12279 /* Emit info for the abstract instance first, if we haven't yet. We 12280 must emit this even if the block is abstract, otherwise when we 12281 emit the block below (or elsewhere), we may end up trying to emit 12282 a die whose origin die hasn't been emitted, and crashing. */ 12283 dwarf2out_abstract_function (decl); 12284 12285 if (! BLOCK_ABSTRACT (stmt)) 12286 { 12287 dw_die_ref subr_die 12288 = new_die (DW_TAG_inlined_subroutine, context_die, stmt); 12289 12290 add_abstract_origin_attribute (subr_die, decl); 12291 add_high_low_attributes (stmt, subr_die); 12292 add_call_src_coords_attributes (stmt, subr_die); 12293 12294 decls_for_scope (stmt, subr_die, depth); 12295 current_function_has_inlines = 1; 12296 } 12297 else 12298 /* We may get here if we're the outer block of function A that was 12299 inlined into function B that was inlined into function C. When 12300 generating debugging info for C, dwarf2out_abstract_function(B) 12301 would mark all inlined blocks as abstract, including this one. 12302 So, we wouldn't (and shouldn't) expect labels to be generated 12303 for this one. Instead, just emit debugging info for 12304 declarations within the block. This is particularly important 12305 in the case of initializers of arguments passed from B to us: 12306 if they're statement expressions containing declarations, we 12307 wouldn't generate dies for their abstract variables, and then, 12308 when generating dies for the real variables, we'd die (pun 12309 intended :-) */ 12310 gen_lexical_block_die (stmt, context_die, depth); 12311} 12312 12313/* Generate a DIE for a field in a record, or structure. */ 12314 12315static void 12316gen_field_die (tree decl, dw_die_ref context_die) 12317{ 12318 dw_die_ref decl_die; 12319 12320 if (TREE_TYPE (decl) == error_mark_node) 12321 return; 12322 12323 decl_die = new_die (DW_TAG_member, context_die, decl); 12324 add_name_and_src_coords_attributes (decl_die, decl); 12325 add_type_attribute (decl_die, member_declared_type (decl), 12326 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl), 12327 context_die); 12328 12329 if (DECL_BIT_FIELD_TYPE (decl)) 12330 { 12331 add_byte_size_attribute (decl_die, decl); 12332 add_bit_size_attribute (decl_die, decl); 12333 add_bit_offset_attribute (decl_die, decl); 12334 } 12335 12336 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE) 12337 add_data_member_location_attribute (decl_die, decl); 12338 12339 if (DECL_ARTIFICIAL (decl)) 12340 add_AT_flag (decl_die, DW_AT_artificial, 1); 12341 12342 if (TREE_PROTECTED (decl)) 12343 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected); 12344 else if (TREE_PRIVATE (decl)) 12345 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private); 12346 12347 /* Equate decl number to die, so that we can look up this decl later on. */ 12348 equate_decl_number_to_die (decl, decl_die); 12349} 12350 12351#if 0 12352/* Don't generate either pointer_type DIEs or reference_type DIEs here. 12353 Use modified_type_die instead. 12354 We keep this code here just in case these types of DIEs may be needed to 12355 represent certain things in other languages (e.g. Pascal) someday. */ 12356 12357static void 12358gen_pointer_type_die (tree type, dw_die_ref context_die) 12359{ 12360 dw_die_ref ptr_die 12361 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type); 12362 12363 equate_type_number_to_die (type, ptr_die); 12364 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die); 12365 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); 12366} 12367 12368/* Don't generate either pointer_type DIEs or reference_type DIEs here. 12369 Use modified_type_die instead. 12370 We keep this code here just in case these types of DIEs may be needed to 12371 represent certain things in other languages (e.g. Pascal) someday. */ 12372 12373static void 12374gen_reference_type_die (tree type, dw_die_ref context_die) 12375{ 12376 dw_die_ref ref_die 12377 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type); 12378 12379 equate_type_number_to_die (type, ref_die); 12380 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die); 12381 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); 12382} 12383#endif 12384 12385/* Generate a DIE for a pointer to a member type. */ 12386 12387static void 12388gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die) 12389{ 12390 dw_die_ref ptr_die 12391 = new_die (DW_TAG_ptr_to_member_type, 12392 scope_die_for (type, context_die), type); 12393 12394 equate_type_number_to_die (type, ptr_die); 12395 add_AT_die_ref (ptr_die, DW_AT_containing_type, 12396 lookup_type_die (TYPE_OFFSET_BASETYPE (type))); 12397 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die); 12398} 12399 12400/* Generate the DIE for the compilation unit. */ 12401 12402static dw_die_ref 12403gen_compile_unit_die (const char *filename) 12404{ 12405 dw_die_ref die; 12406 char producer[250]; 12407 const char *language_string = lang_hooks.name; 12408 int language; 12409 12410 die = new_die (DW_TAG_compile_unit, NULL, NULL); 12411 12412 if (filename) 12413 { 12414 add_name_attribute (die, filename); 12415 /* Don't add cwd for <built-in>. */ 12416 if (filename[0] != DIR_SEPARATOR && filename[0] != '<') 12417 add_comp_dir_attribute (die); 12418 } 12419 12420 sprintf (producer, "%s %s", language_string, version_string); 12421 12422#ifdef MIPS_DEBUGGING_INFO 12423 /* The MIPS/SGI compilers place the 'cc' command line options in the producer 12424 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do 12425 not appear in the producer string, the debugger reaches the conclusion 12426 that the object file is stripped and has no debugging information. 12427 To get the MIPS/SGI debugger to believe that there is debugging 12428 information in the object file, we add a -g to the producer string. */ 12429 if (debug_info_level > DINFO_LEVEL_TERSE) 12430 strcat (producer, " -g"); 12431#endif 12432 12433 add_AT_string (die, DW_AT_producer, producer); 12434 12435 if (strcmp (language_string, "GNU C++") == 0) 12436 language = DW_LANG_C_plus_plus; 12437 else if (strcmp (language_string, "GNU Ada") == 0) 12438 language = DW_LANG_Ada95; 12439 else if (strcmp (language_string, "GNU F77") == 0) 12440 language = DW_LANG_Fortran77; 12441 else if (strcmp (language_string, "GNU F95") == 0) 12442 language = DW_LANG_Fortran95; 12443 else if (strcmp (language_string, "GNU Pascal") == 0) 12444 language = DW_LANG_Pascal83; 12445 else if (strcmp (language_string, "GNU Java") == 0) 12446 language = DW_LANG_Java; 12447 else if (strcmp (language_string, "GNU Objective-C") == 0) 12448 language = DW_LANG_ObjC; 12449 else if (strcmp (language_string, "GNU Objective-C++") == 0) 12450 language = DW_LANG_ObjC_plus_plus; 12451 else 12452 language = DW_LANG_C89; 12453 12454 add_AT_unsigned (die, DW_AT_language, language); 12455 return die; 12456} 12457 12458/* Generate the DIE for a base class. */ 12459 12460static void 12461gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die) 12462{ 12463 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo); 12464 12465 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die); 12466 add_data_member_location_attribute (die, binfo); 12467 12468 if (BINFO_VIRTUAL_P (binfo)) 12469 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual); 12470 12471 if (access == access_public_node) 12472 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public); 12473 else if (access == access_protected_node) 12474 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected); 12475} 12476 12477/* Generate a DIE for a class member. */ 12478 12479static void 12480gen_member_die (tree type, dw_die_ref context_die) 12481{ 12482 tree member; 12483 tree binfo = TYPE_BINFO (type); 12484 dw_die_ref child; 12485 12486 /* If this is not an incomplete type, output descriptions of each of its 12487 members. Note that as we output the DIEs necessary to represent the 12488 members of this record or union type, we will also be trying to output 12489 DIEs to represent the *types* of those members. However the `type' 12490 function (above) will specifically avoid generating type DIEs for member 12491 types *within* the list of member DIEs for this (containing) type except 12492 for those types (of members) which are explicitly marked as also being 12493 members of this (containing) type themselves. The g++ front- end can 12494 force any given type to be treated as a member of some other (containing) 12495 type by setting the TYPE_CONTEXT of the given (member) type to point to 12496 the TREE node representing the appropriate (containing) type. */ 12497 12498 /* First output info about the base classes. */ 12499 if (binfo) 12500 { 12501 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo); 12502 int i; 12503 tree base; 12504 12505 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++) 12506 gen_inheritance_die (base, 12507 (accesses ? VEC_index (tree, accesses, i) 12508 : access_public_node), context_die); 12509 } 12510 12511 /* Now output info about the data members and type members. */ 12512 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member)) 12513 { 12514 /* If we thought we were generating minimal debug info for TYPE 12515 and then changed our minds, some of the member declarations 12516 may have already been defined. Don't define them again, but 12517 do put them in the right order. */ 12518 12519 child = lookup_decl_die (member); 12520 if (child) 12521 splice_child_die (context_die, child); 12522 else 12523 gen_decl_die (member, context_die); 12524 } 12525 12526 /* Now output info about the function members (if any). */ 12527 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member)) 12528 { 12529 /* Don't include clones in the member list. */ 12530 if (DECL_ABSTRACT_ORIGIN (member)) 12531 continue; 12532 12533 child = lookup_decl_die (member); 12534 if (child) 12535 splice_child_die (context_die, child); 12536 else 12537 gen_decl_die (member, context_die); 12538 } 12539} 12540 12541/* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG 12542 is set, we pretend that the type was never defined, so we only get the 12543 member DIEs needed by later specification DIEs. */ 12544 12545static void 12546gen_struct_or_union_type_die (tree type, dw_die_ref context_die, 12547 enum debug_info_usage usage) 12548{ 12549 dw_die_ref type_die = lookup_type_die (type); 12550 dw_die_ref scope_die = 0; 12551 int nested = 0; 12552 int complete = (TYPE_SIZE (type) 12553 && (! TYPE_STUB_DECL (type) 12554 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type)))); 12555 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace); 12556 complete = complete && should_emit_struct_debug (type, usage); 12557 12558 if (type_die && ! complete) 12559 return; 12560 12561 if (TYPE_CONTEXT (type) != NULL_TREE 12562 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type)) 12563 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL)) 12564 nested = 1; 12565 12566 scope_die = scope_die_for (type, context_die); 12567 12568 if (! type_die || (nested && scope_die == comp_unit_die)) 12569 /* First occurrence of type or toplevel definition of nested class. */ 12570 { 12571 dw_die_ref old_die = type_die; 12572 12573 type_die = new_die (TREE_CODE (type) == RECORD_TYPE 12574 ? DW_TAG_structure_type : DW_TAG_union_type, 12575 scope_die, type); 12576 equate_type_number_to_die (type, type_die); 12577 if (old_die) 12578 add_AT_specification (type_die, old_die); 12579 else 12580 add_name_attribute (type_die, type_tag (type)); 12581 /* APPLE LOCAL begin radar 5811943 - Fix type of pointers to Blocks */ 12582 if (TYPE_BLOCK_IMPL_STRUCT (type)) 12583 add_AT_flag (type_die, DW_AT_APPLE_block, 1); 12584 /* APPLE LOCAL end radar 5811943 - Fix type of pointers to Blocks */ 12585 } 12586 else 12587 remove_AT (type_die, DW_AT_declaration); 12588 12589 /* If this type has been completed, then give it a byte_size attribute and 12590 then give a list of members. */ 12591 if (complete && !ns_decl) 12592 { 12593 /* Prevent infinite recursion in cases where the type of some member of 12594 this type is expressed in terms of this type itself. */ 12595 TREE_ASM_WRITTEN (type) = 1; 12596 add_byte_size_attribute (type_die, type); 12597 if (TYPE_STUB_DECL (type) != NULL_TREE) 12598 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type)); 12599 12600 /* If the first reference to this type was as the return type of an 12601 inline function, then it may not have a parent. Fix this now. */ 12602 if (type_die->die_parent == NULL) 12603 add_child_die (scope_die, type_die); 12604 12605 push_decl_scope (type); 12606 gen_member_die (type, type_die); 12607 pop_decl_scope (); 12608 12609 /* GNU extension: Record what type our vtable lives in. */ 12610 if (TYPE_VFIELD (type)) 12611 { 12612 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type)); 12613 12614 gen_type_die (vtype, context_die); 12615 add_AT_die_ref (type_die, DW_AT_containing_type, 12616 lookup_type_die (vtype)); 12617 } 12618 } 12619 else 12620 { 12621 add_AT_flag (type_die, DW_AT_declaration, 1); 12622 12623 /* We don't need to do this for function-local types. */ 12624 if (TYPE_STUB_DECL (type) 12625 && ! decl_function_context (TYPE_STUB_DECL (type))) 12626 VEC_safe_push (tree, gc, incomplete_types, type); 12627 } 12628 12629 if (get_AT (type_die, DW_AT_name)) 12630 add_pubtype (type, type_die); 12631} 12632 12633/* Generate a DIE for a subroutine _type_. */ 12634 12635static void 12636gen_subroutine_type_die (tree type, dw_die_ref context_die) 12637{ 12638 tree return_type = TREE_TYPE (type); 12639 dw_die_ref subr_die 12640 = new_die (DW_TAG_subroutine_type, 12641 scope_die_for (type, context_die), type); 12642 12643 equate_type_number_to_die (type, subr_die); 12644 add_prototyped_attribute (subr_die, type); 12645 add_type_attribute (subr_die, return_type, 0, 0, context_die); 12646 gen_formal_types_die (type, subr_die); 12647 12648 if (get_AT (subr_die, DW_AT_name)) 12649 add_pubtype (type, subr_die); 12650} 12651 12652/* Generate a DIE for a type definition. */ 12653 12654static void 12655gen_typedef_die (tree decl, dw_die_ref context_die) 12656{ 12657 dw_die_ref type_die; 12658 tree origin; 12659 12660 if (TREE_ASM_WRITTEN (decl)) 12661 return; 12662 12663 TREE_ASM_WRITTEN (decl) = 1; 12664 type_die = new_die (DW_TAG_typedef, context_die, decl); 12665 origin = decl_ultimate_origin (decl); 12666 if (origin != NULL) 12667 add_abstract_origin_attribute (type_die, origin); 12668 else 12669 { 12670 tree type; 12671 12672 add_name_and_src_coords_attributes (type_die, decl); 12673 if (DECL_ORIGINAL_TYPE (decl)) 12674 { 12675 type = DECL_ORIGINAL_TYPE (decl); 12676 12677 gcc_assert (type != TREE_TYPE (decl)); 12678 equate_type_number_to_die (TREE_TYPE (decl), type_die); 12679 } 12680 else 12681 type = TREE_TYPE (decl); 12682 12683 add_type_attribute (type_die, type, TREE_READONLY (decl), 12684 TREE_THIS_VOLATILE (decl), context_die); 12685 } 12686 12687 if (DECL_ABSTRACT (decl)) 12688 equate_decl_number_to_die (decl, type_die); 12689 12690 if (get_AT (type_die, DW_AT_name)) 12691 add_pubtype (decl, type_die); 12692} 12693 12694/* Generate a type description DIE. */ 12695 12696static void 12697gen_type_die_with_usage (tree type, dw_die_ref context_die, 12698 enum debug_info_usage usage) 12699{ 12700 int need_pop; 12701 12702 if (type == NULL_TREE || type == error_mark_node) 12703 return; 12704 12705 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 12706 && DECL_ORIGINAL_TYPE (TYPE_NAME (type))) 12707 { 12708 if (TREE_ASM_WRITTEN (type)) 12709 return; 12710 12711 /* Prevent broken recursion; we can't hand off to the same type. */ 12712 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type); 12713 12714 TREE_ASM_WRITTEN (type) = 1; 12715 gen_decl_die (TYPE_NAME (type), context_die); 12716 return; 12717 } 12718 12719 /* We are going to output a DIE to represent the unqualified version 12720 of this type (i.e. without any const or volatile qualifiers) so 12721 get the main variant (i.e. the unqualified version) of this type 12722 now. (Vectors are special because the debugging info is in the 12723 cloned type itself). */ 12724 if (TREE_CODE (type) != VECTOR_TYPE) 12725 type = type_main_variant (type); 12726 12727 if (TREE_ASM_WRITTEN (type)) 12728 return; 12729 12730 switch (TREE_CODE (type)) 12731 { 12732 case ERROR_MARK: 12733 break; 12734 /* APPLE LOCAL radar 5732232 - blocks */ 12735 case BLOCK_POINTER_TYPE: 12736 case POINTER_TYPE: 12737 case REFERENCE_TYPE: 12738 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This 12739 ensures that the gen_type_die recursion will terminate even if the 12740 type is recursive. Recursive types are possible in Ada. */ 12741 /* ??? We could perhaps do this for all types before the switch 12742 statement. */ 12743 TREE_ASM_WRITTEN (type) = 1; 12744 12745 /* For these types, all that is required is that we output a DIE (or a 12746 set of DIEs) to represent the "basis" type. */ 12747 gen_type_die_with_usage (TREE_TYPE (type), context_die, 12748 DINFO_USAGE_IND_USE); 12749 break; 12750 12751 case OFFSET_TYPE: 12752 /* This code is used for C++ pointer-to-data-member types. 12753 Output a description of the relevant class type. */ 12754 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die, 12755 DINFO_USAGE_IND_USE); 12756 12757 /* Output a description of the type of the object pointed to. */ 12758 gen_type_die_with_usage (TREE_TYPE (type), context_die, 12759 DINFO_USAGE_IND_USE); 12760 12761 /* Now output a DIE to represent this pointer-to-data-member type 12762 itself. */ 12763 gen_ptr_to_mbr_type_die (type, context_die); 12764 break; 12765 12766 case FUNCTION_TYPE: 12767 /* Force out return type (in case it wasn't forced out already). */ 12768 gen_type_die_with_usage (TREE_TYPE (type), context_die, 12769 DINFO_USAGE_DIR_USE); 12770 gen_subroutine_type_die (type, context_die); 12771 break; 12772 12773 case METHOD_TYPE: 12774 /* Force out return type (in case it wasn't forced out already). */ 12775 gen_type_die_with_usage (TREE_TYPE (type), context_die, 12776 DINFO_USAGE_DIR_USE); 12777 gen_subroutine_type_die (type, context_die); 12778 break; 12779 12780 case ARRAY_TYPE: 12781 gen_array_type_die (type, context_die); 12782 break; 12783 12784 case VECTOR_TYPE: 12785 gen_array_type_die (type, context_die); 12786 break; 12787 12788 case ENUMERAL_TYPE: 12789 case RECORD_TYPE: 12790 case UNION_TYPE: 12791 case QUAL_UNION_TYPE: 12792 /* If this is a nested type whose containing class hasn't been written 12793 out yet, writing it out will cover this one, too. This does not apply 12794 to instantiations of member class templates; they need to be added to 12795 the containing class as they are generated. FIXME: This hurts the 12796 idea of combining type decls from multiple TUs, since we can't predict 12797 what set of template instantiations we'll get. */ 12798 if (TYPE_CONTEXT (type) 12799 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)) 12800 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type))) 12801 { 12802 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage); 12803 12804 if (TREE_ASM_WRITTEN (type)) 12805 return; 12806 12807 /* If that failed, attach ourselves to the stub. */ 12808 push_decl_scope (TYPE_CONTEXT (type)); 12809 context_die = lookup_type_die (TYPE_CONTEXT (type)); 12810 need_pop = 1; 12811 } 12812 else 12813 { 12814 declare_in_namespace (type, context_die); 12815 need_pop = 0; 12816 } 12817 12818 if (TREE_CODE (type) == ENUMERAL_TYPE) 12819 { 12820 /* This might have been written out by the call to 12821 declare_in_namespace. */ 12822 if (!TREE_ASM_WRITTEN (type)) 12823 gen_enumeration_type_die (type, context_die); 12824 } 12825 else 12826 gen_struct_or_union_type_die (type, context_die, usage); 12827 12828 if (need_pop) 12829 pop_decl_scope (); 12830 12831 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix 12832 it up if it is ever completed. gen_*_type_die will set it for us 12833 when appropriate. */ 12834 return; 12835 12836 case VOID_TYPE: 12837 case INTEGER_TYPE: 12838 case REAL_TYPE: 12839 case COMPLEX_TYPE: 12840 case BOOLEAN_TYPE: 12841 /* No DIEs needed for fundamental types. */ 12842 break; 12843 12844 case LANG_TYPE: 12845 /* No Dwarf representation currently defined. */ 12846 break; 12847 12848 default: 12849 gcc_unreachable (); 12850 } 12851 12852 TREE_ASM_WRITTEN (type) = 1; 12853} 12854 12855static void 12856gen_type_die (tree type, dw_die_ref context_die) 12857{ 12858 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE); 12859} 12860 12861/* Generate a DIE for a tagged type instantiation. */ 12862 12863static void 12864gen_tagged_type_instantiation_die (tree type, dw_die_ref context_die) 12865{ 12866 if (type == NULL_TREE || type == error_mark_node) 12867 return; 12868 12869 /* We are going to output a DIE to represent the unqualified version of 12870 this type (i.e. without any const or volatile qualifiers) so make sure 12871 that we have the main variant (i.e. the unqualified version) of this 12872 type now. */ 12873 gcc_assert (type == type_main_variant (type)); 12874 12875 /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is 12876 an instance of an unresolved type. */ 12877 12878 switch (TREE_CODE (type)) 12879 { 12880 case ERROR_MARK: 12881 break; 12882 12883 case ENUMERAL_TYPE: 12884 gen_inlined_enumeration_type_die (type, context_die); 12885 break; 12886 12887 case RECORD_TYPE: 12888 gen_inlined_structure_type_die (type, context_die); 12889 break; 12890 12891 case UNION_TYPE: 12892 case QUAL_UNION_TYPE: 12893 gen_inlined_union_type_die (type, context_die); 12894 break; 12895 12896 default: 12897 gcc_unreachable (); 12898 } 12899} 12900 12901/* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the 12902 things which are local to the given block. */ 12903 12904static void 12905gen_block_die (tree stmt, dw_die_ref context_die, int depth) 12906{ 12907 int must_output_die = 0; 12908 tree origin; 12909 tree decl; 12910 enum tree_code origin_code; 12911 12912 /* Ignore blocks that are NULL. */ 12913 if (stmt == NULL_TREE) 12914 return; 12915 12916 /* If the block is one fragment of a non-contiguous block, do not 12917 process the variables, since they will have been done by the 12918 origin block. Do process subblocks. */ 12919 if (BLOCK_FRAGMENT_ORIGIN (stmt)) 12920 { 12921 tree sub; 12922 12923 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub)) 12924 gen_block_die (sub, context_die, depth + 1); 12925 12926 return; 12927 } 12928 12929 /* Determine the "ultimate origin" of this block. This block may be an 12930 inlined instance of an inlined instance of inline function, so we have 12931 to trace all of the way back through the origin chain to find out what 12932 sort of node actually served as the original seed for the creation of 12933 the current block. */ 12934 origin = block_ultimate_origin (stmt); 12935 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK; 12936 12937 /* Determine if we need to output any Dwarf DIEs at all to represent this 12938 block. */ 12939 if (origin_code == FUNCTION_DECL) 12940 /* The outer scopes for inlinings *must* always be represented. We 12941 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */ 12942 must_output_die = 1; 12943 else 12944 { 12945 /* In the case where the current block represents an inlining of the 12946 "body block" of an inline function, we must *NOT* output any DIE for 12947 this block because we have already output a DIE to represent the whole 12948 inlined function scope and the "body block" of any function doesn't 12949 really represent a different scope according to ANSI C rules. So we 12950 check here to make sure that this block does not represent a "body 12951 block inlining" before trying to set the MUST_OUTPUT_DIE flag. */ 12952 if (! is_body_block (origin ? origin : stmt)) 12953 { 12954 /* Determine if this block directly contains any "significant" 12955 local declarations which we will need to output DIEs for. */ 12956 if (debug_info_level > DINFO_LEVEL_TERSE) 12957 /* We are not in terse mode so *any* local declaration counts 12958 as being a "significant" one. */ 12959 must_output_die = (BLOCK_VARS (stmt) != NULL 12960 && (TREE_USED (stmt) 12961 || TREE_ASM_WRITTEN (stmt) 12962 || BLOCK_ABSTRACT (stmt))); 12963 else 12964 /* We are in terse mode, so only local (nested) function 12965 definitions count as "significant" local declarations. */ 12966 for (decl = BLOCK_VARS (stmt); 12967 decl != NULL; decl = TREE_CHAIN (decl)) 12968 if (TREE_CODE (decl) == FUNCTION_DECL 12969 && DECL_INITIAL (decl)) 12970 { 12971 must_output_die = 1; 12972 break; 12973 } 12974 } 12975 } 12976 12977 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block 12978 DIE for any block which contains no significant local declarations at 12979 all. Rather, in such cases we just call `decls_for_scope' so that any 12980 needed Dwarf info for any sub-blocks will get properly generated. Note 12981 that in terse mode, our definition of what constitutes a "significant" 12982 local declaration gets restricted to include only inlined function 12983 instances and local (nested) function definitions. */ 12984 if (must_output_die) 12985 { 12986 if (origin_code == FUNCTION_DECL) 12987 gen_inlined_subroutine_die (stmt, context_die, depth); 12988 else 12989 gen_lexical_block_die (stmt, context_die, depth); 12990 } 12991 else 12992 decls_for_scope (stmt, context_die, depth); 12993} 12994 12995/* Generate all of the decls declared within a given scope and (recursively) 12996 all of its sub-blocks. */ 12997 12998static void 12999decls_for_scope (tree stmt, dw_die_ref context_die, int depth) 13000{ 13001 tree decl; 13002 tree subblocks; 13003 13004 /* Ignore NULL blocks. */ 13005 if (stmt == NULL_TREE) 13006 return; 13007 13008 if (TREE_USED (stmt)) 13009 { 13010 /* Output the DIEs to represent all of the data objects and typedefs 13011 declared directly within this block but not within any nested 13012 sub-blocks. Also, nested function and tag DIEs have been 13013 generated with a parent of NULL; fix that up now. */ 13014 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl)) 13015 { 13016 dw_die_ref die; 13017 13018 if (TREE_CODE (decl) == FUNCTION_DECL) 13019 die = lookup_decl_die (decl); 13020 else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)) 13021 die = lookup_type_die (TREE_TYPE (decl)); 13022 else 13023 die = NULL; 13024 13025 if (die != NULL && die->die_parent == NULL) 13026 add_child_die (context_die, die); 13027 /* Do not produce debug information for static variables since 13028 these might be optimized out. We are called for these later 13029 in cgraph_varpool_analyze_pending_decls. */ 13030 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)) 13031 ; 13032 else 13033 gen_decl_die (decl, context_die); 13034 } 13035 } 13036 13037 /* If we're at -g1, we're not interested in subblocks. */ 13038 if (debug_info_level <= DINFO_LEVEL_TERSE) 13039 return; 13040 13041 /* Output the DIEs to represent all sub-blocks (and the items declared 13042 therein) of this block. */ 13043 for (subblocks = BLOCK_SUBBLOCKS (stmt); 13044 subblocks != NULL; 13045 subblocks = BLOCK_CHAIN (subblocks)) 13046 gen_block_die (subblocks, context_die, depth + 1); 13047} 13048 13049/* Is this a typedef we can avoid emitting? */ 13050 13051static inline int 13052is_redundant_typedef (tree decl) 13053{ 13054 if (TYPE_DECL_IS_STUB (decl)) 13055 return 1; 13056 13057 if (DECL_ARTIFICIAL (decl) 13058 && DECL_CONTEXT (decl) 13059 && is_tagged_type (DECL_CONTEXT (decl)) 13060 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL 13061 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))) 13062 /* Also ignore the artificial member typedef for the class name. */ 13063 return 1; 13064 13065 return 0; 13066} 13067 13068/* Returns the DIE for decl. A DIE will always be returned. */ 13069 13070static dw_die_ref 13071force_decl_die (tree decl) 13072{ 13073 dw_die_ref decl_die; 13074 unsigned saved_external_flag; 13075 tree save_fn = NULL_TREE; 13076 decl_die = lookup_decl_die (decl); 13077 if (!decl_die) 13078 { 13079 dw_die_ref context_die; 13080 tree decl_context = DECL_CONTEXT (decl); 13081 if (decl_context) 13082 { 13083 /* Find die that represents this context. */ 13084 if (TYPE_P (decl_context)) 13085 context_die = force_type_die (decl_context); 13086 else 13087 context_die = force_decl_die (decl_context); 13088 } 13089 else 13090 context_die = comp_unit_die; 13091 13092 decl_die = lookup_decl_die (decl); 13093 if (decl_die) 13094 return decl_die; 13095 13096 switch (TREE_CODE (decl)) 13097 { 13098 case FUNCTION_DECL: 13099 /* Clear current_function_decl, so that gen_subprogram_die thinks 13100 that this is a declaration. At this point, we just want to force 13101 declaration die. */ 13102 save_fn = current_function_decl; 13103 current_function_decl = NULL_TREE; 13104 gen_subprogram_die (decl, context_die); 13105 current_function_decl = save_fn; 13106 break; 13107 13108 case VAR_DECL: 13109 /* Set external flag to force declaration die. Restore it after 13110 gen_decl_die() call. */ 13111 saved_external_flag = DECL_EXTERNAL (decl); 13112 DECL_EXTERNAL (decl) = 1; 13113 gen_decl_die (decl, context_die); 13114 DECL_EXTERNAL (decl) = saved_external_flag; 13115 break; 13116 13117 case NAMESPACE_DECL: 13118 dwarf2out_decl (decl); 13119 break; 13120 13121 default: 13122 gcc_unreachable (); 13123 } 13124 13125 /* We should be able to find the DIE now. */ 13126 if (!decl_die) 13127 decl_die = lookup_decl_die (decl); 13128 gcc_assert (decl_die); 13129 } 13130 13131 return decl_die; 13132} 13133 13134/* Returns the DIE for TYPE, that must not be a base type. A DIE is 13135 always returned. */ 13136 13137static dw_die_ref 13138force_type_die (tree type) 13139{ 13140 dw_die_ref type_die; 13141 13142 type_die = lookup_type_die (type); 13143 if (!type_die) 13144 { 13145 dw_die_ref context_die; 13146 if (TYPE_CONTEXT (type)) 13147 { 13148 if (TYPE_P (TYPE_CONTEXT (type))) 13149 context_die = force_type_die (TYPE_CONTEXT (type)); 13150 else 13151 context_die = force_decl_die (TYPE_CONTEXT (type)); 13152 } 13153 else 13154 context_die = comp_unit_die; 13155 13156 type_die = lookup_type_die (type); 13157 if (type_die) 13158 return type_die; 13159 gen_type_die (type, context_die); 13160 type_die = lookup_type_die (type); 13161 gcc_assert (type_die); 13162 } 13163 return type_die; 13164} 13165 13166/* Force out any required namespaces to be able to output DECL, 13167 and return the new context_die for it, if it's changed. */ 13168 13169static dw_die_ref 13170setup_namespace_context (tree thing, dw_die_ref context_die) 13171{ 13172 tree context = (DECL_P (thing) 13173 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing)); 13174 if (context && TREE_CODE (context) == NAMESPACE_DECL) 13175 /* Force out the namespace. */ 13176 context_die = force_decl_die (context); 13177 13178 return context_die; 13179} 13180 13181/* Emit a declaration DIE for THING (which is either a DECL or a tagged 13182 type) within its namespace, if appropriate. 13183 13184 For compatibility with older debuggers, namespace DIEs only contain 13185 declarations; all definitions are emitted at CU scope. */ 13186 13187static void 13188declare_in_namespace (tree thing, dw_die_ref context_die) 13189{ 13190 dw_die_ref ns_context; 13191 13192 if (debug_info_level <= DINFO_LEVEL_TERSE) 13193 return; 13194 13195 /* If this decl is from an inlined function, then don't try to emit it in its 13196 namespace, as we will get confused. It would have already been emitted 13197 when the abstract instance of the inline function was emitted anyways. */ 13198 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing)) 13199 return; 13200 13201 ns_context = setup_namespace_context (thing, context_die); 13202 13203 if (ns_context != context_die) 13204 { 13205 if (DECL_P (thing)) 13206 gen_decl_die (thing, ns_context); 13207 else 13208 gen_type_die (thing, ns_context); 13209 } 13210} 13211 13212/* Generate a DIE for a namespace or namespace alias. */ 13213 13214static void 13215gen_namespace_die (tree decl) 13216{ 13217 dw_die_ref context_die = setup_namespace_context (decl, comp_unit_die); 13218 13219 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace 13220 they are an alias of. */ 13221 if (DECL_ABSTRACT_ORIGIN (decl) == NULL) 13222 { 13223 /* Output a real namespace. */ 13224 dw_die_ref namespace_die 13225 = new_die (DW_TAG_namespace, context_die, decl); 13226 add_name_and_src_coords_attributes (namespace_die, decl); 13227 equate_decl_number_to_die (decl, namespace_die); 13228 } 13229 else 13230 { 13231 /* Output a namespace alias. */ 13232 13233 /* Force out the namespace we are an alias of, if necessary. */ 13234 dw_die_ref origin_die 13235 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl)); 13236 13237 /* Now create the namespace alias DIE. */ 13238 dw_die_ref namespace_die 13239 = new_die (DW_TAG_imported_declaration, context_die, decl); 13240 add_name_and_src_coords_attributes (namespace_die, decl); 13241 add_AT_die_ref (namespace_die, DW_AT_import, origin_die); 13242 equate_decl_number_to_die (decl, namespace_die); 13243 } 13244} 13245 13246/* Generate Dwarf debug information for a decl described by DECL. */ 13247 13248static void 13249gen_decl_die (tree decl, dw_die_ref context_die) 13250{ 13251 tree origin; 13252 13253 if (DECL_P (decl) && DECL_IGNORED_P (decl)) 13254 return; 13255 13256 switch (TREE_CODE (decl)) 13257 { 13258 case ERROR_MARK: 13259 break; 13260 13261 case CONST_DECL: 13262 /* The individual enumerators of an enum type get output when we output 13263 the Dwarf representation of the relevant enum type itself. */ 13264 break; 13265 13266 case FUNCTION_DECL: 13267 /* Don't output any DIEs to represent mere function declarations, 13268 unless they are class members or explicit block externs. */ 13269 if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE 13270 && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl))) 13271 break; 13272 13273#if 0 13274 /* FIXME */ 13275 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN 13276 on local redeclarations of global functions. That seems broken. */ 13277 if (current_function_decl != decl) 13278 /* This is only a declaration. */; 13279#endif 13280 13281 /* If we're emitting a clone, emit info for the abstract instance. */ 13282 if (DECL_ORIGIN (decl) != decl) 13283 dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl)); 13284 13285 /* If we're emitting an out-of-line copy of an inline function, 13286 emit info for the abstract instance and set up to refer to it. */ 13287 else if (cgraph_function_possibly_inlined_p (decl) 13288 && ! DECL_ABSTRACT (decl) 13289 && ! class_or_namespace_scope_p (context_die) 13290 /* dwarf2out_abstract_function won't emit a die if this is just 13291 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in 13292 that case, because that works only if we have a die. */ 13293 && DECL_INITIAL (decl) != NULL_TREE) 13294 { 13295 dwarf2out_abstract_function (decl); 13296 set_decl_origin_self (decl); 13297 } 13298 13299 /* Otherwise we're emitting the primary DIE for this decl. */ 13300 else if (debug_info_level > DINFO_LEVEL_TERSE) 13301 { 13302 /* Before we describe the FUNCTION_DECL itself, make sure that we 13303 have described its return type. */ 13304 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die); 13305 13306 /* And its virtual context. */ 13307 if (DECL_VINDEX (decl) != NULL_TREE) 13308 gen_type_die (DECL_CONTEXT (decl), context_die); 13309 13310 /* And its containing type. */ 13311 origin = decl_class_context (decl); 13312 if (origin != NULL_TREE) 13313 gen_type_die_for_member (origin, decl, context_die); 13314 13315 /* And its containing namespace. */ 13316 declare_in_namespace (decl, context_die); 13317 } 13318 13319 /* Now output a DIE to represent the function itself. */ 13320 gen_subprogram_die (decl, context_die); 13321 break; 13322 13323 case TYPE_DECL: 13324 /* If we are in terse mode, don't generate any DIEs to represent any 13325 actual typedefs. */ 13326 if (debug_info_level <= DINFO_LEVEL_TERSE) 13327 break; 13328 13329 /* In the special case of a TYPE_DECL node representing the declaration 13330 of some type tag, if the given TYPE_DECL is marked as having been 13331 instantiated from some other (original) TYPE_DECL node (e.g. one which 13332 was generated within the original definition of an inline function) we 13333 have to generate a special (abbreviated) DW_TAG_structure_type, 13334 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. */ 13335 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE 13336 && is_tagged_type (TREE_TYPE (decl))) 13337 { 13338 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die); 13339 break; 13340 } 13341 13342 if (is_redundant_typedef (decl)) 13343 gen_type_die (TREE_TYPE (decl), context_die); 13344 else 13345 /* Output a DIE to represent the typedef itself. */ 13346 gen_typedef_die (decl, context_die); 13347 break; 13348 13349 case LABEL_DECL: 13350 if (debug_info_level >= DINFO_LEVEL_NORMAL) 13351 gen_label_die (decl, context_die); 13352 break; 13353 13354 case VAR_DECL: 13355 case RESULT_DECL: 13356 /* If we are in terse mode, don't generate any DIEs to represent any 13357 variable declarations or definitions. */ 13358 if (debug_info_level <= DINFO_LEVEL_TERSE) 13359 break; 13360 13361 /* Output any DIEs that are needed to specify the type of this data 13362 object. */ 13363 gen_type_die (TREE_TYPE (decl), context_die); 13364 13365 /* And its containing type. */ 13366 origin = decl_class_context (decl); 13367 if (origin != NULL_TREE) 13368 gen_type_die_for_member (origin, decl, context_die); 13369 13370 /* And its containing namespace. */ 13371 declare_in_namespace (decl, context_die); 13372 13373 /* Now output the DIE to represent the data object itself. This gets 13374 complicated because of the possibility that the VAR_DECL really 13375 represents an inlined instance of a formal parameter for an inline 13376 function. */ 13377 origin = decl_ultimate_origin (decl); 13378 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL) 13379 gen_formal_parameter_die (decl, context_die); 13380 else 13381 gen_variable_die (decl, context_die); 13382 break; 13383 13384 case FIELD_DECL: 13385 /* Ignore the nameless fields that are used to skip bits but handle C++ 13386 anonymous unions and structs. */ 13387 if (DECL_NAME (decl) != NULL_TREE 13388 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE 13389 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE) 13390 { 13391 gen_type_die (member_declared_type (decl), context_die); 13392 gen_field_die (decl, context_die); 13393 } 13394 break; 13395 13396 case PARM_DECL: 13397 gen_type_die (TREE_TYPE (decl), context_die); 13398 gen_formal_parameter_die (decl, context_die); 13399 break; 13400 13401 case NAMESPACE_DECL: 13402 gen_namespace_die (decl); 13403 break; 13404 13405 default: 13406 /* Probably some frontend-internal decl. Assume we don't care. */ 13407 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES); 13408 break; 13409 } 13410} 13411 13412/* Output debug information for global decl DECL. Called from toplev.c after 13413 compilation proper has finished. */ 13414 13415static void 13416dwarf2out_global_decl (tree decl) 13417{ 13418 /* Output DWARF2 information for file-scope tentative data object 13419 declarations, file-scope (extern) function declarations (which had no 13420 corresponding body) and file-scope tagged type declarations and 13421 definitions which have not yet been forced out. */ 13422 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl)) 13423 dwarf2out_decl (decl); 13424} 13425 13426/* Output debug information for type decl DECL. Called from toplev.c 13427 and from language front ends (to record built-in types). */ 13428static void 13429dwarf2out_type_decl (tree decl, int local) 13430{ 13431 if (!local) 13432 dwarf2out_decl (decl); 13433} 13434 13435/* Output debug information for imported module or decl. */ 13436 13437static void 13438dwarf2out_imported_module_or_decl (tree decl, tree context) 13439{ 13440 dw_die_ref imported_die, at_import_die; 13441 dw_die_ref scope_die; 13442 expanded_location xloc; 13443 13444 if (debug_info_level <= DINFO_LEVEL_TERSE) 13445 return; 13446 13447 gcc_assert (decl); 13448 13449 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs. 13450 We need decl DIE for reference and scope die. First, get DIE for the decl 13451 itself. */ 13452 13453 /* Get the scope die for decl context. Use comp_unit_die for global module 13454 or decl. If die is not found for non globals, force new die. */ 13455 if (!context) 13456 scope_die = comp_unit_die; 13457 else if (TYPE_P (context)) 13458 { 13459 if (!should_emit_struct_debug (context, DINFO_USAGE_DIR_USE)) 13460 return; 13461 scope_die = force_type_die (context); 13462 } 13463 else 13464 scope_die = force_decl_die (context); 13465 13466 /* For TYPE_DECL or CONST_DECL, lookup TREE_TYPE. */ 13467 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL) 13468 { 13469 if (is_base_type (TREE_TYPE (decl))) 13470 at_import_die = base_type_die (TREE_TYPE (decl)); 13471 else 13472 at_import_die = force_type_die (TREE_TYPE (decl)); 13473 } 13474 else 13475 { 13476 at_import_die = lookup_decl_die (decl); 13477 if (!at_import_die) 13478 { 13479 /* If we're trying to avoid duplicate debug info, we may not have 13480 emitted the member decl for this field. Emit it now. */ 13481 if (TREE_CODE (decl) == FIELD_DECL) 13482 { 13483 tree type = DECL_CONTEXT (decl); 13484 dw_die_ref type_context_die; 13485 13486 if (TYPE_CONTEXT (type)) 13487 if (TYPE_P (TYPE_CONTEXT (type))) 13488 { 13489 if (!should_emit_struct_debug (TYPE_CONTEXT (type), 13490 DINFO_USAGE_DIR_USE)) 13491 return; 13492 type_context_die = force_type_die (TYPE_CONTEXT (type)); 13493 } 13494 else 13495 type_context_die = force_decl_die (TYPE_CONTEXT (type)); 13496 else 13497 type_context_die = comp_unit_die; 13498 gen_type_die_for_member (type, decl, type_context_die); 13499 } 13500 at_import_die = force_decl_die (decl); 13501 } 13502 } 13503 13504 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */ 13505 if (TREE_CODE (decl) == NAMESPACE_DECL) 13506 imported_die = new_die (DW_TAG_imported_module, scope_die, context); 13507 else 13508 imported_die = new_die (DW_TAG_imported_declaration, scope_die, context); 13509 13510 xloc = expand_location (input_location); 13511 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file)); 13512 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line); 13513 add_AT_die_ref (imported_die, DW_AT_import, at_import_die); 13514} 13515 13516/* Write the debugging output for DECL. */ 13517 13518void 13519dwarf2out_decl (tree decl) 13520{ 13521 dw_die_ref context_die = comp_unit_die; 13522 13523 switch (TREE_CODE (decl)) 13524 { 13525 case ERROR_MARK: 13526 return; 13527 13528 case FUNCTION_DECL: 13529 /* What we would really like to do here is to filter out all mere 13530 file-scope declarations of file-scope functions which are never 13531 referenced later within this translation unit (and keep all of ones 13532 that *are* referenced later on) but we aren't clairvoyant, so we have 13533 no idea which functions will be referenced in the future (i.e. later 13534 on within the current translation unit). So here we just ignore all 13535 file-scope function declarations which are not also definitions. If 13536 and when the debugger needs to know something about these functions, 13537 it will have to hunt around and find the DWARF information associated 13538 with the definition of the function. 13539 13540 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL 13541 nodes represent definitions and which ones represent mere 13542 declarations. We have to check DECL_INITIAL instead. That's because 13543 the C front-end supports some weird semantics for "extern inline" 13544 function definitions. These can get inlined within the current 13545 translation unit (and thus, we need to generate Dwarf info for their 13546 abstract instances so that the Dwarf info for the concrete inlined 13547 instances can have something to refer to) but the compiler never 13548 generates any out-of-lines instances of such things (despite the fact 13549 that they *are* definitions). 13550 13551 The important point is that the C front-end marks these "extern 13552 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for 13553 them anyway. Note that the C++ front-end also plays some similar games 13554 for inline function definitions appearing within include files which 13555 also contain `#pragma interface' pragmas. */ 13556 if (DECL_INITIAL (decl) == NULL_TREE) 13557 return; 13558 13559 /* If we're a nested function, initially use a parent of NULL; if we're 13560 a plain function, this will be fixed up in decls_for_scope. If 13561 we're a method, it will be ignored, since we already have a DIE. */ 13562 if (decl_function_context (decl) 13563 /* But if we're in terse mode, we don't care about scope. */ 13564 && debug_info_level > DINFO_LEVEL_TERSE) 13565 context_die = NULL; 13566 break; 13567 13568 case VAR_DECL: 13569 /* Ignore this VAR_DECL if it refers to a file-scope extern data object 13570 declaration and if the declaration was never even referenced from 13571 within this entire compilation unit. We suppress these DIEs in 13572 order to save space in the .debug section (by eliminating entries 13573 which are probably useless). Note that we must not suppress 13574 block-local extern declarations (whether used or not) because that 13575 would screw-up the debugger's name lookup mechanism and cause it to 13576 miss things which really ought to be in scope at a given point. */ 13577 if (DECL_EXTERNAL (decl) && !TREE_USED (decl)) 13578 return; 13579 13580 /* For local statics lookup proper context die. */ 13581 if (TREE_STATIC (decl) && decl_function_context (decl)) 13582 context_die = lookup_decl_die (DECL_CONTEXT (decl)); 13583 13584 /* If we are in terse mode, don't generate any DIEs to represent any 13585 variable declarations or definitions. */ 13586 if (debug_info_level <= DINFO_LEVEL_TERSE) 13587 return; 13588 break; 13589 13590 case NAMESPACE_DECL: 13591 if (debug_info_level <= DINFO_LEVEL_TERSE) 13592 return; 13593 if (lookup_decl_die (decl) != NULL) 13594 return; 13595 break; 13596 13597 case TYPE_DECL: 13598 /* Don't emit stubs for types unless they are needed by other DIEs. */ 13599 if (TYPE_DECL_SUPPRESS_DEBUG (decl)) 13600 return; 13601 13602 /* Don't bother trying to generate any DIEs to represent any of the 13603 normal built-in types for the language we are compiling. */ 13604 if (DECL_IS_BUILTIN (decl)) 13605 { 13606 /* OK, we need to generate one for `bool' so GDB knows what type 13607 comparisons have. */ 13608 if (is_cxx () 13609 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE 13610 && ! DECL_IGNORED_P (decl)) 13611 modified_type_die (TREE_TYPE (decl), 0, 0, NULL); 13612 13613 return; 13614 } 13615 13616 /* If we are in terse mode, don't generate any DIEs for types. */ 13617 if (debug_info_level <= DINFO_LEVEL_TERSE) 13618 return; 13619 13620 /* If we're a function-scope tag, initially use a parent of NULL; 13621 this will be fixed up in decls_for_scope. */ 13622 if (decl_function_context (decl)) 13623 context_die = NULL; 13624 13625 break; 13626 13627 default: 13628 return; 13629 } 13630 13631 gen_decl_die (decl, context_die); 13632} 13633 13634/* Output a marker (i.e. a label) for the beginning of the generated code for 13635 a lexical block. */ 13636 13637static void 13638dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED, 13639 unsigned int blocknum) 13640{ 13641 switch_to_section (current_function_section ()); 13642 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum); 13643} 13644 13645/* Output a marker (i.e. a label) for the end of the generated code for a 13646 lexical block. */ 13647 13648static void 13649dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum) 13650{ 13651 switch_to_section (current_function_section ()); 13652 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum); 13653} 13654 13655/* Returns nonzero if it is appropriate not to emit any debugging 13656 information for BLOCK, because it doesn't contain any instructions. 13657 13658 Don't allow this for blocks with nested functions or local classes 13659 as we would end up with orphans, and in the presence of scheduling 13660 we may end up calling them anyway. */ 13661 13662static bool 13663dwarf2out_ignore_block (tree block) 13664{ 13665 tree decl; 13666 13667 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl)) 13668 if (TREE_CODE (decl) == FUNCTION_DECL 13669 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))) 13670 return 0; 13671 13672 return 1; 13673} 13674 13675/* Hash table routines for file_hash. */ 13676 13677static int 13678file_table_eq (const void *p1_p, const void *p2_p) 13679{ 13680 const struct dwarf_file_data * p1 = p1_p; 13681 const char * p2 = p2_p; 13682 return strcmp (p1->filename, p2) == 0; 13683} 13684 13685static hashval_t 13686file_table_hash (const void *p_p) 13687{ 13688 const struct dwarf_file_data * p = p_p; 13689 return htab_hash_string (p->filename); 13690} 13691 13692/* Lookup FILE_NAME (in the list of filenames that we know about here in 13693 dwarf2out.c) and return its "index". The index of each (known) filename is 13694 just a unique number which is associated with only that one filename. We 13695 need such numbers for the sake of generating labels (in the .debug_sfnames 13696 section) and references to those files numbers (in the .debug_srcinfo 13697 and.debug_macinfo sections). If the filename given as an argument is not 13698 found in our current list, add it to the list and assign it the next 13699 available unique index number. In order to speed up searches, we remember 13700 the index of the filename was looked up last. This handles the majority of 13701 all searches. */ 13702 13703static struct dwarf_file_data * 13704lookup_filename (const char *file_name) 13705{ 13706 void ** slot; 13707 struct dwarf_file_data * created; 13708 13709 /* Check to see if the file name that was searched on the previous 13710 call matches this file name. If so, return the index. */ 13711 if (file_table_last_lookup 13712 && (file_name == file_table_last_lookup->filename 13713 || strcmp (file_table_last_lookup->filename, file_name) == 0)) 13714 return file_table_last_lookup; 13715 13716 /* Didn't match the previous lookup, search the table. */ 13717 slot = htab_find_slot_with_hash (file_table, file_name, 13718 htab_hash_string (file_name), INSERT); 13719 if (*slot) 13720 return *slot; 13721 13722 created = ggc_alloc (sizeof (struct dwarf_file_data)); 13723 created->filename = file_name; 13724 created->emitted_number = 0; 13725 *slot = created; 13726 return created; 13727} 13728 13729/* If the assembler will construct the file table, then translate the compiler 13730 internal file table number into the assembler file table number, and emit 13731 a .file directive if we haven't already emitted one yet. The file table 13732 numbers are different because we prune debug info for unused variables and 13733 types, which may include filenames. */ 13734 13735static int 13736maybe_emit_file (struct dwarf_file_data * fd) 13737{ 13738 if (! fd->emitted_number) 13739 { 13740 if (last_emitted_file) 13741 fd->emitted_number = last_emitted_file->emitted_number + 1; 13742 else 13743 fd->emitted_number = 1; 13744 last_emitted_file = fd; 13745 13746 if (DWARF2_ASM_LINE_DEBUG_INFO) 13747 { 13748 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number); 13749 output_quoted_string (asm_out_file, fd->filename); 13750 fputc ('\n', asm_out_file); 13751 } 13752 } 13753 13754 return fd->emitted_number; 13755} 13756 13757/* Called by the final INSN scan whenever we see a var location. We 13758 use it to drop labels in the right places, and throw the location in 13759 our lookup table. */ 13760 13761static void 13762dwarf2out_var_location (rtx loc_note) 13763{ 13764 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES]; 13765 struct var_loc_node *newloc; 13766 rtx prev_insn; 13767 static rtx last_insn; 13768 static const char *last_label; 13769 tree decl; 13770 13771 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note))) 13772 return; 13773 prev_insn = PREV_INSN (loc_note); 13774 13775 newloc = ggc_alloc_cleared (sizeof (struct var_loc_node)); 13776 /* If the insn we processed last time is the previous insn 13777 and it is also a var location note, use the label we emitted 13778 last time. */ 13779 if (last_insn != NULL_RTX 13780 && last_insn == prev_insn 13781 && NOTE_P (prev_insn) 13782 && NOTE_LINE_NUMBER (prev_insn) == NOTE_INSN_VAR_LOCATION) 13783 { 13784 newloc->label = last_label; 13785 } 13786 else 13787 { 13788 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num); 13789 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num); 13790 loclabel_num++; 13791 newloc->label = ggc_strdup (loclabel); 13792 } 13793 newloc->var_loc_note = loc_note; 13794 newloc->next = NULL; 13795 13796 if (cfun && in_cold_section_p) 13797 newloc->section_label = cfun->cold_section_label; 13798 else 13799 newloc->section_label = text_section_label; 13800 13801 last_insn = loc_note; 13802 last_label = newloc->label; 13803 decl = NOTE_VAR_LOCATION_DECL (loc_note); 13804 add_var_loc_to_decl (decl, newloc); 13805} 13806 13807/* We need to reset the locations at the beginning of each 13808 function. We can't do this in the end_function hook, because the 13809 declarations that use the locations won't have been output when 13810 that hook is called. Also compute have_multiple_function_sections here. */ 13811 13812static void 13813dwarf2out_begin_function (tree fun) 13814{ 13815 htab_empty (decl_loc_table); 13816 13817 if (function_section (fun) != text_section) 13818 have_multiple_function_sections = true; 13819} 13820 13821/* Output a label to mark the beginning of a source code line entry 13822 and record information relating to this source line, in 13823 'line_info_table' for later output of the .debug_line section. */ 13824 13825static void 13826dwarf2out_source_line (unsigned int line, const char *filename) 13827{ 13828 if (debug_info_level >= DINFO_LEVEL_NORMAL 13829 && line != 0) 13830 { 13831 int file_num = maybe_emit_file (lookup_filename (filename)); 13832 13833 switch_to_section (current_function_section ()); 13834 13835 /* If requested, emit something human-readable. */ 13836 if (flag_debug_asm) 13837 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START, 13838 filename, line); 13839 13840 if (DWARF2_ASM_LINE_DEBUG_INFO) 13841 { 13842 /* Emit the .loc directive understood by GNU as. */ 13843 fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line); 13844 13845 /* Indicate that line number info exists. */ 13846 line_info_table_in_use++; 13847 } 13848 else if (function_section (current_function_decl) != text_section) 13849 { 13850 dw_separate_line_info_ref line_info; 13851 targetm.asm_out.internal_label (asm_out_file, 13852 SEPARATE_LINE_CODE_LABEL, 13853 separate_line_info_table_in_use); 13854 13855 /* Expand the line info table if necessary. */ 13856 if (separate_line_info_table_in_use 13857 == separate_line_info_table_allocated) 13858 { 13859 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT; 13860 separate_line_info_table 13861 = ggc_realloc (separate_line_info_table, 13862 separate_line_info_table_allocated 13863 * sizeof (dw_separate_line_info_entry)); 13864 memset (separate_line_info_table 13865 + separate_line_info_table_in_use, 13866 0, 13867 (LINE_INFO_TABLE_INCREMENT 13868 * sizeof (dw_separate_line_info_entry))); 13869 } 13870 13871 /* Add the new entry at the end of the line_info_table. */ 13872 line_info 13873 = &separate_line_info_table[separate_line_info_table_in_use++]; 13874 line_info->dw_file_num = file_num; 13875 line_info->dw_line_num = line; 13876 line_info->function = current_function_funcdef_no; 13877 } 13878 else 13879 { 13880 dw_line_info_ref line_info; 13881 13882 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL, 13883 line_info_table_in_use); 13884 13885 /* Expand the line info table if necessary. */ 13886 if (line_info_table_in_use == line_info_table_allocated) 13887 { 13888 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT; 13889 line_info_table 13890 = ggc_realloc (line_info_table, 13891 (line_info_table_allocated 13892 * sizeof (dw_line_info_entry))); 13893 memset (line_info_table + line_info_table_in_use, 0, 13894 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry)); 13895 } 13896 13897 /* Add the new entry at the end of the line_info_table. */ 13898 line_info = &line_info_table[line_info_table_in_use++]; 13899 line_info->dw_file_num = file_num; 13900 line_info->dw_line_num = line; 13901 } 13902 } 13903} 13904 13905/* Record the beginning of a new source file. */ 13906 13907static void 13908dwarf2out_start_source_file (unsigned int lineno, const char *filename) 13909{ 13910 if (flag_eliminate_dwarf2_dups) 13911 { 13912 /* Record the beginning of the file for break_out_includes. */ 13913 dw_die_ref bincl_die; 13914 13915 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL); 13916 add_AT_string (bincl_die, DW_AT_name, filename); 13917 } 13918 13919 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 13920 { 13921 int file_num = maybe_emit_file (lookup_filename (filename)); 13922 13923 switch_to_section (debug_macinfo_section); 13924 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file"); 13925 dw2_asm_output_data_uleb128 (lineno, "Included from line number %d", 13926 lineno); 13927 13928 dw2_asm_output_data_uleb128 (file_num, "file %s", filename); 13929 } 13930} 13931 13932/* Record the end of a source file. */ 13933 13934static void 13935dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED) 13936{ 13937 if (flag_eliminate_dwarf2_dups) 13938 /* Record the end of the file for break_out_includes. */ 13939 new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL); 13940 13941 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 13942 { 13943 switch_to_section (debug_macinfo_section); 13944 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file"); 13945 } 13946} 13947 13948/* Called from debug_define in toplev.c. The `buffer' parameter contains 13949 the tail part of the directive line, i.e. the part which is past the 13950 initial whitespace, #, whitespace, directive-name, whitespace part. */ 13951 13952static void 13953dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED, 13954 const char *buffer ATTRIBUTE_UNUSED) 13955{ 13956 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 13957 { 13958 switch_to_section (debug_macinfo_section); 13959 dw2_asm_output_data (1, DW_MACINFO_define, "Define macro"); 13960 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno); 13961 dw2_asm_output_nstring (buffer, -1, "The macro"); 13962 } 13963} 13964 13965/* Called from debug_undef in toplev.c. The `buffer' parameter contains 13966 the tail part of the directive line, i.e. the part which is past the 13967 initial whitespace, #, whitespace, directive-name, whitespace part. */ 13968 13969static void 13970dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED, 13971 const char *buffer ATTRIBUTE_UNUSED) 13972{ 13973 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 13974 { 13975 switch_to_section (debug_macinfo_section); 13976 dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro"); 13977 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno); 13978 dw2_asm_output_nstring (buffer, -1, "The macro"); 13979 } 13980} 13981 13982/* Set up for Dwarf output at the start of compilation. */ 13983 13984static void 13985dwarf2out_init (const char *filename ATTRIBUTE_UNUSED) 13986{ 13987 /* Allocate the file_table. */ 13988 file_table = htab_create_ggc (50, file_table_hash, 13989 file_table_eq, NULL); 13990 13991 /* Allocate the decl_die_table. */ 13992 decl_die_table = htab_create_ggc (10, decl_die_table_hash, 13993 decl_die_table_eq, NULL); 13994 13995 /* Allocate the decl_loc_table. */ 13996 decl_loc_table = htab_create_ggc (10, decl_loc_table_hash, 13997 decl_loc_table_eq, NULL); 13998 13999 /* Allocate the initial hunk of the decl_scope_table. */ 14000 decl_scope_table = VEC_alloc (tree, gc, 256); 14001 14002 /* Allocate the initial hunk of the abbrev_die_table. */ 14003 abbrev_die_table = ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT 14004 * sizeof (dw_die_ref)); 14005 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT; 14006 /* Zero-th entry is allocated, but unused. */ 14007 abbrev_die_table_in_use = 1; 14008 14009 /* Allocate the initial hunk of the line_info_table. */ 14010 line_info_table = ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT 14011 * sizeof (dw_line_info_entry)); 14012 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT; 14013 14014 /* Zero-th entry is allocated, but unused. */ 14015 line_info_table_in_use = 1; 14016 14017 /* Allocate the pubtypes and pubnames vectors. */ 14018 pubname_table = VEC_alloc (pubname_entry, gc, 32); 14019 pubtype_table = VEC_alloc (pubname_entry, gc, 32); 14020 14021 /* Generate the initial DIE for the .debug section. Note that the (string) 14022 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE 14023 will (typically) be a relative pathname and that this pathname should be 14024 taken as being relative to the directory from which the compiler was 14025 invoked when the given (base) source file was compiled. We will fill 14026 in this value in dwarf2out_finish. */ 14027 comp_unit_die = gen_compile_unit_die (NULL); 14028 14029 incomplete_types = VEC_alloc (tree, gc, 64); 14030 14031 used_rtx_array = VEC_alloc (rtx, gc, 32); 14032 14033 debug_info_section = get_section (DEBUG_INFO_SECTION, 14034 SECTION_DEBUG, NULL); 14035 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION, 14036 SECTION_DEBUG, NULL); 14037 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION, 14038 SECTION_DEBUG, NULL); 14039 debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION, 14040 SECTION_DEBUG, NULL); 14041 debug_line_section = get_section (DEBUG_LINE_SECTION, 14042 SECTION_DEBUG, NULL); 14043 debug_loc_section = get_section (DEBUG_LOC_SECTION, 14044 SECTION_DEBUG, NULL); 14045 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION, 14046 SECTION_DEBUG, NULL); 14047#ifdef DEBUG_PUBTYPES_SECTION 14048 debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION, 14049 SECTION_DEBUG, NULL); 14050#endif 14051 debug_str_section = get_section (DEBUG_STR_SECTION, 14052 DEBUG_STR_SECTION_FLAGS, NULL); 14053 debug_ranges_section = get_section (DEBUG_RANGES_SECTION, 14054 SECTION_DEBUG, NULL); 14055 debug_frame_section = get_section (DEBUG_FRAME_SECTION, 14056 SECTION_DEBUG, NULL); 14057 14058 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0); 14059 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label, 14060 DEBUG_ABBREV_SECTION_LABEL, 0); 14061 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0); 14062 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label, 14063 COLD_TEXT_SECTION_LABEL, 0); 14064 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0); 14065 14066 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label, 14067 DEBUG_INFO_SECTION_LABEL, 0); 14068 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label, 14069 DEBUG_LINE_SECTION_LABEL, 0); 14070 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label, 14071 DEBUG_RANGES_SECTION_LABEL, 0); 14072 switch_to_section (debug_abbrev_section); 14073 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label); 14074 switch_to_section (debug_info_section); 14075 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label); 14076 switch_to_section (debug_line_section); 14077 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label); 14078 14079 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 14080 { 14081 switch_to_section (debug_macinfo_section); 14082 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label, 14083 DEBUG_MACINFO_SECTION_LABEL, 0); 14084 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label); 14085 } 14086 14087 switch_to_section (text_section); 14088 ASM_OUTPUT_LABEL (asm_out_file, text_section_label); 14089 if (flag_reorder_blocks_and_partition) 14090 { 14091 switch_to_section (unlikely_text_section ()); 14092 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label); 14093 } 14094} 14095 14096/* A helper function for dwarf2out_finish called through 14097 ht_forall. Emit one queued .debug_str string. */ 14098 14099static int 14100output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED) 14101{ 14102 struct indirect_string_node *node = (struct indirect_string_node *) *h; 14103 14104 if (node->form == DW_FORM_strp) 14105 { 14106 switch_to_section (debug_str_section); 14107 ASM_OUTPUT_LABEL (asm_out_file, node->label); 14108 assemble_string (node->str, strlen (node->str) + 1); 14109 } 14110 14111 return 1; 14112} 14113 14114#if ENABLE_ASSERT_CHECKING 14115/* Verify that all marks are clear. */ 14116 14117static void 14118verify_marks_clear (dw_die_ref die) 14119{ 14120 dw_die_ref c; 14121 14122 gcc_assert (! die->die_mark); 14123 FOR_EACH_CHILD (die, c, verify_marks_clear (c)); 14124} 14125#endif /* ENABLE_ASSERT_CHECKING */ 14126 14127/* Clear the marks for a die and its children. 14128 Be cool if the mark isn't set. */ 14129 14130static void 14131prune_unmark_dies (dw_die_ref die) 14132{ 14133 dw_die_ref c; 14134 14135 if (die->die_mark) 14136 die->die_mark = 0; 14137 FOR_EACH_CHILD (die, c, prune_unmark_dies (c)); 14138} 14139 14140/* Given DIE that we're marking as used, find any other dies 14141 it references as attributes and mark them as used. */ 14142 14143static void 14144prune_unused_types_walk_attribs (dw_die_ref die) 14145{ 14146 dw_attr_ref a; 14147 unsigned ix; 14148 14149 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 14150 { 14151 if (a->dw_attr_val.val_class == dw_val_class_die_ref) 14152 { 14153 /* A reference to another DIE. 14154 Make sure that it will get emitted. */ 14155 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1); 14156 } 14157 /* Set the string's refcount to 0 so that prune_unused_types_mark 14158 accounts properly for it. */ 14159 if (AT_class (a) == dw_val_class_str) 14160 a->dw_attr_val.v.val_str->refcount = 0; 14161 } 14162} 14163 14164 14165/* Mark DIE as being used. If DOKIDS is true, then walk down 14166 to DIE's children. */ 14167 14168static void 14169prune_unused_types_mark (dw_die_ref die, int dokids) 14170{ 14171 dw_die_ref c; 14172 14173 if (die->die_mark == 0) 14174 { 14175 /* We haven't done this node yet. Mark it as used. */ 14176 die->die_mark = 1; 14177 14178 /* We also have to mark its parents as used. 14179 (But we don't want to mark our parents' kids due to this.) */ 14180 if (die->die_parent) 14181 prune_unused_types_mark (die->die_parent, 0); 14182 14183 /* Mark any referenced nodes. */ 14184 prune_unused_types_walk_attribs (die); 14185 14186 /* If this node is a specification, 14187 also mark the definition, if it exists. */ 14188 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition) 14189 prune_unused_types_mark (die->die_definition, 1); 14190 } 14191 14192 if (dokids && die->die_mark != 2) 14193 { 14194 /* We need to walk the children, but haven't done so yet. 14195 Remember that we've walked the kids. */ 14196 die->die_mark = 2; 14197 14198 /* If this is an array type, we need to make sure our 14199 kids get marked, even if they're types. */ 14200 if (die->die_tag == DW_TAG_array_type) 14201 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1)); 14202 else 14203 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c)); 14204 } 14205} 14206 14207 14208/* Walk the tree DIE and mark types that we actually use. */ 14209 14210static void 14211prune_unused_types_walk (dw_die_ref die) 14212{ 14213 dw_die_ref c; 14214 14215 /* Don't do anything if this node is already marked. */ 14216 if (die->die_mark) 14217 return; 14218 14219 switch (die->die_tag) { 14220 case DW_TAG_const_type: 14221 case DW_TAG_packed_type: 14222 case DW_TAG_pointer_type: 14223 case DW_TAG_reference_type: 14224 case DW_TAG_volatile_type: 14225 case DW_TAG_typedef: 14226 case DW_TAG_array_type: 14227 case DW_TAG_structure_type: 14228 case DW_TAG_union_type: 14229 case DW_TAG_class_type: 14230 case DW_TAG_friend: 14231 case DW_TAG_variant_part: 14232 case DW_TAG_enumeration_type: 14233 case DW_TAG_subroutine_type: 14234 case DW_TAG_string_type: 14235 case DW_TAG_set_type: 14236 case DW_TAG_subrange_type: 14237 case DW_TAG_ptr_to_member_type: 14238 case DW_TAG_file_type: 14239 if (die->die_perennial_p) 14240 break; 14241 14242 /* It's a type node --- don't mark it. */ 14243 return; 14244 14245 default: 14246 /* Mark everything else. */ 14247 break; 14248 } 14249 14250 die->die_mark = 1; 14251 14252 /* Now, mark any dies referenced from here. */ 14253 prune_unused_types_walk_attribs (die); 14254 14255 /* Mark children. */ 14256 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c)); 14257} 14258 14259/* Increment the string counts on strings referred to from DIE's 14260 attributes. */ 14261 14262static void 14263prune_unused_types_update_strings (dw_die_ref die) 14264{ 14265 dw_attr_ref a; 14266 unsigned ix; 14267 14268 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 14269 if (AT_class (a) == dw_val_class_str) 14270 { 14271 struct indirect_string_node *s = a->dw_attr_val.v.val_str; 14272 s->refcount++; 14273 /* Avoid unnecessarily putting strings that are used less than 14274 twice in the hash table. */ 14275 if (s->refcount 14276 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2)) 14277 { 14278 void ** slot; 14279 slot = htab_find_slot_with_hash (debug_str_hash, s->str, 14280 htab_hash_string (s->str), 14281 INSERT); 14282 gcc_assert (*slot == NULL); 14283 *slot = s; 14284 } 14285 } 14286} 14287 14288/* Remove from the tree DIE any dies that aren't marked. */ 14289 14290static void 14291prune_unused_types_prune (dw_die_ref die) 14292{ 14293 dw_die_ref c; 14294 14295 gcc_assert (die->die_mark); 14296 prune_unused_types_update_strings (die); 14297 14298 if (! die->die_child) 14299 return; 14300 14301 c = die->die_child; 14302 do { 14303 dw_die_ref prev = c; 14304 for (c = c->die_sib; ! c->die_mark; c = c->die_sib) 14305 if (c == die->die_child) 14306 { 14307 /* No marked children between 'prev' and the end of the list. */ 14308 if (prev == c) 14309 /* No marked children at all. */ 14310 die->die_child = NULL; 14311 else 14312 { 14313 prev->die_sib = c->die_sib; 14314 die->die_child = prev; 14315 } 14316 return; 14317 } 14318 14319 if (c != prev->die_sib) 14320 prev->die_sib = c; 14321 prune_unused_types_prune (c); 14322 } while (c != die->die_child); 14323} 14324 14325 14326/* Remove dies representing declarations that we never use. */ 14327 14328static void 14329prune_unused_types (void) 14330{ 14331 unsigned int i; 14332 limbo_die_node *node; 14333 pubname_ref pub; 14334 14335#if ENABLE_ASSERT_CHECKING 14336 /* All the marks should already be clear. */ 14337 verify_marks_clear (comp_unit_die); 14338 for (node = limbo_die_list; node; node = node->next) 14339 verify_marks_clear (node->die); 14340#endif /* ENABLE_ASSERT_CHECKING */ 14341 14342 /* Set the mark on nodes that are actually used. */ 14343 prune_unused_types_walk (comp_unit_die); 14344 for (node = limbo_die_list; node; node = node->next) 14345 prune_unused_types_walk (node->die); 14346 14347 /* Also set the mark on nodes referenced from the 14348 pubname_table or arange_table. */ 14349 for (i = 0; VEC_iterate (pubname_entry, pubname_table, i, pub); i++) 14350 prune_unused_types_mark (pub->die, 1); 14351 for (i = 0; i < arange_table_in_use; i++) 14352 prune_unused_types_mark (arange_table[i], 1); 14353 14354 /* Get rid of nodes that aren't marked; and update the string counts. */ 14355 if (debug_str_hash) 14356 htab_empty (debug_str_hash); 14357 prune_unused_types_prune (comp_unit_die); 14358 for (node = limbo_die_list; node; node = node->next) 14359 prune_unused_types_prune (node->die); 14360 14361 /* Leave the marks clear. */ 14362 prune_unmark_dies (comp_unit_die); 14363 for (node = limbo_die_list; node; node = node->next) 14364 prune_unmark_dies (node->die); 14365} 14366 14367/* Set the parameter to true if there are any relative pathnames in 14368 the file table. */ 14369static int 14370file_table_relative_p (void ** slot, void *param) 14371{ 14372 bool *p = param; 14373 struct dwarf_file_data *d = *slot; 14374 if (d->emitted_number && d->filename[0] != DIR_SEPARATOR) 14375 { 14376 *p = true; 14377 return 0; 14378 } 14379 return 1; 14380} 14381 14382/* Output stuff that dwarf requires at the end of every file, 14383 and generate the DWARF-2 debugging info. */ 14384 14385static void 14386dwarf2out_finish (const char *filename) 14387{ 14388 limbo_die_node *node, *next_node; 14389 dw_die_ref die = 0; 14390 14391 /* Add the name for the main input file now. We delayed this from 14392 dwarf2out_init to avoid complications with PCH. */ 14393 add_name_attribute (comp_unit_die, filename); 14394 if (filename[0] != DIR_SEPARATOR) 14395 add_comp_dir_attribute (comp_unit_die); 14396 else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL) 14397 { 14398 bool p = false; 14399 htab_traverse (file_table, file_table_relative_p, &p); 14400 if (p) 14401 add_comp_dir_attribute (comp_unit_die); 14402 } 14403 14404 /* Traverse the limbo die list, and add parent/child links. The only 14405 dies without parents that should be here are concrete instances of 14406 inline functions, and the comp_unit_die. We can ignore the comp_unit_die. 14407 For concrete instances, we can get the parent die from the abstract 14408 instance. */ 14409 for (node = limbo_die_list; node; node = next_node) 14410 { 14411 next_node = node->next; 14412 die = node->die; 14413 14414 if (die->die_parent == NULL) 14415 { 14416 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin); 14417 14418 if (origin) 14419 add_child_die (origin->die_parent, die); 14420 else if (die == comp_unit_die) 14421 ; 14422 else if (errorcount > 0 || sorrycount > 0) 14423 /* It's OK to be confused by errors in the input. */ 14424 add_child_die (comp_unit_die, die); 14425 else 14426 { 14427 /* In certain situations, the lexical block containing a 14428 nested function can be optimized away, which results 14429 in the nested function die being orphaned. Likewise 14430 with the return type of that nested function. Force 14431 this to be a child of the containing function. 14432 14433 It may happen that even the containing function got fully 14434 inlined and optimized out. In that case we are lost and 14435 assign the empty child. This should not be big issue as 14436 the function is likely unreachable too. */ 14437 tree context = NULL_TREE; 14438 14439 gcc_assert (node->created_for); 14440 14441 if (DECL_P (node->created_for)) 14442 context = DECL_CONTEXT (node->created_for); 14443 else if (TYPE_P (node->created_for)) 14444 context = TYPE_CONTEXT (node->created_for); 14445 14446 gcc_assert (context 14447 && (TREE_CODE (context) == FUNCTION_DECL 14448 || TREE_CODE (context) == NAMESPACE_DECL)); 14449 14450 origin = lookup_decl_die (context); 14451 if (origin) 14452 add_child_die (origin, die); 14453 else 14454 add_child_die (comp_unit_die, die); 14455 } 14456 } 14457 } 14458 14459 limbo_die_list = NULL; 14460 14461 /* Walk through the list of incomplete types again, trying once more to 14462 emit full debugging info for them. */ 14463 retry_incomplete_types (); 14464 14465 if (flag_eliminate_unused_debug_types) 14466 prune_unused_types (); 14467 14468 /* Generate separate CUs for each of the include files we've seen. 14469 They will go into limbo_die_list. */ 14470 if (flag_eliminate_dwarf2_dups) 14471 break_out_includes (comp_unit_die); 14472 14473 /* Traverse the DIE's and add add sibling attributes to those DIE's 14474 that have children. */ 14475 add_sibling_attributes (comp_unit_die); 14476 for (node = limbo_die_list; node; node = node->next) 14477 add_sibling_attributes (node->die); 14478 14479 /* Output a terminator label for the .text section. */ 14480 switch_to_section (text_section); 14481 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0); 14482 if (flag_reorder_blocks_and_partition) 14483 { 14484 switch_to_section (unlikely_text_section ()); 14485 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0); 14486 } 14487 14488 /* We can only use the low/high_pc attributes if all of the code was 14489 in .text. */ 14490 if (!have_multiple_function_sections) 14491 { 14492 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label); 14493 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label); 14494 } 14495 14496 /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate 14497 "base address". Use zero so that these addresses become absolute. */ 14498 else if (have_location_lists || ranges_table_in_use) 14499 add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx); 14500 14501 /* Output location list section if necessary. */ 14502 if (have_location_lists) 14503 { 14504 /* Output the location lists info. */ 14505 switch_to_section (debug_loc_section); 14506 ASM_GENERATE_INTERNAL_LABEL (loc_section_label, 14507 DEBUG_LOC_SECTION_LABEL, 0); 14508 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label); 14509 output_location_lists (die); 14510 } 14511 14512 if (debug_info_level >= DINFO_LEVEL_NORMAL) 14513 add_AT_lineptr (comp_unit_die, DW_AT_stmt_list, 14514 debug_line_section_label); 14515 14516 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 14517 add_AT_macptr (comp_unit_die, DW_AT_macro_info, macinfo_section_label); 14518 14519 /* Output all of the compilation units. We put the main one last so that 14520 the offsets are available to output_pubnames. */ 14521 for (node = limbo_die_list; node; node = node->next) 14522 output_comp_unit (node->die, 0); 14523 14524 output_comp_unit (comp_unit_die, 0); 14525 14526 /* Output the abbreviation table. */ 14527 switch_to_section (debug_abbrev_section); 14528 output_abbrev_section (); 14529 14530 /* Output public names table if necessary. */ 14531 if (!VEC_empty (pubname_entry, pubname_table)) 14532 { 14533 switch_to_section (debug_pubnames_section); 14534 output_pubnames (pubname_table); 14535 } 14536 14537#ifdef DEBUG_PUBTYPES_SECTION 14538 /* Output public types table if necessary. */ 14539 if (!VEC_empty (pubname_entry, pubtype_table)) 14540 { 14541 switch_to_section (debug_pubtypes_section); 14542 output_pubnames (pubtype_table); 14543 } 14544#endif 14545 14546 /* Output the address range information. We only put functions in the arange 14547 table, so don't write it out if we don't have any. */ 14548 if (fde_table_in_use) 14549 { 14550 switch_to_section (debug_aranges_section); 14551 output_aranges (); 14552 } 14553 14554 /* Output ranges section if necessary. */ 14555 if (ranges_table_in_use) 14556 { 14557 switch_to_section (debug_ranges_section); 14558 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label); 14559 output_ranges (); 14560 } 14561 14562 /* Output the source line correspondence table. We must do this 14563 even if there is no line information. Otherwise, on an empty 14564 translation unit, we will generate a present, but empty, 14565 .debug_info section. IRIX 6.5 `nm' will then complain when 14566 examining the file. This is done late so that any filenames 14567 used by the debug_info section are marked as 'used'. */ 14568 if (! DWARF2_ASM_LINE_DEBUG_INFO) 14569 { 14570 switch_to_section (debug_line_section); 14571 output_line_info (); 14572 } 14573 14574 /* Have to end the macro section. */ 14575 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 14576 { 14577 switch_to_section (debug_macinfo_section); 14578 dw2_asm_output_data (1, 0, "End compilation unit"); 14579 } 14580 14581 /* If we emitted any DW_FORM_strp form attribute, output the string 14582 table too. */ 14583 if (debug_str_hash) 14584 htab_traverse (debug_str_hash, output_indirect_string, NULL); 14585} 14586#else 14587 14588/* This should never be used, but its address is needed for comparisons. */ 14589const struct gcc_debug_hooks dwarf2_debug_hooks; 14590 14591#endif /* DWARF2_DEBUGGING_INFO */ 14592 14593#include "gt-dwarf2out.h" 14594