dwarf2out.c revision 259948
1/* Output Dwarf2 format symbol table information from GCC. 2 Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 3 2003, 2004, 2005, 2006 Free Software Foundation, Inc. 4 Contributed by Gary Funck (gary@intrepid.com). 5 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com). 6 Extensively modified by Jason Merrill (jason@cygnus.com). 7 8This file is part of GCC. 9 10GCC is free software; you can redistribute it and/or modify it under 11the terms of the GNU General Public License as published by the Free 12Software Foundation; either version 2, or (at your option) any later 13version. 14 15GCC is distributed in the hope that it will be useful, but WITHOUT ANY 16WARRANTY; without even the implied warranty of MERCHANTABILITY or 17FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 18for more details. 19 20You should have received a copy of the GNU General Public License 21along with GCC; see the file COPYING. If not, write to the Free 22Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 2302110-1301, USA. */ 24 25/* TODO: Emit .debug_line header even when there are no functions, since 26 the file numbers are used by .debug_info. Alternately, leave 27 out locations for types and decls. 28 Avoid talking about ctors and op= for PODs. 29 Factor out common prologue sequences into multiple CIEs. */ 30 31/* The first part of this file deals with the DWARF 2 frame unwind 32 information, which is also used by the GCC efficient exception handling 33 mechanism. The second part, controlled only by an #ifdef 34 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging 35 information. */ 36 37#include "config.h" 38#include "system.h" 39#include "coretypes.h" 40#include "tm.h" 41#include "tree.h" 42#include "version.h" 43#include "flags.h" 44#include "real.h" 45#include "rtl.h" 46#include "hard-reg-set.h" 47#include "regs.h" 48#include "insn-config.h" 49#include "reload.h" 50#include "function.h" 51#include "output.h" 52#include "expr.h" 53#include "libfuncs.h" 54#include "except.h" 55#include "dwarf2.h" 56#include "dwarf2out.h" 57#include "dwarf2asm.h" 58#include "toplev.h" 59#include "varray.h" 60#include "ggc.h" 61#include "md5.h" 62#include "tm_p.h" 63#include "diagnostic.h" 64#include "debug.h" 65#include "target.h" 66#include "langhooks.h" 67#include "hashtab.h" 68#include "cgraph.h" 69#include "input.h" 70 71#ifdef DWARF2_DEBUGGING_INFO 72static void dwarf2out_source_line (unsigned int, const char *); 73#endif 74 75/* DWARF2 Abbreviation Glossary: 76 CFA = Canonical Frame Address 77 a fixed address on the stack which identifies a call frame. 78 We define it to be the value of SP just before the call insn. 79 The CFA register and offset, which may change during the course 80 of the function, are used to calculate its value at runtime. 81 CFI = Call Frame Instruction 82 an instruction for the DWARF2 abstract machine 83 CIE = Common Information Entry 84 information describing information common to one or more FDEs 85 DIE = Debugging Information Entry 86 FDE = Frame Description Entry 87 information describing the stack call frame, in particular, 88 how to restore registers 89 90 DW_CFA_... = DWARF2 CFA call frame instruction 91 DW_TAG_... = DWARF2 DIE tag */ 92 93#ifndef DWARF2_FRAME_INFO 94# ifdef DWARF2_DEBUGGING_INFO 95# define DWARF2_FRAME_INFO \ 96 (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG) 97# else 98# define DWARF2_FRAME_INFO 0 99# endif 100#endif 101 102/* Map register numbers held in the call frame info that gcc has 103 collected using DWARF_FRAME_REGNUM to those that should be output in 104 .debug_frame and .eh_frame. */ 105#ifndef DWARF2_FRAME_REG_OUT 106#define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO) 107#endif 108 109/* Decide whether we want to emit frame unwind information for the current 110 translation unit. */ 111 112int 113dwarf2out_do_frame (void) 114{ 115 /* We want to emit correct CFA location expressions or lists, so we 116 have to return true if we're going to output debug info, even if 117 we're not going to output frame or unwind info. */ 118 return (write_symbols == DWARF2_DEBUG 119 || write_symbols == VMS_AND_DWARF2_DEBUG 120 || DWARF2_FRAME_INFO 121#ifdef DWARF2_UNWIND_INFO 122 || (DWARF2_UNWIND_INFO 123 && (flag_unwind_tables 124 || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS))) 125#endif 126 ); 127} 128 129/* The size of the target's pointer type. */ 130#ifndef PTR_SIZE 131#define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT) 132#endif 133 134/* Array of RTXes referenced by the debugging information, which therefore 135 must be kept around forever. */ 136static GTY(()) VEC(rtx,gc) *used_rtx_array; 137 138/* A pointer to the base of a list of incomplete types which might be 139 completed at some later time. incomplete_types_list needs to be a 140 VEC(tree,gc) because we want to tell the garbage collector about 141 it. */ 142static GTY(()) VEC(tree,gc) *incomplete_types; 143 144/* A pointer to the base of a table of references to declaration 145 scopes. This table is a display which tracks the nesting 146 of declaration scopes at the current scope and containing 147 scopes. This table is used to find the proper place to 148 define type declaration DIE's. */ 149static GTY(()) VEC(tree,gc) *decl_scope_table; 150 151/* Pointers to various DWARF2 sections. */ 152static GTY(()) section *debug_info_section; 153static GTY(()) section *debug_abbrev_section; 154static GTY(()) section *debug_aranges_section; 155static GTY(()) section *debug_macinfo_section; 156static GTY(()) section *debug_line_section; 157static GTY(()) section *debug_loc_section; 158static GTY(()) section *debug_pubnames_section; 159static GTY(()) section *debug_str_section; 160static GTY(()) section *debug_ranges_section; 161static GTY(()) section *debug_frame_section; 162 163/* How to start an assembler comment. */ 164#ifndef ASM_COMMENT_START 165#define ASM_COMMENT_START ";#" 166#endif 167 168typedef struct dw_cfi_struct *dw_cfi_ref; 169typedef struct dw_fde_struct *dw_fde_ref; 170typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref; 171 172/* Call frames are described using a sequence of Call Frame 173 Information instructions. The register number, offset 174 and address fields are provided as possible operands; 175 their use is selected by the opcode field. */ 176 177enum dw_cfi_oprnd_type { 178 dw_cfi_oprnd_unused, 179 dw_cfi_oprnd_reg_num, 180 dw_cfi_oprnd_offset, 181 dw_cfi_oprnd_addr, 182 dw_cfi_oprnd_loc 183}; 184 185typedef union dw_cfi_oprnd_struct GTY(()) 186{ 187 unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num; 188 HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset; 189 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr; 190 struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc; 191} 192dw_cfi_oprnd; 193 194typedef struct dw_cfi_struct GTY(()) 195{ 196 dw_cfi_ref dw_cfi_next; 197 enum dwarf_call_frame_info dw_cfi_opc; 198 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)"))) 199 dw_cfi_oprnd1; 200 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)"))) 201 dw_cfi_oprnd2; 202} 203dw_cfi_node; 204 205/* This is how we define the location of the CFA. We use to handle it 206 as REG + OFFSET all the time, but now it can be more complex. 207 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET. 208 Instead of passing around REG and OFFSET, we pass a copy 209 of this structure. */ 210typedef struct cfa_loc GTY(()) 211{ 212 HOST_WIDE_INT offset; 213 HOST_WIDE_INT base_offset; 214 unsigned int reg; 215 int indirect; /* 1 if CFA is accessed via a dereference. */ 216} dw_cfa_location; 217 218/* All call frame descriptions (FDE's) in the GCC generated DWARF 219 refer to a single Common Information Entry (CIE), defined at 220 the beginning of the .debug_frame section. This use of a single 221 CIE obviates the need to keep track of multiple CIE's 222 in the DWARF generation routines below. */ 223 224typedef struct dw_fde_struct GTY(()) 225{ 226 tree decl; 227 const char *dw_fde_begin; 228 const char *dw_fde_current_label; 229 const char *dw_fde_end; 230 const char *dw_fde_hot_section_label; 231 const char *dw_fde_hot_section_end_label; 232 const char *dw_fde_unlikely_section_label; 233 const char *dw_fde_unlikely_section_end_label; 234 bool dw_fde_switched_sections; 235 dw_cfi_ref dw_fde_cfi; 236 unsigned funcdef_number; 237 unsigned all_throwers_are_sibcalls : 1; 238 unsigned nothrow : 1; 239 unsigned uses_eh_lsda : 1; 240} 241dw_fde_node; 242 243/* Maximum size (in bytes) of an artificially generated label. */ 244#define MAX_ARTIFICIAL_LABEL_BYTES 30 245 246/* The size of addresses as they appear in the Dwarf 2 data. 247 Some architectures use word addresses to refer to code locations, 248 but Dwarf 2 info always uses byte addresses. On such machines, 249 Dwarf 2 addresses need to be larger than the architecture's 250 pointers. */ 251#ifndef DWARF2_ADDR_SIZE 252#define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT) 253#endif 254 255/* The size in bytes of a DWARF field indicating an offset or length 256 relative to a debug info section, specified to be 4 bytes in the 257 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same 258 as PTR_SIZE. */ 259 260#ifndef DWARF_OFFSET_SIZE 261#define DWARF_OFFSET_SIZE 4 262#endif 263 264/* According to the (draft) DWARF 3 specification, the initial length 265 should either be 4 or 12 bytes. When it's 12 bytes, the first 4 266 bytes are 0xffffffff, followed by the length stored in the next 8 267 bytes. 268 269 However, the SGI/MIPS ABI uses an initial length which is equal to 270 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */ 271 272#ifndef DWARF_INITIAL_LENGTH_SIZE 273#define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12) 274#endif 275 276#define DWARF_VERSION 2 277 278/* Round SIZE up to the nearest BOUNDARY. */ 279#define DWARF_ROUND(SIZE,BOUNDARY) \ 280 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY)) 281 282/* Offsets recorded in opcodes are a multiple of this alignment factor. */ 283#ifndef DWARF_CIE_DATA_ALIGNMENT 284#ifdef STACK_GROWS_DOWNWARD 285#define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD)) 286#else 287#define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD) 288#endif 289#endif 290 291/* CIE identifier. */ 292#if HOST_BITS_PER_WIDE_INT >= 64 293#define DWARF_CIE_ID \ 294 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID) 295#else 296#define DWARF_CIE_ID DW_CIE_ID 297#endif 298 299/* A pointer to the base of a table that contains frame description 300 information for each routine. */ 301static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table; 302 303/* Number of elements currently allocated for fde_table. */ 304static GTY(()) unsigned fde_table_allocated; 305 306/* Number of elements in fde_table currently in use. */ 307static GTY(()) unsigned fde_table_in_use; 308 309/* Size (in elements) of increments by which we may expand the 310 fde_table. */ 311#define FDE_TABLE_INCREMENT 256 312 313/* A list of call frame insns for the CIE. */ 314static GTY(()) dw_cfi_ref cie_cfi_head; 315 316#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 317/* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram 318 attribute that accelerates the lookup of the FDE associated 319 with the subprogram. This variable holds the table index of the FDE 320 associated with the current function (body) definition. */ 321static unsigned current_funcdef_fde; 322#endif 323 324struct indirect_string_node GTY(()) 325{ 326 const char *str; 327 unsigned int refcount; 328 unsigned int form; 329 char *label; 330}; 331 332static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash; 333 334static GTY(()) int dw2_string_counter; 335static GTY(()) unsigned long dwarf2out_cfi_label_num; 336 337#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 338 339/* Forward declarations for functions defined in this file. */ 340 341static char *stripattributes (const char *); 342static const char *dwarf_cfi_name (unsigned); 343static dw_cfi_ref new_cfi (void); 344static void add_cfi (dw_cfi_ref *, dw_cfi_ref); 345static void add_fde_cfi (const char *, dw_cfi_ref); 346static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *); 347static void lookup_cfa (dw_cfa_location *); 348static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT); 349static void initial_return_save (rtx); 350static HOST_WIDE_INT stack_adjust_offset (rtx); 351static void output_cfi (dw_cfi_ref, dw_fde_ref, int); 352static void output_call_frame_info (int); 353static void dwarf2out_stack_adjust (rtx, bool); 354static void flush_queued_reg_saves (void); 355static bool clobbers_queued_reg_save (rtx); 356static void dwarf2out_frame_debug_expr (rtx, const char *); 357 358/* Support for complex CFA locations. */ 359static void output_cfa_loc (dw_cfi_ref); 360static void get_cfa_from_loc_descr (dw_cfa_location *, 361 struct dw_loc_descr_struct *); 362static struct dw_loc_descr_struct *build_cfa_loc 363 (dw_cfa_location *, HOST_WIDE_INT); 364static void def_cfa_1 (const char *, dw_cfa_location *); 365 366/* How to start an assembler comment. */ 367#ifndef ASM_COMMENT_START 368#define ASM_COMMENT_START ";#" 369#endif 370 371/* Data and reference forms for relocatable data. */ 372#define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4) 373#define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4) 374 375#ifndef DEBUG_FRAME_SECTION 376#define DEBUG_FRAME_SECTION ".debug_frame" 377#endif 378 379#ifndef FUNC_BEGIN_LABEL 380#define FUNC_BEGIN_LABEL "LFB" 381#endif 382 383#ifndef FUNC_END_LABEL 384#define FUNC_END_LABEL "LFE" 385#endif 386 387#ifndef FRAME_BEGIN_LABEL 388#define FRAME_BEGIN_LABEL "Lframe" 389#endif 390#define CIE_AFTER_SIZE_LABEL "LSCIE" 391#define CIE_END_LABEL "LECIE" 392#define FDE_LABEL "LSFDE" 393#define FDE_AFTER_SIZE_LABEL "LASFDE" 394#define FDE_END_LABEL "LEFDE" 395#define LINE_NUMBER_BEGIN_LABEL "LSLT" 396#define LINE_NUMBER_END_LABEL "LELT" 397#define LN_PROLOG_AS_LABEL "LASLTP" 398#define LN_PROLOG_END_LABEL "LELTP" 399#define DIE_LABEL_PREFIX "DW" 400 401/* The DWARF 2 CFA column which tracks the return address. Normally this 402 is the column for PC, or the first column after all of the hard 403 registers. */ 404#ifndef DWARF_FRAME_RETURN_COLUMN 405#ifdef PC_REGNUM 406#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM) 407#else 408#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS 409#endif 410#endif 411 412/* The mapping from gcc register number to DWARF 2 CFA column number. By 413 default, we just provide columns for all registers. */ 414#ifndef DWARF_FRAME_REGNUM 415#define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG) 416#endif 417 418/* Hook used by __throw. */ 419 420rtx 421expand_builtin_dwarf_sp_column (void) 422{ 423 unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM); 424 return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1)); 425} 426 427/* Return a pointer to a copy of the section string name S with all 428 attributes stripped off, and an asterisk prepended (for assemble_name). */ 429 430static inline char * 431stripattributes (const char *s) 432{ 433 char *stripped = XNEWVEC (char, strlen (s) + 2); 434 char *p = stripped; 435 436 *p++ = '*'; 437 438 while (*s && *s != ',') 439 *p++ = *s++; 440 441 *p = '\0'; 442 return stripped; 443} 444 445/* Generate code to initialize the register size table. */ 446 447void 448expand_builtin_init_dwarf_reg_sizes (tree address) 449{ 450 unsigned int i; 451 enum machine_mode mode = TYPE_MODE (char_type_node); 452 rtx addr = expand_normal (address); 453 rtx mem = gen_rtx_MEM (BLKmode, addr); 454 bool wrote_return_column = false; 455 456 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) 457 { 458 int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1); 459 460 if (rnum < DWARF_FRAME_REGISTERS) 461 { 462 HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode); 463 enum machine_mode save_mode = reg_raw_mode[i]; 464 HOST_WIDE_INT size; 465 466 if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode)) 467 save_mode = choose_hard_reg_mode (i, 1, true); 468 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN) 469 { 470 if (save_mode == VOIDmode) 471 continue; 472 wrote_return_column = true; 473 } 474 size = GET_MODE_SIZE (save_mode); 475 if (offset < 0) 476 continue; 477 478 emit_move_insn (adjust_address (mem, mode, offset), 479 gen_int_mode (size, mode)); 480 } 481 } 482 483#ifdef DWARF_ALT_FRAME_RETURN_COLUMN 484 gcc_assert (wrote_return_column); 485 i = DWARF_ALT_FRAME_RETURN_COLUMN; 486 wrote_return_column = false; 487#else 488 i = DWARF_FRAME_RETURN_COLUMN; 489#endif 490 491 if (! wrote_return_column) 492 { 493 enum machine_mode save_mode = Pmode; 494 HOST_WIDE_INT offset = i * GET_MODE_SIZE (mode); 495 HOST_WIDE_INT size = GET_MODE_SIZE (save_mode); 496 emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size)); 497 } 498} 499 500/* Convert a DWARF call frame info. operation to its string name */ 501 502static const char * 503dwarf_cfi_name (unsigned int cfi_opc) 504{ 505 switch (cfi_opc) 506 { 507 case DW_CFA_advance_loc: 508 return "DW_CFA_advance_loc"; 509 case DW_CFA_offset: 510 return "DW_CFA_offset"; 511 case DW_CFA_restore: 512 return "DW_CFA_restore"; 513 case DW_CFA_nop: 514 return "DW_CFA_nop"; 515 case DW_CFA_set_loc: 516 return "DW_CFA_set_loc"; 517 case DW_CFA_advance_loc1: 518 return "DW_CFA_advance_loc1"; 519 case DW_CFA_advance_loc2: 520 return "DW_CFA_advance_loc2"; 521 case DW_CFA_advance_loc4: 522 return "DW_CFA_advance_loc4"; 523 case DW_CFA_offset_extended: 524 return "DW_CFA_offset_extended"; 525 case DW_CFA_restore_extended: 526 return "DW_CFA_restore_extended"; 527 case DW_CFA_undefined: 528 return "DW_CFA_undefined"; 529 case DW_CFA_same_value: 530 return "DW_CFA_same_value"; 531 case DW_CFA_register: 532 return "DW_CFA_register"; 533 case DW_CFA_remember_state: 534 return "DW_CFA_remember_state"; 535 case DW_CFA_restore_state: 536 return "DW_CFA_restore_state"; 537 case DW_CFA_def_cfa: 538 return "DW_CFA_def_cfa"; 539 case DW_CFA_def_cfa_register: 540 return "DW_CFA_def_cfa_register"; 541 case DW_CFA_def_cfa_offset: 542 return "DW_CFA_def_cfa_offset"; 543 544 /* DWARF 3 */ 545 case DW_CFA_def_cfa_expression: 546 return "DW_CFA_def_cfa_expression"; 547 case DW_CFA_expression: 548 return "DW_CFA_expression"; 549 case DW_CFA_offset_extended_sf: 550 return "DW_CFA_offset_extended_sf"; 551 case DW_CFA_def_cfa_sf: 552 return "DW_CFA_def_cfa_sf"; 553 case DW_CFA_def_cfa_offset_sf: 554 return "DW_CFA_def_cfa_offset_sf"; 555 556 /* SGI/MIPS specific */ 557 case DW_CFA_MIPS_advance_loc8: 558 return "DW_CFA_MIPS_advance_loc8"; 559 560 /* GNU extensions */ 561 case DW_CFA_GNU_window_save: 562 return "DW_CFA_GNU_window_save"; 563 case DW_CFA_GNU_args_size: 564 return "DW_CFA_GNU_args_size"; 565 case DW_CFA_GNU_negative_offset_extended: 566 return "DW_CFA_GNU_negative_offset_extended"; 567 568 default: 569 return "DW_CFA_<unknown>"; 570 } 571} 572 573/* Return a pointer to a newly allocated Call Frame Instruction. */ 574 575static inline dw_cfi_ref 576new_cfi (void) 577{ 578 dw_cfi_ref cfi = ggc_alloc (sizeof (dw_cfi_node)); 579 580 cfi->dw_cfi_next = NULL; 581 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0; 582 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0; 583 584 return cfi; 585} 586 587/* Add a Call Frame Instruction to list of instructions. */ 588 589static inline void 590add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi) 591{ 592 dw_cfi_ref *p; 593 594 /* Find the end of the chain. */ 595 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next) 596 ; 597 598 *p = cfi; 599} 600 601/* Generate a new label for the CFI info to refer to. */ 602 603char * 604dwarf2out_cfi_label (void) 605{ 606 static char label[20]; 607 608 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++); 609 ASM_OUTPUT_LABEL (asm_out_file, label); 610 return label; 611} 612 613/* Add CFI to the current fde at the PC value indicated by LABEL if specified, 614 or to the CIE if LABEL is NULL. */ 615 616static void 617add_fde_cfi (const char *label, dw_cfi_ref cfi) 618{ 619 if (label) 620 { 621 dw_fde_ref fde = &fde_table[fde_table_in_use - 1]; 622 623 if (*label == 0) 624 label = dwarf2out_cfi_label (); 625 626 if (fde->dw_fde_current_label == NULL 627 || strcmp (label, fde->dw_fde_current_label) != 0) 628 { 629 dw_cfi_ref xcfi; 630 631 label = xstrdup (label); 632 633 /* Set the location counter to the new label. */ 634 xcfi = new_cfi (); 635 /* If we have a current label, advance from there, otherwise 636 set the location directly using set_loc. */ 637 xcfi->dw_cfi_opc = fde->dw_fde_current_label 638 ? DW_CFA_advance_loc4 639 : DW_CFA_set_loc; 640 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label; 641 add_cfi (&fde->dw_fde_cfi, xcfi); 642 643 fde->dw_fde_current_label = label; 644 } 645 646 add_cfi (&fde->dw_fde_cfi, cfi); 647 } 648 649 else 650 add_cfi (&cie_cfi_head, cfi); 651} 652 653/* Subroutine of lookup_cfa. */ 654 655static void 656lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc) 657{ 658 switch (cfi->dw_cfi_opc) 659 { 660 case DW_CFA_def_cfa_offset: 661 loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset; 662 break; 663 case DW_CFA_def_cfa_offset_sf: 664 loc->offset 665 = cfi->dw_cfi_oprnd1.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT; 666 break; 667 case DW_CFA_def_cfa_register: 668 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num; 669 break; 670 case DW_CFA_def_cfa: 671 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num; 672 loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset; 673 break; 674 case DW_CFA_def_cfa_sf: 675 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num; 676 loc->offset 677 = cfi->dw_cfi_oprnd2.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT; 678 break; 679 case DW_CFA_def_cfa_expression: 680 get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc); 681 break; 682 default: 683 break; 684 } 685} 686 687/* Find the previous value for the CFA. */ 688 689static void 690lookup_cfa (dw_cfa_location *loc) 691{ 692 dw_cfi_ref cfi; 693 694 loc->reg = INVALID_REGNUM; 695 loc->offset = 0; 696 loc->indirect = 0; 697 loc->base_offset = 0; 698 699 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next) 700 lookup_cfa_1 (cfi, loc); 701 702 if (fde_table_in_use) 703 { 704 dw_fde_ref fde = &fde_table[fde_table_in_use - 1]; 705 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next) 706 lookup_cfa_1 (cfi, loc); 707 } 708} 709 710/* The current rule for calculating the DWARF2 canonical frame address. */ 711static dw_cfa_location cfa; 712 713/* The register used for saving registers to the stack, and its offset 714 from the CFA. */ 715static dw_cfa_location cfa_store; 716 717/* The running total of the size of arguments pushed onto the stack. */ 718static HOST_WIDE_INT args_size; 719 720/* The last args_size we actually output. */ 721static HOST_WIDE_INT old_args_size; 722 723/* Entry point to update the canonical frame address (CFA). 724 LABEL is passed to add_fde_cfi. The value of CFA is now to be 725 calculated from REG+OFFSET. */ 726 727void 728dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset) 729{ 730 dw_cfa_location loc; 731 loc.indirect = 0; 732 loc.base_offset = 0; 733 loc.reg = reg; 734 loc.offset = offset; 735 def_cfa_1 (label, &loc); 736} 737 738/* Determine if two dw_cfa_location structures define the same data. */ 739 740static bool 741cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2) 742{ 743 return (loc1->reg == loc2->reg 744 && loc1->offset == loc2->offset 745 && loc1->indirect == loc2->indirect 746 && (loc1->indirect == 0 747 || loc1->base_offset == loc2->base_offset)); 748} 749 750/* This routine does the actual work. The CFA is now calculated from 751 the dw_cfa_location structure. */ 752 753static void 754def_cfa_1 (const char *label, dw_cfa_location *loc_p) 755{ 756 dw_cfi_ref cfi; 757 dw_cfa_location old_cfa, loc; 758 759 cfa = *loc_p; 760 loc = *loc_p; 761 762 if (cfa_store.reg == loc.reg && loc.indirect == 0) 763 cfa_store.offset = loc.offset; 764 765 loc.reg = DWARF_FRAME_REGNUM (loc.reg); 766 lookup_cfa (&old_cfa); 767 768 /* If nothing changed, no need to issue any call frame instructions. */ 769 if (cfa_equal_p (&loc, &old_cfa)) 770 return; 771 772 cfi = new_cfi (); 773 774 if (loc.reg == old_cfa.reg && !loc.indirect) 775 { 776 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating 777 the CFA register did not change but the offset did. */ 778 if (loc.offset < 0) 779 { 780 HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT; 781 gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset); 782 783 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf; 784 cfi->dw_cfi_oprnd1.dw_cfi_offset = f_offset; 785 } 786 else 787 { 788 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset; 789 cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset; 790 } 791 } 792 793#ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */ 794 else if (loc.offset == old_cfa.offset 795 && old_cfa.reg != INVALID_REGNUM 796 && !loc.indirect) 797 { 798 /* Construct a "DW_CFA_def_cfa_register <register>" instruction, 799 indicating the CFA register has changed to <register> but the 800 offset has not changed. */ 801 cfi->dw_cfi_opc = DW_CFA_def_cfa_register; 802 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg; 803 } 804#endif 805 806 else if (loc.indirect == 0) 807 { 808 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction, 809 indicating the CFA register has changed to <register> with 810 the specified offset. */ 811 if (loc.offset < 0) 812 { 813 HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT; 814 gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset); 815 816 cfi->dw_cfi_opc = DW_CFA_def_cfa_sf; 817 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg; 818 cfi->dw_cfi_oprnd2.dw_cfi_offset = f_offset; 819 } 820 else 821 { 822 cfi->dw_cfi_opc = DW_CFA_def_cfa; 823 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg; 824 cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset; 825 } 826 } 827 else 828 { 829 /* Construct a DW_CFA_def_cfa_expression instruction to 830 calculate the CFA using a full location expression since no 831 register-offset pair is available. */ 832 struct dw_loc_descr_struct *loc_list; 833 834 cfi->dw_cfi_opc = DW_CFA_def_cfa_expression; 835 loc_list = build_cfa_loc (&loc, 0); 836 cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list; 837 } 838 839 add_fde_cfi (label, cfi); 840} 841 842/* Add the CFI for saving a register. REG is the CFA column number. 843 LABEL is passed to add_fde_cfi. 844 If SREG is -1, the register is saved at OFFSET from the CFA; 845 otherwise it is saved in SREG. */ 846 847static void 848reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset) 849{ 850 dw_cfi_ref cfi = new_cfi (); 851 852 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg; 853 854 if (sreg == INVALID_REGNUM) 855 { 856 if (reg & ~0x3f) 857 /* The register number won't fit in 6 bits, so we have to use 858 the long form. */ 859 cfi->dw_cfi_opc = DW_CFA_offset_extended; 860 else 861 cfi->dw_cfi_opc = DW_CFA_offset; 862 863#ifdef ENABLE_CHECKING 864 { 865 /* If we get an offset that is not a multiple of 866 DWARF_CIE_DATA_ALIGNMENT, there is either a bug in the 867 definition of DWARF_CIE_DATA_ALIGNMENT, or a bug in the machine 868 description. */ 869 HOST_WIDE_INT check_offset = offset / DWARF_CIE_DATA_ALIGNMENT; 870 871 gcc_assert (check_offset * DWARF_CIE_DATA_ALIGNMENT == offset); 872 } 873#endif 874 offset /= DWARF_CIE_DATA_ALIGNMENT; 875 if (offset < 0) 876 cfi->dw_cfi_opc = DW_CFA_offset_extended_sf; 877 878 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset; 879 } 880 else if (sreg == reg) 881 cfi->dw_cfi_opc = DW_CFA_same_value; 882 else 883 { 884 cfi->dw_cfi_opc = DW_CFA_register; 885 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg; 886 } 887 888 add_fde_cfi (label, cfi); 889} 890 891/* Add the CFI for saving a register window. LABEL is passed to reg_save. 892 This CFI tells the unwinder that it needs to restore the window registers 893 from the previous frame's window save area. 894 895 ??? Perhaps we should note in the CIE where windows are saved (instead of 896 assuming 0(cfa)) and what registers are in the window. */ 897 898void 899dwarf2out_window_save (const char *label) 900{ 901 dw_cfi_ref cfi = new_cfi (); 902 903 cfi->dw_cfi_opc = DW_CFA_GNU_window_save; 904 add_fde_cfi (label, cfi); 905} 906 907/* Add a CFI to update the running total of the size of arguments 908 pushed onto the stack. */ 909 910void 911dwarf2out_args_size (const char *label, HOST_WIDE_INT size) 912{ 913 dw_cfi_ref cfi; 914 915 if (size == old_args_size) 916 return; 917 918 old_args_size = size; 919 920 cfi = new_cfi (); 921 cfi->dw_cfi_opc = DW_CFA_GNU_args_size; 922 cfi->dw_cfi_oprnd1.dw_cfi_offset = size; 923 add_fde_cfi (label, cfi); 924} 925 926/* Entry point for saving a register to the stack. REG is the GCC register 927 number. LABEL and OFFSET are passed to reg_save. */ 928 929void 930dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset) 931{ 932 reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset); 933} 934 935/* Entry point for saving the return address in the stack. 936 LABEL and OFFSET are passed to reg_save. */ 937 938void 939dwarf2out_return_save (const char *label, HOST_WIDE_INT offset) 940{ 941 reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset); 942} 943 944/* Entry point for saving the return address in a register. 945 LABEL and SREG are passed to reg_save. */ 946 947void 948dwarf2out_return_reg (const char *label, unsigned int sreg) 949{ 950 reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0); 951} 952 953/* Record the initial position of the return address. RTL is 954 INCOMING_RETURN_ADDR_RTX. */ 955 956static void 957initial_return_save (rtx rtl) 958{ 959 unsigned int reg = INVALID_REGNUM; 960 HOST_WIDE_INT offset = 0; 961 962 switch (GET_CODE (rtl)) 963 { 964 case REG: 965 /* RA is in a register. */ 966 reg = DWARF_FRAME_REGNUM (REGNO (rtl)); 967 break; 968 969 case MEM: 970 /* RA is on the stack. */ 971 rtl = XEXP (rtl, 0); 972 switch (GET_CODE (rtl)) 973 { 974 case REG: 975 gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM); 976 offset = 0; 977 break; 978 979 case PLUS: 980 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM); 981 offset = INTVAL (XEXP (rtl, 1)); 982 break; 983 984 case MINUS: 985 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM); 986 offset = -INTVAL (XEXP (rtl, 1)); 987 break; 988 989 default: 990 gcc_unreachable (); 991 } 992 993 break; 994 995 case PLUS: 996 /* The return address is at some offset from any value we can 997 actually load. For instance, on the SPARC it is in %i7+8. Just 998 ignore the offset for now; it doesn't matter for unwinding frames. */ 999 gcc_assert (GET_CODE (XEXP (rtl, 1)) == CONST_INT); 1000 initial_return_save (XEXP (rtl, 0)); 1001 return; 1002 1003 default: 1004 gcc_unreachable (); 1005 } 1006 1007 if (reg != DWARF_FRAME_RETURN_COLUMN) 1008 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset); 1009} 1010 1011/* Given a SET, calculate the amount of stack adjustment it 1012 contains. */ 1013 1014static HOST_WIDE_INT 1015stack_adjust_offset (rtx pattern) 1016{ 1017 rtx src = SET_SRC (pattern); 1018 rtx dest = SET_DEST (pattern); 1019 HOST_WIDE_INT offset = 0; 1020 enum rtx_code code; 1021 1022 if (dest == stack_pointer_rtx) 1023 { 1024 /* (set (reg sp) (plus (reg sp) (const_int))) */ 1025 code = GET_CODE (src); 1026 if (! (code == PLUS || code == MINUS) 1027 || XEXP (src, 0) != stack_pointer_rtx 1028 || GET_CODE (XEXP (src, 1)) != CONST_INT) 1029 return 0; 1030 1031 offset = INTVAL (XEXP (src, 1)); 1032 if (code == PLUS) 1033 offset = -offset; 1034 } 1035 else if (MEM_P (dest)) 1036 { 1037 /* (set (mem (pre_dec (reg sp))) (foo)) */ 1038 src = XEXP (dest, 0); 1039 code = GET_CODE (src); 1040 1041 switch (code) 1042 { 1043 case PRE_MODIFY: 1044 case POST_MODIFY: 1045 if (XEXP (src, 0) == stack_pointer_rtx) 1046 { 1047 rtx val = XEXP (XEXP (src, 1), 1); 1048 /* We handle only adjustments by constant amount. */ 1049 gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS 1050 && GET_CODE (val) == CONST_INT); 1051 offset = -INTVAL (val); 1052 break; 1053 } 1054 return 0; 1055 1056 case PRE_DEC: 1057 case POST_DEC: 1058 if (XEXP (src, 0) == stack_pointer_rtx) 1059 { 1060 offset = GET_MODE_SIZE (GET_MODE (dest)); 1061 break; 1062 } 1063 return 0; 1064 1065 case PRE_INC: 1066 case POST_INC: 1067 if (XEXP (src, 0) == stack_pointer_rtx) 1068 { 1069 offset = -GET_MODE_SIZE (GET_MODE (dest)); 1070 break; 1071 } 1072 return 0; 1073 1074 default: 1075 return 0; 1076 } 1077 } 1078 else 1079 return 0; 1080 1081 return offset; 1082} 1083 1084/* Check INSN to see if it looks like a push or a stack adjustment, and 1085 make a note of it if it does. EH uses this information to find out how 1086 much extra space it needs to pop off the stack. */ 1087 1088static void 1089dwarf2out_stack_adjust (rtx insn, bool after_p) 1090{ 1091 HOST_WIDE_INT offset; 1092 const char *label; 1093 int i; 1094 1095 /* Don't handle epilogues at all. Certainly it would be wrong to do so 1096 with this function. Proper support would require all frame-related 1097 insns to be marked, and to be able to handle saving state around 1098 epilogues textually in the middle of the function. */ 1099 if (prologue_epilogue_contains (insn) || sibcall_epilogue_contains (insn)) 1100 return; 1101 1102 /* If only calls can throw, and we have a frame pointer, 1103 save up adjustments until we see the CALL_INSN. */ 1104 if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM) 1105 { 1106 if (CALL_P (insn) && !after_p) 1107 { 1108 /* Extract the size of the args from the CALL rtx itself. */ 1109 insn = PATTERN (insn); 1110 if (GET_CODE (insn) == PARALLEL) 1111 insn = XVECEXP (insn, 0, 0); 1112 if (GET_CODE (insn) == SET) 1113 insn = SET_SRC (insn); 1114 gcc_assert (GET_CODE (insn) == CALL); 1115 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1))); 1116 } 1117 return; 1118 } 1119 1120 if (CALL_P (insn) && !after_p) 1121 { 1122 if (!flag_asynchronous_unwind_tables) 1123 dwarf2out_args_size ("", args_size); 1124 return; 1125 } 1126 else if (BARRIER_P (insn)) 1127 { 1128 /* When we see a BARRIER, we know to reset args_size to 0. Usually 1129 the compiler will have already emitted a stack adjustment, but 1130 doesn't bother for calls to noreturn functions. */ 1131#ifdef STACK_GROWS_DOWNWARD 1132 offset = -args_size; 1133#else 1134 offset = args_size; 1135#endif 1136 } 1137 else if (GET_CODE (PATTERN (insn)) == SET) 1138 offset = stack_adjust_offset (PATTERN (insn)); 1139 else if (GET_CODE (PATTERN (insn)) == PARALLEL 1140 || GET_CODE (PATTERN (insn)) == SEQUENCE) 1141 { 1142 /* There may be stack adjustments inside compound insns. Search 1143 for them. */ 1144 for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--) 1145 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET) 1146 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i)); 1147 } 1148 else 1149 return; 1150 1151 if (offset == 0) 1152 return; 1153 1154 if (cfa.reg == STACK_POINTER_REGNUM) 1155 cfa.offset += offset; 1156 1157#ifndef STACK_GROWS_DOWNWARD 1158 offset = -offset; 1159#endif 1160 1161 args_size += offset; 1162 if (args_size < 0) 1163 args_size = 0; 1164 1165 label = dwarf2out_cfi_label (); 1166 def_cfa_1 (label, &cfa); 1167 if (flag_asynchronous_unwind_tables) 1168 dwarf2out_args_size (label, args_size); 1169} 1170 1171#endif 1172 1173/* We delay emitting a register save until either (a) we reach the end 1174 of the prologue or (b) the register is clobbered. This clusters 1175 register saves so that there are fewer pc advances. */ 1176 1177struct queued_reg_save GTY(()) 1178{ 1179 struct queued_reg_save *next; 1180 rtx reg; 1181 HOST_WIDE_INT cfa_offset; 1182 rtx saved_reg; 1183}; 1184 1185static GTY(()) struct queued_reg_save *queued_reg_saves; 1186 1187/* The caller's ORIG_REG is saved in SAVED_IN_REG. */ 1188struct reg_saved_in_data GTY(()) { 1189 rtx orig_reg; 1190 rtx saved_in_reg; 1191}; 1192 1193/* A list of registers saved in other registers. 1194 The list intentionally has a small maximum capacity of 4; if your 1195 port needs more than that, you might consider implementing a 1196 more efficient data structure. */ 1197static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4]; 1198static GTY(()) size_t num_regs_saved_in_regs; 1199 1200#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 1201static const char *last_reg_save_label; 1202 1203/* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at 1204 SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */ 1205 1206static void 1207queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset) 1208{ 1209 struct queued_reg_save *q; 1210 1211 /* Duplicates waste space, but it's also necessary to remove them 1212 for correctness, since the queue gets output in reverse 1213 order. */ 1214 for (q = queued_reg_saves; q != NULL; q = q->next) 1215 if (REGNO (q->reg) == REGNO (reg)) 1216 break; 1217 1218 if (q == NULL) 1219 { 1220 q = ggc_alloc (sizeof (*q)); 1221 q->next = queued_reg_saves; 1222 queued_reg_saves = q; 1223 } 1224 1225 q->reg = reg; 1226 q->cfa_offset = offset; 1227 q->saved_reg = sreg; 1228 1229 last_reg_save_label = label; 1230} 1231 1232/* Output all the entries in QUEUED_REG_SAVES. */ 1233 1234static void 1235flush_queued_reg_saves (void) 1236{ 1237 struct queued_reg_save *q; 1238 1239 for (q = queued_reg_saves; q; q = q->next) 1240 { 1241 size_t i; 1242 unsigned int reg, sreg; 1243 1244 for (i = 0; i < num_regs_saved_in_regs; i++) 1245 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg)) 1246 break; 1247 if (q->saved_reg && i == num_regs_saved_in_regs) 1248 { 1249 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs)); 1250 num_regs_saved_in_regs++; 1251 } 1252 if (i != num_regs_saved_in_regs) 1253 { 1254 regs_saved_in_regs[i].orig_reg = q->reg; 1255 regs_saved_in_regs[i].saved_in_reg = q->saved_reg; 1256 } 1257 1258 reg = DWARF_FRAME_REGNUM (REGNO (q->reg)); 1259 if (q->saved_reg) 1260 sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg)); 1261 else 1262 sreg = INVALID_REGNUM; 1263 reg_save (last_reg_save_label, reg, sreg, q->cfa_offset); 1264 } 1265 1266 queued_reg_saves = NULL; 1267 last_reg_save_label = NULL; 1268} 1269 1270/* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved 1271 location for? Or, does it clobber a register which we've previously 1272 said that some other register is saved in, and for which we now 1273 have a new location for? */ 1274 1275static bool 1276clobbers_queued_reg_save (rtx insn) 1277{ 1278 struct queued_reg_save *q; 1279 1280 for (q = queued_reg_saves; q; q = q->next) 1281 { 1282 size_t i; 1283 if (modified_in_p (q->reg, insn)) 1284 return true; 1285 for (i = 0; i < num_regs_saved_in_regs; i++) 1286 if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg) 1287 && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn)) 1288 return true; 1289 } 1290 1291 return false; 1292} 1293 1294/* Entry point for saving the first register into the second. */ 1295 1296void 1297dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg) 1298{ 1299 size_t i; 1300 unsigned int regno, sregno; 1301 1302 for (i = 0; i < num_regs_saved_in_regs; i++) 1303 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg)) 1304 break; 1305 if (i == num_regs_saved_in_regs) 1306 { 1307 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs)); 1308 num_regs_saved_in_regs++; 1309 } 1310 regs_saved_in_regs[i].orig_reg = reg; 1311 regs_saved_in_regs[i].saved_in_reg = sreg; 1312 1313 regno = DWARF_FRAME_REGNUM (REGNO (reg)); 1314 sregno = DWARF_FRAME_REGNUM (REGNO (sreg)); 1315 reg_save (label, regno, sregno, 0); 1316} 1317 1318/* What register, if any, is currently saved in REG? */ 1319 1320static rtx 1321reg_saved_in (rtx reg) 1322{ 1323 unsigned int regn = REGNO (reg); 1324 size_t i; 1325 struct queued_reg_save *q; 1326 1327 for (q = queued_reg_saves; q; q = q->next) 1328 if (q->saved_reg && regn == REGNO (q->saved_reg)) 1329 return q->reg; 1330 1331 for (i = 0; i < num_regs_saved_in_regs; i++) 1332 if (regs_saved_in_regs[i].saved_in_reg 1333 && regn == REGNO (regs_saved_in_regs[i].saved_in_reg)) 1334 return regs_saved_in_regs[i].orig_reg; 1335 1336 return NULL_RTX; 1337} 1338 1339 1340/* A temporary register holding an integral value used in adjusting SP 1341 or setting up the store_reg. The "offset" field holds the integer 1342 value, not an offset. */ 1343static dw_cfa_location cfa_temp; 1344 1345/* Record call frame debugging information for an expression EXPR, 1346 which either sets SP or FP (adjusting how we calculate the frame 1347 address) or saves a register to the stack or another register. 1348 LABEL indicates the address of EXPR. 1349 1350 This function encodes a state machine mapping rtxes to actions on 1351 cfa, cfa_store, and cfa_temp.reg. We describe these rules so 1352 users need not read the source code. 1353 1354 The High-Level Picture 1355 1356 Changes in the register we use to calculate the CFA: Currently we 1357 assume that if you copy the CFA register into another register, we 1358 should take the other one as the new CFA register; this seems to 1359 work pretty well. If it's wrong for some target, it's simple 1360 enough not to set RTX_FRAME_RELATED_P on the insn in question. 1361 1362 Changes in the register we use for saving registers to the stack: 1363 This is usually SP, but not always. Again, we deduce that if you 1364 copy SP into another register (and SP is not the CFA register), 1365 then the new register is the one we will be using for register 1366 saves. This also seems to work. 1367 1368 Register saves: There's not much guesswork about this one; if 1369 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a 1370 register save, and the register used to calculate the destination 1371 had better be the one we think we're using for this purpose. 1372 It's also assumed that a copy from a call-saved register to another 1373 register is saving that register if RTX_FRAME_RELATED_P is set on 1374 that instruction. If the copy is from a call-saved register to 1375 the *same* register, that means that the register is now the same 1376 value as in the caller. 1377 1378 Except: If the register being saved is the CFA register, and the 1379 offset is nonzero, we are saving the CFA, so we assume we have to 1380 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that 1381 the intent is to save the value of SP from the previous frame. 1382 1383 In addition, if a register has previously been saved to a different 1384 register, 1385 1386 Invariants / Summaries of Rules 1387 1388 cfa current rule for calculating the CFA. It usually 1389 consists of a register and an offset. 1390 cfa_store register used by prologue code to save things to the stack 1391 cfa_store.offset is the offset from the value of 1392 cfa_store.reg to the actual CFA 1393 cfa_temp register holding an integral value. cfa_temp.offset 1394 stores the value, which will be used to adjust the 1395 stack pointer. cfa_temp is also used like cfa_store, 1396 to track stores to the stack via fp or a temp reg. 1397 1398 Rules 1- 4: Setting a register's value to cfa.reg or an expression 1399 with cfa.reg as the first operand changes the cfa.reg and its 1400 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and 1401 cfa_temp.offset. 1402 1403 Rules 6- 9: Set a non-cfa.reg register value to a constant or an 1404 expression yielding a constant. This sets cfa_temp.reg 1405 and cfa_temp.offset. 1406 1407 Rule 5: Create a new register cfa_store used to save items to the 1408 stack. 1409 1410 Rules 10-14: Save a register to the stack. Define offset as the 1411 difference of the original location and cfa_store's 1412 location (or cfa_temp's location if cfa_temp is used). 1413 1414 The Rules 1415 1416 "{a,b}" indicates a choice of a xor b. 1417 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg. 1418 1419 Rule 1: 1420 (set <reg1> <reg2>:cfa.reg) 1421 effects: cfa.reg = <reg1> 1422 cfa.offset unchanged 1423 cfa_temp.reg = <reg1> 1424 cfa_temp.offset = cfa.offset 1425 1426 Rule 2: 1427 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg 1428 {<const_int>,<reg>:cfa_temp.reg})) 1429 effects: cfa.reg = sp if fp used 1430 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp 1431 cfa_store.offset += {+/- <const_int>, cfa_temp.offset} 1432 if cfa_store.reg==sp 1433 1434 Rule 3: 1435 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>)) 1436 effects: cfa.reg = fp 1437 cfa_offset += +/- <const_int> 1438 1439 Rule 4: 1440 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>)) 1441 constraints: <reg1> != fp 1442 <reg1> != sp 1443 effects: cfa.reg = <reg1> 1444 cfa_temp.reg = <reg1> 1445 cfa_temp.offset = cfa.offset 1446 1447 Rule 5: 1448 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg)) 1449 constraints: <reg1> != fp 1450 <reg1> != sp 1451 effects: cfa_store.reg = <reg1> 1452 cfa_store.offset = cfa.offset - cfa_temp.offset 1453 1454 Rule 6: 1455 (set <reg> <const_int>) 1456 effects: cfa_temp.reg = <reg> 1457 cfa_temp.offset = <const_int> 1458 1459 Rule 7: 1460 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>)) 1461 effects: cfa_temp.reg = <reg1> 1462 cfa_temp.offset |= <const_int> 1463 1464 Rule 8: 1465 (set <reg> (high <exp>)) 1466 effects: none 1467 1468 Rule 9: 1469 (set <reg> (lo_sum <exp> <const_int>)) 1470 effects: cfa_temp.reg = <reg> 1471 cfa_temp.offset = <const_int> 1472 1473 Rule 10: 1474 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>) 1475 effects: cfa_store.offset -= <const_int> 1476 cfa.offset = cfa_store.offset if cfa.reg == sp 1477 cfa.reg = sp 1478 cfa.base_offset = -cfa_store.offset 1479 1480 Rule 11: 1481 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>) 1482 effects: cfa_store.offset += -/+ mode_size(mem) 1483 cfa.offset = cfa_store.offset if cfa.reg == sp 1484 cfa.reg = sp 1485 cfa.base_offset = -cfa_store.offset 1486 1487 Rule 12: 1488 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>)) 1489 1490 <reg2>) 1491 effects: cfa.reg = <reg1> 1492 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset 1493 1494 Rule 13: 1495 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>) 1496 effects: cfa.reg = <reg1> 1497 cfa.base_offset = -{cfa_store,cfa_temp}.offset 1498 1499 Rule 14: 1500 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>) 1501 effects: cfa.reg = <reg1> 1502 cfa.base_offset = -cfa_temp.offset 1503 cfa_temp.offset -= mode_size(mem) 1504 1505 Rule 15: 1506 (set <reg> {unspec, unspec_volatile}) 1507 effects: target-dependent */ 1508 1509static void 1510dwarf2out_frame_debug_expr (rtx expr, const char *label) 1511{ 1512 rtx src, dest; 1513 HOST_WIDE_INT offset; 1514 1515 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of 1516 the PARALLEL independently. The first element is always processed if 1517 it is a SET. This is for backward compatibility. Other elements 1518 are processed only if they are SETs and the RTX_FRAME_RELATED_P 1519 flag is set in them. */ 1520 if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE) 1521 { 1522 int par_index; 1523 int limit = XVECLEN (expr, 0); 1524 1525 for (par_index = 0; par_index < limit; par_index++) 1526 if (GET_CODE (XVECEXP (expr, 0, par_index)) == SET 1527 && (RTX_FRAME_RELATED_P (XVECEXP (expr, 0, par_index)) 1528 || par_index == 0)) 1529 dwarf2out_frame_debug_expr (XVECEXP (expr, 0, par_index), label); 1530 1531 return; 1532 } 1533 1534 gcc_assert (GET_CODE (expr) == SET); 1535 1536 src = SET_SRC (expr); 1537 dest = SET_DEST (expr); 1538 1539 if (REG_P (src)) 1540 { 1541 rtx rsi = reg_saved_in (src); 1542 if (rsi) 1543 src = rsi; 1544 } 1545 1546 switch (GET_CODE (dest)) 1547 { 1548 case REG: 1549 switch (GET_CODE (src)) 1550 { 1551 /* Setting FP from SP. */ 1552 case REG: 1553 if (cfa.reg == (unsigned) REGNO (src)) 1554 { 1555 /* Rule 1 */ 1556 /* Update the CFA rule wrt SP or FP. Make sure src is 1557 relative to the current CFA register. 1558 1559 We used to require that dest be either SP or FP, but the 1560 ARM copies SP to a temporary register, and from there to 1561 FP. So we just rely on the backends to only set 1562 RTX_FRAME_RELATED_P on appropriate insns. */ 1563 cfa.reg = REGNO (dest); 1564 cfa_temp.reg = cfa.reg; 1565 cfa_temp.offset = cfa.offset; 1566 } 1567 else 1568 { 1569 /* Saving a register in a register. */ 1570 gcc_assert (!fixed_regs [REGNO (dest)] 1571 /* For the SPARC and its register window. */ 1572 || (DWARF_FRAME_REGNUM (REGNO (src)) 1573 == DWARF_FRAME_RETURN_COLUMN)); 1574 queue_reg_save (label, src, dest, 0); 1575 } 1576 break; 1577 1578 case PLUS: 1579 case MINUS: 1580 case LO_SUM: 1581 if (dest == stack_pointer_rtx) 1582 { 1583 /* Rule 2 */ 1584 /* Adjusting SP. */ 1585 switch (GET_CODE (XEXP (src, 1))) 1586 { 1587 case CONST_INT: 1588 offset = INTVAL (XEXP (src, 1)); 1589 break; 1590 case REG: 1591 gcc_assert ((unsigned) REGNO (XEXP (src, 1)) 1592 == cfa_temp.reg); 1593 offset = cfa_temp.offset; 1594 break; 1595 default: 1596 gcc_unreachable (); 1597 } 1598 1599 if (XEXP (src, 0) == hard_frame_pointer_rtx) 1600 { 1601 /* Restoring SP from FP in the epilogue. */ 1602 gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM); 1603 cfa.reg = STACK_POINTER_REGNUM; 1604 } 1605 else if (GET_CODE (src) == LO_SUM) 1606 /* Assume we've set the source reg of the LO_SUM from sp. */ 1607 ; 1608 else 1609 gcc_assert (XEXP (src, 0) == stack_pointer_rtx); 1610 1611 if (GET_CODE (src) != MINUS) 1612 offset = -offset; 1613 if (cfa.reg == STACK_POINTER_REGNUM) 1614 cfa.offset += offset; 1615 if (cfa_store.reg == STACK_POINTER_REGNUM) 1616 cfa_store.offset += offset; 1617 } 1618 else if (dest == hard_frame_pointer_rtx) 1619 { 1620 /* Rule 3 */ 1621 /* Either setting the FP from an offset of the SP, 1622 or adjusting the FP */ 1623 gcc_assert (frame_pointer_needed); 1624 1625 gcc_assert (REG_P (XEXP (src, 0)) 1626 && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg 1627 && GET_CODE (XEXP (src, 1)) == CONST_INT); 1628 offset = INTVAL (XEXP (src, 1)); 1629 if (GET_CODE (src) != MINUS) 1630 offset = -offset; 1631 cfa.offset += offset; 1632 cfa.reg = HARD_FRAME_POINTER_REGNUM; 1633 } 1634 else 1635 { 1636 gcc_assert (GET_CODE (src) != MINUS); 1637 1638 /* Rule 4 */ 1639 if (REG_P (XEXP (src, 0)) 1640 && REGNO (XEXP (src, 0)) == cfa.reg 1641 && GET_CODE (XEXP (src, 1)) == CONST_INT) 1642 { 1643 /* Setting a temporary CFA register that will be copied 1644 into the FP later on. */ 1645 offset = - INTVAL (XEXP (src, 1)); 1646 cfa.offset += offset; 1647 cfa.reg = REGNO (dest); 1648 /* Or used to save regs to the stack. */ 1649 cfa_temp.reg = cfa.reg; 1650 cfa_temp.offset = cfa.offset; 1651 } 1652 1653 /* Rule 5 */ 1654 else if (REG_P (XEXP (src, 0)) 1655 && REGNO (XEXP (src, 0)) == cfa_temp.reg 1656 && XEXP (src, 1) == stack_pointer_rtx) 1657 { 1658 /* Setting a scratch register that we will use instead 1659 of SP for saving registers to the stack. */ 1660 gcc_assert (cfa.reg == STACK_POINTER_REGNUM); 1661 cfa_store.reg = REGNO (dest); 1662 cfa_store.offset = cfa.offset - cfa_temp.offset; 1663 } 1664 1665 /* Rule 9 */ 1666 else if (GET_CODE (src) == LO_SUM 1667 && GET_CODE (XEXP (src, 1)) == CONST_INT) 1668 { 1669 cfa_temp.reg = REGNO (dest); 1670 cfa_temp.offset = INTVAL (XEXP (src, 1)); 1671 } 1672 else 1673 gcc_unreachable (); 1674 } 1675 break; 1676 1677 /* Rule 6 */ 1678 case CONST_INT: 1679 cfa_temp.reg = REGNO (dest); 1680 cfa_temp.offset = INTVAL (src); 1681 break; 1682 1683 /* Rule 7 */ 1684 case IOR: 1685 gcc_assert (REG_P (XEXP (src, 0)) 1686 && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg 1687 && GET_CODE (XEXP (src, 1)) == CONST_INT); 1688 1689 if ((unsigned) REGNO (dest) != cfa_temp.reg) 1690 cfa_temp.reg = REGNO (dest); 1691 cfa_temp.offset |= INTVAL (XEXP (src, 1)); 1692 break; 1693 1694 /* Skip over HIGH, assuming it will be followed by a LO_SUM, 1695 which will fill in all of the bits. */ 1696 /* Rule 8 */ 1697 case HIGH: 1698 break; 1699 1700 /* Rule 15 */ 1701 case UNSPEC: 1702 case UNSPEC_VOLATILE: 1703 gcc_assert (targetm.dwarf_handle_frame_unspec); 1704 targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1)); 1705 return; 1706 1707 default: 1708 gcc_unreachable (); 1709 } 1710 1711 def_cfa_1 (label, &cfa); 1712 break; 1713 1714 case MEM: 1715 gcc_assert (REG_P (src)); 1716 1717 /* Saving a register to the stack. Make sure dest is relative to the 1718 CFA register. */ 1719 switch (GET_CODE (XEXP (dest, 0))) 1720 { 1721 /* Rule 10 */ 1722 /* With a push. */ 1723 case PRE_MODIFY: 1724 /* We can't handle variable size modifications. */ 1725 gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1)) 1726 == CONST_INT); 1727 offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1)); 1728 1729 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM 1730 && cfa_store.reg == STACK_POINTER_REGNUM); 1731 1732 cfa_store.offset += offset; 1733 if (cfa.reg == STACK_POINTER_REGNUM) 1734 cfa.offset = cfa_store.offset; 1735 1736 offset = -cfa_store.offset; 1737 break; 1738 1739 /* Rule 11 */ 1740 case PRE_INC: 1741 case PRE_DEC: 1742 offset = GET_MODE_SIZE (GET_MODE (dest)); 1743 if (GET_CODE (XEXP (dest, 0)) == PRE_INC) 1744 offset = -offset; 1745 1746 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM 1747 && cfa_store.reg == STACK_POINTER_REGNUM); 1748 1749 cfa_store.offset += offset; 1750 if (cfa.reg == STACK_POINTER_REGNUM) 1751 cfa.offset = cfa_store.offset; 1752 1753 offset = -cfa_store.offset; 1754 break; 1755 1756 /* Rule 12 */ 1757 /* With an offset. */ 1758 case PLUS: 1759 case MINUS: 1760 case LO_SUM: 1761 { 1762 int regno; 1763 1764 gcc_assert (GET_CODE (XEXP (XEXP (dest, 0), 1)) == CONST_INT 1765 && REG_P (XEXP (XEXP (dest, 0), 0))); 1766 offset = INTVAL (XEXP (XEXP (dest, 0), 1)); 1767 if (GET_CODE (XEXP (dest, 0)) == MINUS) 1768 offset = -offset; 1769 1770 regno = REGNO (XEXP (XEXP (dest, 0), 0)); 1771 1772 if (cfa_store.reg == (unsigned) regno) 1773 offset -= cfa_store.offset; 1774 else 1775 { 1776 gcc_assert (cfa_temp.reg == (unsigned) regno); 1777 offset -= cfa_temp.offset; 1778 } 1779 } 1780 break; 1781 1782 /* Rule 13 */ 1783 /* Without an offset. */ 1784 case REG: 1785 { 1786 int regno = REGNO (XEXP (dest, 0)); 1787 1788 if (cfa_store.reg == (unsigned) regno) 1789 offset = -cfa_store.offset; 1790 else 1791 { 1792 gcc_assert (cfa_temp.reg == (unsigned) regno); 1793 offset = -cfa_temp.offset; 1794 } 1795 } 1796 break; 1797 1798 /* Rule 14 */ 1799 case POST_INC: 1800 gcc_assert (cfa_temp.reg 1801 == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0))); 1802 offset = -cfa_temp.offset; 1803 cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest)); 1804 break; 1805 1806 default: 1807 gcc_unreachable (); 1808 } 1809 1810 if (REGNO (src) != STACK_POINTER_REGNUM 1811 && REGNO (src) != HARD_FRAME_POINTER_REGNUM 1812 && (unsigned) REGNO (src) == cfa.reg) 1813 { 1814 /* We're storing the current CFA reg into the stack. */ 1815 1816 if (cfa.offset == 0) 1817 { 1818 /* If the source register is exactly the CFA, assume 1819 we're saving SP like any other register; this happens 1820 on the ARM. */ 1821 def_cfa_1 (label, &cfa); 1822 queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset); 1823 break; 1824 } 1825 else 1826 { 1827 /* Otherwise, we'll need to look in the stack to 1828 calculate the CFA. */ 1829 rtx x = XEXP (dest, 0); 1830 1831 if (!REG_P (x)) 1832 x = XEXP (x, 0); 1833 gcc_assert (REG_P (x)); 1834 1835 cfa.reg = REGNO (x); 1836 cfa.base_offset = offset; 1837 cfa.indirect = 1; 1838 def_cfa_1 (label, &cfa); 1839 break; 1840 } 1841 } 1842 1843 def_cfa_1 (label, &cfa); 1844 queue_reg_save (label, src, NULL_RTX, offset); 1845 break; 1846 1847 default: 1848 gcc_unreachable (); 1849 } 1850} 1851 1852/* Record call frame debugging information for INSN, which either 1853 sets SP or FP (adjusting how we calculate the frame address) or saves a 1854 register to the stack. If INSN is NULL_RTX, initialize our state. 1855 1856 If AFTER_P is false, we're being called before the insn is emitted, 1857 otherwise after. Call instructions get invoked twice. */ 1858 1859void 1860dwarf2out_frame_debug (rtx insn, bool after_p) 1861{ 1862 const char *label; 1863 rtx src; 1864 1865 if (insn == NULL_RTX) 1866 { 1867 size_t i; 1868 1869 /* Flush any queued register saves. */ 1870 flush_queued_reg_saves (); 1871 1872 /* Set up state for generating call frame debug info. */ 1873 lookup_cfa (&cfa); 1874 gcc_assert (cfa.reg 1875 == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM)); 1876 1877 cfa.reg = STACK_POINTER_REGNUM; 1878 cfa_store = cfa; 1879 cfa_temp.reg = -1; 1880 cfa_temp.offset = 0; 1881 1882 for (i = 0; i < num_regs_saved_in_regs; i++) 1883 { 1884 regs_saved_in_regs[i].orig_reg = NULL_RTX; 1885 regs_saved_in_regs[i].saved_in_reg = NULL_RTX; 1886 } 1887 num_regs_saved_in_regs = 0; 1888 return; 1889 } 1890 1891 if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn)) 1892 flush_queued_reg_saves (); 1893 1894 if (! RTX_FRAME_RELATED_P (insn)) 1895 { 1896 if (!ACCUMULATE_OUTGOING_ARGS) 1897 dwarf2out_stack_adjust (insn, after_p); 1898 return; 1899 } 1900 1901 label = dwarf2out_cfi_label (); 1902 src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX); 1903 if (src) 1904 insn = XEXP (src, 0); 1905 else 1906 insn = PATTERN (insn); 1907 1908 dwarf2out_frame_debug_expr (insn, label); 1909} 1910 1911#endif 1912 1913/* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */ 1914static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc 1915 (enum dwarf_call_frame_info cfi); 1916 1917static enum dw_cfi_oprnd_type 1918dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi) 1919{ 1920 switch (cfi) 1921 { 1922 case DW_CFA_nop: 1923 case DW_CFA_GNU_window_save: 1924 return dw_cfi_oprnd_unused; 1925 1926 case DW_CFA_set_loc: 1927 case DW_CFA_advance_loc1: 1928 case DW_CFA_advance_loc2: 1929 case DW_CFA_advance_loc4: 1930 case DW_CFA_MIPS_advance_loc8: 1931 return dw_cfi_oprnd_addr; 1932 1933 case DW_CFA_offset: 1934 case DW_CFA_offset_extended: 1935 case DW_CFA_def_cfa: 1936 case DW_CFA_offset_extended_sf: 1937 case DW_CFA_def_cfa_sf: 1938 case DW_CFA_restore_extended: 1939 case DW_CFA_undefined: 1940 case DW_CFA_same_value: 1941 case DW_CFA_def_cfa_register: 1942 case DW_CFA_register: 1943 return dw_cfi_oprnd_reg_num; 1944 1945 case DW_CFA_def_cfa_offset: 1946 case DW_CFA_GNU_args_size: 1947 case DW_CFA_def_cfa_offset_sf: 1948 return dw_cfi_oprnd_offset; 1949 1950 case DW_CFA_def_cfa_expression: 1951 case DW_CFA_expression: 1952 return dw_cfi_oprnd_loc; 1953 1954 default: 1955 gcc_unreachable (); 1956 } 1957} 1958 1959/* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */ 1960static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc 1961 (enum dwarf_call_frame_info cfi); 1962 1963static enum dw_cfi_oprnd_type 1964dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi) 1965{ 1966 switch (cfi) 1967 { 1968 case DW_CFA_def_cfa: 1969 case DW_CFA_def_cfa_sf: 1970 case DW_CFA_offset: 1971 case DW_CFA_offset_extended_sf: 1972 case DW_CFA_offset_extended: 1973 return dw_cfi_oprnd_offset; 1974 1975 case DW_CFA_register: 1976 return dw_cfi_oprnd_reg_num; 1977 1978 default: 1979 return dw_cfi_oprnd_unused; 1980 } 1981} 1982 1983#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 1984 1985/* Switch to eh_frame_section. If we don't have an eh_frame_section, 1986 switch to the data section instead, and write out a synthetic label 1987 for collect2. */ 1988 1989static void 1990switch_to_eh_frame_section (void) 1991{ 1992 tree label; 1993 1994#ifdef EH_FRAME_SECTION_NAME 1995 if (eh_frame_section == 0) 1996 { 1997 int flags; 1998 1999 if (EH_TABLES_CAN_BE_READ_ONLY) 2000 { 2001 int fde_encoding; 2002 int per_encoding; 2003 int lsda_encoding; 2004 2005 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, 2006 /*global=*/0); 2007 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, 2008 /*global=*/1); 2009 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, 2010 /*global=*/0); 2011 flags = ((! flag_pic 2012 || ((fde_encoding & 0x70) != DW_EH_PE_absptr 2013 && (fde_encoding & 0x70) != DW_EH_PE_aligned 2014 && (per_encoding & 0x70) != DW_EH_PE_absptr 2015 && (per_encoding & 0x70) != DW_EH_PE_aligned 2016 && (lsda_encoding & 0x70) != DW_EH_PE_absptr 2017 && (lsda_encoding & 0x70) != DW_EH_PE_aligned)) 2018 ? 0 : SECTION_WRITE); 2019 } 2020 else 2021 flags = SECTION_WRITE; 2022 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL); 2023 } 2024#endif 2025 2026 if (eh_frame_section) 2027 switch_to_section (eh_frame_section); 2028 else 2029 { 2030 /* We have no special eh_frame section. Put the information in 2031 the data section and emit special labels to guide collect2. */ 2032 switch_to_section (data_section); 2033 label = get_file_function_name ('F'); 2034 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE)); 2035 targetm.asm_out.globalize_label (asm_out_file, 2036 IDENTIFIER_POINTER (label)); 2037 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label)); 2038 } 2039} 2040 2041/* Output a Call Frame Information opcode and its operand(s). */ 2042 2043static void 2044output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh) 2045{ 2046 unsigned long r; 2047 if (cfi->dw_cfi_opc == DW_CFA_advance_loc) 2048 dw2_asm_output_data (1, (cfi->dw_cfi_opc 2049 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)), 2050 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX, 2051 cfi->dw_cfi_oprnd1.dw_cfi_offset); 2052 else if (cfi->dw_cfi_opc == DW_CFA_offset) 2053 { 2054 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2055 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)), 2056 "DW_CFA_offset, column 0x%lx", r); 2057 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL); 2058 } 2059 else if (cfi->dw_cfi_opc == DW_CFA_restore) 2060 { 2061 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2062 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)), 2063 "DW_CFA_restore, column 0x%lx", r); 2064 } 2065 else 2066 { 2067 dw2_asm_output_data (1, cfi->dw_cfi_opc, 2068 "%s", dwarf_cfi_name (cfi->dw_cfi_opc)); 2069 2070 switch (cfi->dw_cfi_opc) 2071 { 2072 case DW_CFA_set_loc: 2073 if (for_eh) 2074 dw2_asm_output_encoded_addr_rtx ( 2075 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0), 2076 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr), 2077 false, NULL); 2078 else 2079 dw2_asm_output_addr (DWARF2_ADDR_SIZE, 2080 cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL); 2081 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 2082 break; 2083 2084 case DW_CFA_advance_loc1: 2085 dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr, 2086 fde->dw_fde_current_label, NULL); 2087 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 2088 break; 2089 2090 case DW_CFA_advance_loc2: 2091 dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr, 2092 fde->dw_fde_current_label, NULL); 2093 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 2094 break; 2095 2096 case DW_CFA_advance_loc4: 2097 dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr, 2098 fde->dw_fde_current_label, NULL); 2099 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 2100 break; 2101 2102 case DW_CFA_MIPS_advance_loc8: 2103 dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr, 2104 fde->dw_fde_current_label, NULL); 2105 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 2106 break; 2107 2108 case DW_CFA_offset_extended: 2109 case DW_CFA_def_cfa: 2110 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2111 dw2_asm_output_data_uleb128 (r, NULL); 2112 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL); 2113 break; 2114 2115 case DW_CFA_offset_extended_sf: 2116 case DW_CFA_def_cfa_sf: 2117 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2118 dw2_asm_output_data_uleb128 (r, NULL); 2119 dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL); 2120 break; 2121 2122 case DW_CFA_restore_extended: 2123 case DW_CFA_undefined: 2124 case DW_CFA_same_value: 2125 case DW_CFA_def_cfa_register: 2126 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2127 dw2_asm_output_data_uleb128 (r, NULL); 2128 break; 2129 2130 case DW_CFA_register: 2131 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); 2132 dw2_asm_output_data_uleb128 (r, NULL); 2133 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh); 2134 dw2_asm_output_data_uleb128 (r, NULL); 2135 break; 2136 2137 case DW_CFA_def_cfa_offset: 2138 case DW_CFA_GNU_args_size: 2139 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL); 2140 break; 2141 2142 case DW_CFA_def_cfa_offset_sf: 2143 dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL); 2144 break; 2145 2146 case DW_CFA_GNU_window_save: 2147 break; 2148 2149 case DW_CFA_def_cfa_expression: 2150 case DW_CFA_expression: 2151 output_cfa_loc (cfi); 2152 break; 2153 2154 case DW_CFA_GNU_negative_offset_extended: 2155 /* Obsoleted by DW_CFA_offset_extended_sf. */ 2156 gcc_unreachable (); 2157 2158 default: 2159 break; 2160 } 2161 } 2162} 2163 2164/* Output the call frame information used to record information 2165 that relates to calculating the frame pointer, and records the 2166 location of saved registers. */ 2167 2168static void 2169output_call_frame_info (int for_eh) 2170{ 2171 unsigned int i; 2172 dw_fde_ref fde; 2173 dw_cfi_ref cfi; 2174 char l1[20], l2[20], section_start_label[20]; 2175 bool any_lsda_needed = false; 2176 char augmentation[6]; 2177 int augmentation_size; 2178 int fde_encoding = DW_EH_PE_absptr; 2179 int per_encoding = DW_EH_PE_absptr; 2180 int lsda_encoding = DW_EH_PE_absptr; 2181 int return_reg; 2182 2183 /* Don't emit a CIE if there won't be any FDEs. */ 2184 if (fde_table_in_use == 0) 2185 return; 2186 2187 /* If we make FDEs linkonce, we may have to emit an empty label for 2188 an FDE that wouldn't otherwise be emitted. We want to avoid 2189 having an FDE kept around when the function it refers to is 2190 discarded. Example where this matters: a primary function 2191 template in C++ requires EH information, but an explicit 2192 specialization doesn't. */ 2193 if (TARGET_USES_WEAK_UNWIND_INFO 2194 && ! flag_asynchronous_unwind_tables 2195 && for_eh) 2196 for (i = 0; i < fde_table_in_use; i++) 2197 if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls) 2198 && !fde_table[i].uses_eh_lsda 2199 && ! DECL_WEAK (fde_table[i].decl)) 2200 targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl, 2201 for_eh, /* empty */ 1); 2202 2203 /* If we don't have any functions we'll want to unwind out of, don't 2204 emit any EH unwind information. Note that if exceptions aren't 2205 enabled, we won't have collected nothrow information, and if we 2206 asked for asynchronous tables, we always want this info. */ 2207 if (for_eh) 2208 { 2209 bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables; 2210 2211 for (i = 0; i < fde_table_in_use; i++) 2212 if (fde_table[i].uses_eh_lsda) 2213 any_eh_needed = any_lsda_needed = true; 2214 else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl)) 2215 any_eh_needed = true; 2216 else if (! fde_table[i].nothrow 2217 && ! fde_table[i].all_throwers_are_sibcalls) 2218 any_eh_needed = true; 2219 2220 if (! any_eh_needed) 2221 return; 2222 } 2223 2224 /* We're going to be generating comments, so turn on app. */ 2225 if (flag_debug_asm) 2226 app_enable (); 2227 2228 if (for_eh) 2229 switch_to_eh_frame_section (); 2230 else 2231 { 2232 if (!debug_frame_section) 2233 debug_frame_section = get_section (DEBUG_FRAME_SECTION, 2234 SECTION_DEBUG, NULL); 2235 switch_to_section (debug_frame_section); 2236 } 2237 2238 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh); 2239 ASM_OUTPUT_LABEL (asm_out_file, section_start_label); 2240 2241 /* Output the CIE. */ 2242 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh); 2243 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh); 2244 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh) 2245 dw2_asm_output_data (4, 0xffffffff, 2246 "Initial length escape value indicating 64-bit DWARF extension"); 2247 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1, 2248 "Length of Common Information Entry"); 2249 ASM_OUTPUT_LABEL (asm_out_file, l1); 2250 2251 /* Now that the CIE pointer is PC-relative for EH, 2252 use 0 to identify the CIE. */ 2253 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE), 2254 (for_eh ? 0 : DWARF_CIE_ID), 2255 "CIE Identifier Tag"); 2256 2257 dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version"); 2258 2259 augmentation[0] = 0; 2260 augmentation_size = 0; 2261 if (for_eh) 2262 { 2263 char *p; 2264 2265 /* Augmentation: 2266 z Indicates that a uleb128 is present to size the 2267 augmentation section. 2268 L Indicates the encoding (and thus presence) of 2269 an LSDA pointer in the FDE augmentation. 2270 R Indicates a non-default pointer encoding for 2271 FDE code pointers. 2272 P Indicates the presence of an encoding + language 2273 personality routine in the CIE augmentation. */ 2274 2275 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0); 2276 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1); 2277 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0); 2278 2279 p = augmentation + 1; 2280 if (eh_personality_libfunc) 2281 { 2282 *p++ = 'P'; 2283 augmentation_size += 1 + size_of_encoded_value (per_encoding); 2284 } 2285 if (any_lsda_needed) 2286 { 2287 *p++ = 'L'; 2288 augmentation_size += 1; 2289 } 2290 if (fde_encoding != DW_EH_PE_absptr) 2291 { 2292 *p++ = 'R'; 2293 augmentation_size += 1; 2294 } 2295 if (p > augmentation + 1) 2296 { 2297 augmentation[0] = 'z'; 2298 *p = '\0'; 2299 } 2300 2301 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */ 2302 if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned) 2303 { 2304 int offset = ( 4 /* Length */ 2305 + 4 /* CIE Id */ 2306 + 1 /* CIE version */ 2307 + strlen (augmentation) + 1 /* Augmentation */ 2308 + size_of_uleb128 (1) /* Code alignment */ 2309 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT) 2310 + 1 /* RA column */ 2311 + 1 /* Augmentation size */ 2312 + 1 /* Personality encoding */ ); 2313 int pad = -offset & (PTR_SIZE - 1); 2314 2315 augmentation_size += pad; 2316 2317 /* Augmentations should be small, so there's scarce need to 2318 iterate for a solution. Die if we exceed one uleb128 byte. */ 2319 gcc_assert (size_of_uleb128 (augmentation_size) == 1); 2320 } 2321 } 2322 2323 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation"); 2324 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor"); 2325 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT, 2326 "CIE Data Alignment Factor"); 2327 2328 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh); 2329 if (DW_CIE_VERSION == 1) 2330 dw2_asm_output_data (1, return_reg, "CIE RA Column"); 2331 else 2332 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column"); 2333 2334 if (augmentation[0]) 2335 { 2336 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size"); 2337 if (eh_personality_libfunc) 2338 { 2339 dw2_asm_output_data (1, per_encoding, "Personality (%s)", 2340 eh_data_format_name (per_encoding)); 2341 dw2_asm_output_encoded_addr_rtx (per_encoding, 2342 eh_personality_libfunc, 2343 true, NULL); 2344 } 2345 2346 if (any_lsda_needed) 2347 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)", 2348 eh_data_format_name (lsda_encoding)); 2349 2350 if (fde_encoding != DW_EH_PE_absptr) 2351 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)", 2352 eh_data_format_name (fde_encoding)); 2353 } 2354 2355 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next) 2356 output_cfi (cfi, NULL, for_eh); 2357 2358 /* Pad the CIE out to an address sized boundary. */ 2359 ASM_OUTPUT_ALIGN (asm_out_file, 2360 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)); 2361 ASM_OUTPUT_LABEL (asm_out_file, l2); 2362 2363 /* Loop through all of the FDE's. */ 2364 for (i = 0; i < fde_table_in_use; i++) 2365 { 2366 fde = &fde_table[i]; 2367 2368 /* Don't emit EH unwind info for leaf functions that don't need it. */ 2369 if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions 2370 && (fde->nothrow || fde->all_throwers_are_sibcalls) 2371 && ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl)) 2372 && !fde->uses_eh_lsda) 2373 continue; 2374 2375 targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh, /* empty */ 0); 2376 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL, for_eh + i * 2); 2377 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2); 2378 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2); 2379 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh) 2380 dw2_asm_output_data (4, 0xffffffff, 2381 "Initial length escape value indicating 64-bit DWARF extension"); 2382 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1, 2383 "FDE Length"); 2384 ASM_OUTPUT_LABEL (asm_out_file, l1); 2385 2386 if (for_eh) 2387 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset"); 2388 else 2389 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label, 2390 debug_frame_section, "FDE CIE offset"); 2391 2392 if (for_eh) 2393 { 2394 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin); 2395 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL; 2396 dw2_asm_output_encoded_addr_rtx (fde_encoding, 2397 sym_ref, 2398 false, 2399 "FDE initial location"); 2400 if (fde->dw_fde_switched_sections) 2401 { 2402 rtx sym_ref2 = gen_rtx_SYMBOL_REF (Pmode, 2403 fde->dw_fde_unlikely_section_label); 2404 rtx sym_ref3= gen_rtx_SYMBOL_REF (Pmode, 2405 fde->dw_fde_hot_section_label); 2406 SYMBOL_REF_FLAGS (sym_ref2) |= SYMBOL_FLAG_LOCAL; 2407 SYMBOL_REF_FLAGS (sym_ref3) |= SYMBOL_FLAG_LOCAL; 2408 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref3, false, 2409 "FDE initial location"); 2410 dw2_asm_output_delta (size_of_encoded_value (fde_encoding), 2411 fde->dw_fde_hot_section_end_label, 2412 fde->dw_fde_hot_section_label, 2413 "FDE address range"); 2414 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref2, false, 2415 "FDE initial location"); 2416 dw2_asm_output_delta (size_of_encoded_value (fde_encoding), 2417 fde->dw_fde_unlikely_section_end_label, 2418 fde->dw_fde_unlikely_section_label, 2419 "FDE address range"); 2420 } 2421 else 2422 dw2_asm_output_delta (size_of_encoded_value (fde_encoding), 2423 fde->dw_fde_end, fde->dw_fde_begin, 2424 "FDE address range"); 2425 } 2426 else 2427 { 2428 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin, 2429 "FDE initial location"); 2430 if (fde->dw_fde_switched_sections) 2431 { 2432 dw2_asm_output_addr (DWARF2_ADDR_SIZE, 2433 fde->dw_fde_hot_section_label, 2434 "FDE initial location"); 2435 dw2_asm_output_delta (DWARF2_ADDR_SIZE, 2436 fde->dw_fde_hot_section_end_label, 2437 fde->dw_fde_hot_section_label, 2438 "FDE address range"); 2439 dw2_asm_output_addr (DWARF2_ADDR_SIZE, 2440 fde->dw_fde_unlikely_section_label, 2441 "FDE initial location"); 2442 dw2_asm_output_delta (DWARF2_ADDR_SIZE, 2443 fde->dw_fde_unlikely_section_end_label, 2444 fde->dw_fde_unlikely_section_label, 2445 "FDE address range"); 2446 } 2447 else 2448 dw2_asm_output_delta (DWARF2_ADDR_SIZE, 2449 fde->dw_fde_end, fde->dw_fde_begin, 2450 "FDE address range"); 2451 } 2452 2453 if (augmentation[0]) 2454 { 2455 if (any_lsda_needed) 2456 { 2457 int size = size_of_encoded_value (lsda_encoding); 2458 2459 if (lsda_encoding == DW_EH_PE_aligned) 2460 { 2461 int offset = ( 4 /* Length */ 2462 + 4 /* CIE offset */ 2463 + 2 * size_of_encoded_value (fde_encoding) 2464 + 1 /* Augmentation size */ ); 2465 int pad = -offset & (PTR_SIZE - 1); 2466 2467 size += pad; 2468 gcc_assert (size_of_uleb128 (size) == 1); 2469 } 2470 2471 dw2_asm_output_data_uleb128 (size, "Augmentation size"); 2472 2473 if (fde->uses_eh_lsda) 2474 { 2475 ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA", 2476 fde->funcdef_number); 2477 dw2_asm_output_encoded_addr_rtx ( 2478 lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1), 2479 false, "Language Specific Data Area"); 2480 } 2481 else 2482 { 2483 if (lsda_encoding == DW_EH_PE_aligned) 2484 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE)); 2485 dw2_asm_output_data 2486 (size_of_encoded_value (lsda_encoding), 0, 2487 "Language Specific Data Area (none)"); 2488 } 2489 } 2490 else 2491 dw2_asm_output_data_uleb128 (0, "Augmentation size"); 2492 } 2493 2494 /* Loop through the Call Frame Instructions associated with 2495 this FDE. */ 2496 fde->dw_fde_current_label = fde->dw_fde_begin; 2497 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next) 2498 output_cfi (cfi, fde, for_eh); 2499 2500 /* Pad the FDE out to an address sized boundary. */ 2501 ASM_OUTPUT_ALIGN (asm_out_file, 2502 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE))); 2503 ASM_OUTPUT_LABEL (asm_out_file, l2); 2504 } 2505 2506 if (for_eh && targetm.terminate_dw2_eh_frame_info) 2507 dw2_asm_output_data (4, 0, "End of Table"); 2508#ifdef MIPS_DEBUGGING_INFO 2509 /* Work around Irix 6 assembler bug whereby labels at the end of a section 2510 get a value of 0. Putting .align 0 after the label fixes it. */ 2511 ASM_OUTPUT_ALIGN (asm_out_file, 0); 2512#endif 2513 2514 /* Turn off app to make assembly quicker. */ 2515 if (flag_debug_asm) 2516 app_disable (); 2517} 2518 2519/* Output a marker (i.e. a label) for the beginning of a function, before 2520 the prologue. */ 2521 2522void 2523dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED, 2524 const char *file ATTRIBUTE_UNUSED) 2525{ 2526 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 2527 char * dup_label; 2528 dw_fde_ref fde; 2529 2530 current_function_func_begin_label = NULL; 2531 2532#ifdef TARGET_UNWIND_INFO 2533 /* ??? current_function_func_begin_label is also used by except.c 2534 for call-site information. We must emit this label if it might 2535 be used. */ 2536 if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS) 2537 && ! dwarf2out_do_frame ()) 2538 return; 2539#else 2540 if (! dwarf2out_do_frame ()) 2541 return; 2542#endif 2543 2544 switch_to_section (function_section (current_function_decl)); 2545 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL, 2546 current_function_funcdef_no); 2547 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL, 2548 current_function_funcdef_no); 2549 dup_label = xstrdup (label); 2550 current_function_func_begin_label = dup_label; 2551 2552#ifdef TARGET_UNWIND_INFO 2553 /* We can elide the fde allocation if we're not emitting debug info. */ 2554 if (! dwarf2out_do_frame ()) 2555 return; 2556#endif 2557 2558 /* Expand the fde table if necessary. */ 2559 if (fde_table_in_use == fde_table_allocated) 2560 { 2561 fde_table_allocated += FDE_TABLE_INCREMENT; 2562 fde_table = ggc_realloc (fde_table, 2563 fde_table_allocated * sizeof (dw_fde_node)); 2564 memset (fde_table + fde_table_in_use, 0, 2565 FDE_TABLE_INCREMENT * sizeof (dw_fde_node)); 2566 } 2567 2568 /* Record the FDE associated with this function. */ 2569 current_funcdef_fde = fde_table_in_use; 2570 2571 /* Add the new FDE at the end of the fde_table. */ 2572 fde = &fde_table[fde_table_in_use++]; 2573 fde->decl = current_function_decl; 2574 fde->dw_fde_begin = dup_label; 2575 fde->dw_fde_current_label = dup_label; 2576 fde->dw_fde_hot_section_label = NULL; 2577 fde->dw_fde_hot_section_end_label = NULL; 2578 fde->dw_fde_unlikely_section_label = NULL; 2579 fde->dw_fde_unlikely_section_end_label = NULL; 2580 fde->dw_fde_switched_sections = false; 2581 fde->dw_fde_end = NULL; 2582 fde->dw_fde_cfi = NULL; 2583 fde->funcdef_number = current_function_funcdef_no; 2584 fde->nothrow = TREE_NOTHROW (current_function_decl); 2585 fde->uses_eh_lsda = cfun->uses_eh_lsda; 2586 fde->all_throwers_are_sibcalls = cfun->all_throwers_are_sibcalls; 2587 2588 args_size = old_args_size = 0; 2589 2590 /* We only want to output line number information for the genuine dwarf2 2591 prologue case, not the eh frame case. */ 2592#ifdef DWARF2_DEBUGGING_INFO 2593 if (file) 2594 dwarf2out_source_line (line, file); 2595#endif 2596} 2597 2598/* Output a marker (i.e. a label) for the absolute end of the generated code 2599 for a function definition. This gets called *after* the epilogue code has 2600 been generated. */ 2601 2602void 2603dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED, 2604 const char *file ATTRIBUTE_UNUSED) 2605{ 2606 dw_fde_ref fde; 2607 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 2608 2609 /* Output a label to mark the endpoint of the code generated for this 2610 function. */ 2611 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL, 2612 current_function_funcdef_no); 2613 ASM_OUTPUT_LABEL (asm_out_file, label); 2614 fde = &fde_table[fde_table_in_use - 1]; 2615 fde->dw_fde_end = xstrdup (label); 2616} 2617 2618void 2619dwarf2out_frame_init (void) 2620{ 2621 /* Allocate the initial hunk of the fde_table. */ 2622 fde_table = ggc_alloc_cleared (FDE_TABLE_INCREMENT * sizeof (dw_fde_node)); 2623 fde_table_allocated = FDE_TABLE_INCREMENT; 2624 fde_table_in_use = 0; 2625 2626 /* Generate the CFA instructions common to all FDE's. Do it now for the 2627 sake of lookup_cfa. */ 2628 2629 /* On entry, the Canonical Frame Address is at SP. */ 2630 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET); 2631 2632#ifdef DWARF2_UNWIND_INFO 2633 if (DWARF2_UNWIND_INFO) 2634 initial_return_save (INCOMING_RETURN_ADDR_RTX); 2635#endif 2636} 2637 2638void 2639dwarf2out_frame_finish (void) 2640{ 2641 /* Output call frame information. */ 2642 if (DWARF2_FRAME_INFO) 2643 output_call_frame_info (0); 2644 2645#ifndef TARGET_UNWIND_INFO 2646 /* Output another copy for the unwinder. */ 2647 if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions)) 2648 output_call_frame_info (1); 2649#endif 2650} 2651#endif 2652 2653/* And now, the subset of the debugging information support code necessary 2654 for emitting location expressions. */ 2655 2656/* Data about a single source file. */ 2657struct dwarf_file_data GTY(()) 2658{ 2659 const char * filename; 2660 int emitted_number; 2661}; 2662 2663/* We need some way to distinguish DW_OP_addr with a direct symbol 2664 relocation from DW_OP_addr with a dtp-relative symbol relocation. */ 2665#define INTERNAL_DW_OP_tls_addr (0x100 + DW_OP_addr) 2666 2667 2668typedef struct dw_val_struct *dw_val_ref; 2669typedef struct die_struct *dw_die_ref; 2670typedef struct dw_loc_descr_struct *dw_loc_descr_ref; 2671typedef struct dw_loc_list_struct *dw_loc_list_ref; 2672 2673/* Each DIE may have a series of attribute/value pairs. Values 2674 can take on several forms. The forms that are used in this 2675 implementation are listed below. */ 2676 2677enum dw_val_class 2678{ 2679 dw_val_class_addr, 2680 dw_val_class_offset, 2681 dw_val_class_loc, 2682 dw_val_class_loc_list, 2683 dw_val_class_range_list, 2684 dw_val_class_const, 2685 dw_val_class_unsigned_const, 2686 dw_val_class_long_long, 2687 dw_val_class_vec, 2688 dw_val_class_flag, 2689 dw_val_class_die_ref, 2690 dw_val_class_fde_ref, 2691 dw_val_class_lbl_id, 2692 dw_val_class_lineptr, 2693 dw_val_class_str, 2694 dw_val_class_macptr, 2695 dw_val_class_file 2696}; 2697 2698/* Describe a double word constant value. */ 2699/* ??? Every instance of long_long in the code really means CONST_DOUBLE. */ 2700 2701typedef struct dw_long_long_struct GTY(()) 2702{ 2703 unsigned long hi; 2704 unsigned long low; 2705} 2706dw_long_long_const; 2707 2708/* Describe a floating point constant value, or a vector constant value. */ 2709 2710typedef struct dw_vec_struct GTY(()) 2711{ 2712 unsigned char * GTY((length ("%h.length"))) array; 2713 unsigned length; 2714 unsigned elt_size; 2715} 2716dw_vec_const; 2717 2718/* The dw_val_node describes an attribute's value, as it is 2719 represented internally. */ 2720 2721typedef struct dw_val_struct GTY(()) 2722{ 2723 enum dw_val_class val_class; 2724 union dw_val_struct_union 2725 { 2726 rtx GTY ((tag ("dw_val_class_addr"))) val_addr; 2727 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset; 2728 dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list; 2729 dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc; 2730 HOST_WIDE_INT GTY ((default)) val_int; 2731 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned; 2732 dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long; 2733 dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec; 2734 struct dw_val_die_union 2735 { 2736 dw_die_ref die; 2737 int external; 2738 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref; 2739 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index; 2740 struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str; 2741 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id; 2742 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag; 2743 struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file; 2744 } 2745 GTY ((desc ("%1.val_class"))) v; 2746} 2747dw_val_node; 2748 2749/* Locations in memory are described using a sequence of stack machine 2750 operations. */ 2751 2752typedef struct dw_loc_descr_struct GTY(()) 2753{ 2754 dw_loc_descr_ref dw_loc_next; 2755 enum dwarf_location_atom dw_loc_opc; 2756 dw_val_node dw_loc_oprnd1; 2757 dw_val_node dw_loc_oprnd2; 2758 int dw_loc_addr; 2759} 2760dw_loc_descr_node; 2761 2762/* Location lists are ranges + location descriptions for that range, 2763 so you can track variables that are in different places over 2764 their entire life. */ 2765typedef struct dw_loc_list_struct GTY(()) 2766{ 2767 dw_loc_list_ref dw_loc_next; 2768 const char *begin; /* Label for begin address of range */ 2769 const char *end; /* Label for end address of range */ 2770 char *ll_symbol; /* Label for beginning of location list. 2771 Only on head of list */ 2772 const char *section; /* Section this loclist is relative to */ 2773 dw_loc_descr_ref expr; 2774} dw_loc_list_node; 2775 2776#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) 2777 2778static const char *dwarf_stack_op_name (unsigned); 2779static dw_loc_descr_ref new_loc_descr (enum dwarf_location_atom, 2780 unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT); 2781static void add_loc_descr (dw_loc_descr_ref *, dw_loc_descr_ref); 2782static unsigned long size_of_loc_descr (dw_loc_descr_ref); 2783static unsigned long size_of_locs (dw_loc_descr_ref); 2784static void output_loc_operands (dw_loc_descr_ref); 2785static void output_loc_sequence (dw_loc_descr_ref); 2786 2787/* Convert a DWARF stack opcode into its string name. */ 2788 2789static const char * 2790dwarf_stack_op_name (unsigned int op) 2791{ 2792 switch (op) 2793 { 2794 case DW_OP_addr: 2795 case INTERNAL_DW_OP_tls_addr: 2796 return "DW_OP_addr"; 2797 case DW_OP_deref: 2798 return "DW_OP_deref"; 2799 case DW_OP_const1u: 2800 return "DW_OP_const1u"; 2801 case DW_OP_const1s: 2802 return "DW_OP_const1s"; 2803 case DW_OP_const2u: 2804 return "DW_OP_const2u"; 2805 case DW_OP_const2s: 2806 return "DW_OP_const2s"; 2807 case DW_OP_const4u: 2808 return "DW_OP_const4u"; 2809 case DW_OP_const4s: 2810 return "DW_OP_const4s"; 2811 case DW_OP_const8u: 2812 return "DW_OP_const8u"; 2813 case DW_OP_const8s: 2814 return "DW_OP_const8s"; 2815 case DW_OP_constu: 2816 return "DW_OP_constu"; 2817 case DW_OP_consts: 2818 return "DW_OP_consts"; 2819 case DW_OP_dup: 2820 return "DW_OP_dup"; 2821 case DW_OP_drop: 2822 return "DW_OP_drop"; 2823 case DW_OP_over: 2824 return "DW_OP_over"; 2825 case DW_OP_pick: 2826 return "DW_OP_pick"; 2827 case DW_OP_swap: 2828 return "DW_OP_swap"; 2829 case DW_OP_rot: 2830 return "DW_OP_rot"; 2831 case DW_OP_xderef: 2832 return "DW_OP_xderef"; 2833 case DW_OP_abs: 2834 return "DW_OP_abs"; 2835 case DW_OP_and: 2836 return "DW_OP_and"; 2837 case DW_OP_div: 2838 return "DW_OP_div"; 2839 case DW_OP_minus: 2840 return "DW_OP_minus"; 2841 case DW_OP_mod: 2842 return "DW_OP_mod"; 2843 case DW_OP_mul: 2844 return "DW_OP_mul"; 2845 case DW_OP_neg: 2846 return "DW_OP_neg"; 2847 case DW_OP_not: 2848 return "DW_OP_not"; 2849 case DW_OP_or: 2850 return "DW_OP_or"; 2851 case DW_OP_plus: 2852 return "DW_OP_plus"; 2853 case DW_OP_plus_uconst: 2854 return "DW_OP_plus_uconst"; 2855 case DW_OP_shl: 2856 return "DW_OP_shl"; 2857 case DW_OP_shr: 2858 return "DW_OP_shr"; 2859 case DW_OP_shra: 2860 return "DW_OP_shra"; 2861 case DW_OP_xor: 2862 return "DW_OP_xor"; 2863 case DW_OP_bra: 2864 return "DW_OP_bra"; 2865 case DW_OP_eq: 2866 return "DW_OP_eq"; 2867 case DW_OP_ge: 2868 return "DW_OP_ge"; 2869 case DW_OP_gt: 2870 return "DW_OP_gt"; 2871 case DW_OP_le: 2872 return "DW_OP_le"; 2873 case DW_OP_lt: 2874 return "DW_OP_lt"; 2875 case DW_OP_ne: 2876 return "DW_OP_ne"; 2877 case DW_OP_skip: 2878 return "DW_OP_skip"; 2879 case DW_OP_lit0: 2880 return "DW_OP_lit0"; 2881 case DW_OP_lit1: 2882 return "DW_OP_lit1"; 2883 case DW_OP_lit2: 2884 return "DW_OP_lit2"; 2885 case DW_OP_lit3: 2886 return "DW_OP_lit3"; 2887 case DW_OP_lit4: 2888 return "DW_OP_lit4"; 2889 case DW_OP_lit5: 2890 return "DW_OP_lit5"; 2891 case DW_OP_lit6: 2892 return "DW_OP_lit6"; 2893 case DW_OP_lit7: 2894 return "DW_OP_lit7"; 2895 case DW_OP_lit8: 2896 return "DW_OP_lit8"; 2897 case DW_OP_lit9: 2898 return "DW_OP_lit9"; 2899 case DW_OP_lit10: 2900 return "DW_OP_lit10"; 2901 case DW_OP_lit11: 2902 return "DW_OP_lit11"; 2903 case DW_OP_lit12: 2904 return "DW_OP_lit12"; 2905 case DW_OP_lit13: 2906 return "DW_OP_lit13"; 2907 case DW_OP_lit14: 2908 return "DW_OP_lit14"; 2909 case DW_OP_lit15: 2910 return "DW_OP_lit15"; 2911 case DW_OP_lit16: 2912 return "DW_OP_lit16"; 2913 case DW_OP_lit17: 2914 return "DW_OP_lit17"; 2915 case DW_OP_lit18: 2916 return "DW_OP_lit18"; 2917 case DW_OP_lit19: 2918 return "DW_OP_lit19"; 2919 case DW_OP_lit20: 2920 return "DW_OP_lit20"; 2921 case DW_OP_lit21: 2922 return "DW_OP_lit21"; 2923 case DW_OP_lit22: 2924 return "DW_OP_lit22"; 2925 case DW_OP_lit23: 2926 return "DW_OP_lit23"; 2927 case DW_OP_lit24: 2928 return "DW_OP_lit24"; 2929 case DW_OP_lit25: 2930 return "DW_OP_lit25"; 2931 case DW_OP_lit26: 2932 return "DW_OP_lit26"; 2933 case DW_OP_lit27: 2934 return "DW_OP_lit27"; 2935 case DW_OP_lit28: 2936 return "DW_OP_lit28"; 2937 case DW_OP_lit29: 2938 return "DW_OP_lit29"; 2939 case DW_OP_lit30: 2940 return "DW_OP_lit30"; 2941 case DW_OP_lit31: 2942 return "DW_OP_lit31"; 2943 case DW_OP_reg0: 2944 return "DW_OP_reg0"; 2945 case DW_OP_reg1: 2946 return "DW_OP_reg1"; 2947 case DW_OP_reg2: 2948 return "DW_OP_reg2"; 2949 case DW_OP_reg3: 2950 return "DW_OP_reg3"; 2951 case DW_OP_reg4: 2952 return "DW_OP_reg4"; 2953 case DW_OP_reg5: 2954 return "DW_OP_reg5"; 2955 case DW_OP_reg6: 2956 return "DW_OP_reg6"; 2957 case DW_OP_reg7: 2958 return "DW_OP_reg7"; 2959 case DW_OP_reg8: 2960 return "DW_OP_reg8"; 2961 case DW_OP_reg9: 2962 return "DW_OP_reg9"; 2963 case DW_OP_reg10: 2964 return "DW_OP_reg10"; 2965 case DW_OP_reg11: 2966 return "DW_OP_reg11"; 2967 case DW_OP_reg12: 2968 return "DW_OP_reg12"; 2969 case DW_OP_reg13: 2970 return "DW_OP_reg13"; 2971 case DW_OP_reg14: 2972 return "DW_OP_reg14"; 2973 case DW_OP_reg15: 2974 return "DW_OP_reg15"; 2975 case DW_OP_reg16: 2976 return "DW_OP_reg16"; 2977 case DW_OP_reg17: 2978 return "DW_OP_reg17"; 2979 case DW_OP_reg18: 2980 return "DW_OP_reg18"; 2981 case DW_OP_reg19: 2982 return "DW_OP_reg19"; 2983 case DW_OP_reg20: 2984 return "DW_OP_reg20"; 2985 case DW_OP_reg21: 2986 return "DW_OP_reg21"; 2987 case DW_OP_reg22: 2988 return "DW_OP_reg22"; 2989 case DW_OP_reg23: 2990 return "DW_OP_reg23"; 2991 case DW_OP_reg24: 2992 return "DW_OP_reg24"; 2993 case DW_OP_reg25: 2994 return "DW_OP_reg25"; 2995 case DW_OP_reg26: 2996 return "DW_OP_reg26"; 2997 case DW_OP_reg27: 2998 return "DW_OP_reg27"; 2999 case DW_OP_reg28: 3000 return "DW_OP_reg28"; 3001 case DW_OP_reg29: 3002 return "DW_OP_reg29"; 3003 case DW_OP_reg30: 3004 return "DW_OP_reg30"; 3005 case DW_OP_reg31: 3006 return "DW_OP_reg31"; 3007 case DW_OP_breg0: 3008 return "DW_OP_breg0"; 3009 case DW_OP_breg1: 3010 return "DW_OP_breg1"; 3011 case DW_OP_breg2: 3012 return "DW_OP_breg2"; 3013 case DW_OP_breg3: 3014 return "DW_OP_breg3"; 3015 case DW_OP_breg4: 3016 return "DW_OP_breg4"; 3017 case DW_OP_breg5: 3018 return "DW_OP_breg5"; 3019 case DW_OP_breg6: 3020 return "DW_OP_breg6"; 3021 case DW_OP_breg7: 3022 return "DW_OP_breg7"; 3023 case DW_OP_breg8: 3024 return "DW_OP_breg8"; 3025 case DW_OP_breg9: 3026 return "DW_OP_breg9"; 3027 case DW_OP_breg10: 3028 return "DW_OP_breg10"; 3029 case DW_OP_breg11: 3030 return "DW_OP_breg11"; 3031 case DW_OP_breg12: 3032 return "DW_OP_breg12"; 3033 case DW_OP_breg13: 3034 return "DW_OP_breg13"; 3035 case DW_OP_breg14: 3036 return "DW_OP_breg14"; 3037 case DW_OP_breg15: 3038 return "DW_OP_breg15"; 3039 case DW_OP_breg16: 3040 return "DW_OP_breg16"; 3041 case DW_OP_breg17: 3042 return "DW_OP_breg17"; 3043 case DW_OP_breg18: 3044 return "DW_OP_breg18"; 3045 case DW_OP_breg19: 3046 return "DW_OP_breg19"; 3047 case DW_OP_breg20: 3048 return "DW_OP_breg20"; 3049 case DW_OP_breg21: 3050 return "DW_OP_breg21"; 3051 case DW_OP_breg22: 3052 return "DW_OP_breg22"; 3053 case DW_OP_breg23: 3054 return "DW_OP_breg23"; 3055 case DW_OP_breg24: 3056 return "DW_OP_breg24"; 3057 case DW_OP_breg25: 3058 return "DW_OP_breg25"; 3059 case DW_OP_breg26: 3060 return "DW_OP_breg26"; 3061 case DW_OP_breg27: 3062 return "DW_OP_breg27"; 3063 case DW_OP_breg28: 3064 return "DW_OP_breg28"; 3065 case DW_OP_breg29: 3066 return "DW_OP_breg29"; 3067 case DW_OP_breg30: 3068 return "DW_OP_breg30"; 3069 case DW_OP_breg31: 3070 return "DW_OP_breg31"; 3071 case DW_OP_regx: 3072 return "DW_OP_regx"; 3073 case DW_OP_fbreg: 3074 return "DW_OP_fbreg"; 3075 case DW_OP_bregx: 3076 return "DW_OP_bregx"; 3077 case DW_OP_piece: 3078 return "DW_OP_piece"; 3079 case DW_OP_deref_size: 3080 return "DW_OP_deref_size"; 3081 case DW_OP_xderef_size: 3082 return "DW_OP_xderef_size"; 3083 case DW_OP_nop: 3084 return "DW_OP_nop"; 3085 case DW_OP_push_object_address: 3086 return "DW_OP_push_object_address"; 3087 case DW_OP_call2: 3088 return "DW_OP_call2"; 3089 case DW_OP_call4: 3090 return "DW_OP_call4"; 3091 case DW_OP_call_ref: 3092 return "DW_OP_call_ref"; 3093 case DW_OP_GNU_push_tls_address: 3094 return "DW_OP_GNU_push_tls_address"; 3095 default: 3096 return "OP_<unknown>"; 3097 } 3098} 3099 3100/* Return a pointer to a newly allocated location description. Location 3101 descriptions are simple expression terms that can be strung 3102 together to form more complicated location (address) descriptions. */ 3103 3104static inline dw_loc_descr_ref 3105new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1, 3106 unsigned HOST_WIDE_INT oprnd2) 3107{ 3108 dw_loc_descr_ref descr = ggc_alloc_cleared (sizeof (dw_loc_descr_node)); 3109 3110 descr->dw_loc_opc = op; 3111 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const; 3112 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1; 3113 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const; 3114 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2; 3115 3116 return descr; 3117} 3118 3119/* Add a location description term to a location description expression. */ 3120 3121static inline void 3122add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr) 3123{ 3124 dw_loc_descr_ref *d; 3125 3126 /* Find the end of the chain. */ 3127 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next) 3128 ; 3129 3130 *d = descr; 3131} 3132 3133/* Return the size of a location descriptor. */ 3134 3135static unsigned long 3136size_of_loc_descr (dw_loc_descr_ref loc) 3137{ 3138 unsigned long size = 1; 3139 3140 switch (loc->dw_loc_opc) 3141 { 3142 case DW_OP_addr: 3143 case INTERNAL_DW_OP_tls_addr: 3144 size += DWARF2_ADDR_SIZE; 3145 break; 3146 case DW_OP_const1u: 3147 case DW_OP_const1s: 3148 size += 1; 3149 break; 3150 case DW_OP_const2u: 3151 case DW_OP_const2s: 3152 size += 2; 3153 break; 3154 case DW_OP_const4u: 3155 case DW_OP_const4s: 3156 size += 4; 3157 break; 3158 case DW_OP_const8u: 3159 case DW_OP_const8s: 3160 size += 8; 3161 break; 3162 case DW_OP_constu: 3163 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 3164 break; 3165 case DW_OP_consts: 3166 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); 3167 break; 3168 case DW_OP_pick: 3169 size += 1; 3170 break; 3171 case DW_OP_plus_uconst: 3172 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 3173 break; 3174 case DW_OP_skip: 3175 case DW_OP_bra: 3176 size += 2; 3177 break; 3178 case DW_OP_breg0: 3179 case DW_OP_breg1: 3180 case DW_OP_breg2: 3181 case DW_OP_breg3: 3182 case DW_OP_breg4: 3183 case DW_OP_breg5: 3184 case DW_OP_breg6: 3185 case DW_OP_breg7: 3186 case DW_OP_breg8: 3187 case DW_OP_breg9: 3188 case DW_OP_breg10: 3189 case DW_OP_breg11: 3190 case DW_OP_breg12: 3191 case DW_OP_breg13: 3192 case DW_OP_breg14: 3193 case DW_OP_breg15: 3194 case DW_OP_breg16: 3195 case DW_OP_breg17: 3196 case DW_OP_breg18: 3197 case DW_OP_breg19: 3198 case DW_OP_breg20: 3199 case DW_OP_breg21: 3200 case DW_OP_breg22: 3201 case DW_OP_breg23: 3202 case DW_OP_breg24: 3203 case DW_OP_breg25: 3204 case DW_OP_breg26: 3205 case DW_OP_breg27: 3206 case DW_OP_breg28: 3207 case DW_OP_breg29: 3208 case DW_OP_breg30: 3209 case DW_OP_breg31: 3210 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); 3211 break; 3212 case DW_OP_regx: 3213 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 3214 break; 3215 case DW_OP_fbreg: 3216 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); 3217 break; 3218 case DW_OP_bregx: 3219 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 3220 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int); 3221 break; 3222 case DW_OP_piece: 3223 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); 3224 break; 3225 case DW_OP_deref_size: 3226 case DW_OP_xderef_size: 3227 size += 1; 3228 break; 3229 case DW_OP_call2: 3230 size += 2; 3231 break; 3232 case DW_OP_call4: 3233 size += 4; 3234 break; 3235 case DW_OP_call_ref: 3236 size += DWARF2_ADDR_SIZE; 3237 break; 3238 default: 3239 break; 3240 } 3241 3242 return size; 3243} 3244 3245/* Return the size of a series of location descriptors. */ 3246 3247static unsigned long 3248size_of_locs (dw_loc_descr_ref loc) 3249{ 3250 dw_loc_descr_ref l; 3251 unsigned long size; 3252 3253 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr 3254 field, to avoid writing to a PCH file. */ 3255 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next) 3256 { 3257 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra) 3258 break; 3259 size += size_of_loc_descr (l); 3260 } 3261 if (! l) 3262 return size; 3263 3264 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next) 3265 { 3266 l->dw_loc_addr = size; 3267 size += size_of_loc_descr (l); 3268 } 3269 3270 return size; 3271} 3272 3273/* Output location description stack opcode's operands (if any). */ 3274 3275static void 3276output_loc_operands (dw_loc_descr_ref loc) 3277{ 3278 dw_val_ref val1 = &loc->dw_loc_oprnd1; 3279 dw_val_ref val2 = &loc->dw_loc_oprnd2; 3280 3281 switch (loc->dw_loc_opc) 3282 { 3283#ifdef DWARF2_DEBUGGING_INFO 3284 case DW_OP_addr: 3285 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL); 3286 break; 3287 case DW_OP_const2u: 3288 case DW_OP_const2s: 3289 dw2_asm_output_data (2, val1->v.val_int, NULL); 3290 break; 3291 case DW_OP_const4u: 3292 case DW_OP_const4s: 3293 dw2_asm_output_data (4, val1->v.val_int, NULL); 3294 break; 3295 case DW_OP_const8u: 3296 case DW_OP_const8s: 3297 gcc_assert (HOST_BITS_PER_LONG >= 64); 3298 dw2_asm_output_data (8, val1->v.val_int, NULL); 3299 break; 3300 case DW_OP_skip: 3301 case DW_OP_bra: 3302 { 3303 int offset; 3304 3305 gcc_assert (val1->val_class == dw_val_class_loc); 3306 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3); 3307 3308 dw2_asm_output_data (2, offset, NULL); 3309 } 3310 break; 3311#else 3312 case DW_OP_addr: 3313 case DW_OP_const2u: 3314 case DW_OP_const2s: 3315 case DW_OP_const4u: 3316 case DW_OP_const4s: 3317 case DW_OP_const8u: 3318 case DW_OP_const8s: 3319 case DW_OP_skip: 3320 case DW_OP_bra: 3321 /* We currently don't make any attempt to make sure these are 3322 aligned properly like we do for the main unwind info, so 3323 don't support emitting things larger than a byte if we're 3324 only doing unwinding. */ 3325 gcc_unreachable (); 3326#endif 3327 case DW_OP_const1u: 3328 case DW_OP_const1s: 3329 dw2_asm_output_data (1, val1->v.val_int, NULL); 3330 break; 3331 case DW_OP_constu: 3332 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3333 break; 3334 case DW_OP_consts: 3335 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); 3336 break; 3337 case DW_OP_pick: 3338 dw2_asm_output_data (1, val1->v.val_int, NULL); 3339 break; 3340 case DW_OP_plus_uconst: 3341 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3342 break; 3343 case DW_OP_breg0: 3344 case DW_OP_breg1: 3345 case DW_OP_breg2: 3346 case DW_OP_breg3: 3347 case DW_OP_breg4: 3348 case DW_OP_breg5: 3349 case DW_OP_breg6: 3350 case DW_OP_breg7: 3351 case DW_OP_breg8: 3352 case DW_OP_breg9: 3353 case DW_OP_breg10: 3354 case DW_OP_breg11: 3355 case DW_OP_breg12: 3356 case DW_OP_breg13: 3357 case DW_OP_breg14: 3358 case DW_OP_breg15: 3359 case DW_OP_breg16: 3360 case DW_OP_breg17: 3361 case DW_OP_breg18: 3362 case DW_OP_breg19: 3363 case DW_OP_breg20: 3364 case DW_OP_breg21: 3365 case DW_OP_breg22: 3366 case DW_OP_breg23: 3367 case DW_OP_breg24: 3368 case DW_OP_breg25: 3369 case DW_OP_breg26: 3370 case DW_OP_breg27: 3371 case DW_OP_breg28: 3372 case DW_OP_breg29: 3373 case DW_OP_breg30: 3374 case DW_OP_breg31: 3375 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); 3376 break; 3377 case DW_OP_regx: 3378 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3379 break; 3380 case DW_OP_fbreg: 3381 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); 3382 break; 3383 case DW_OP_bregx: 3384 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3385 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL); 3386 break; 3387 case DW_OP_piece: 3388 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); 3389 break; 3390 case DW_OP_deref_size: 3391 case DW_OP_xderef_size: 3392 dw2_asm_output_data (1, val1->v.val_int, NULL); 3393 break; 3394 3395 case INTERNAL_DW_OP_tls_addr: 3396 if (targetm.asm_out.output_dwarf_dtprel) 3397 { 3398 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 3399 DWARF2_ADDR_SIZE, 3400 val1->v.val_addr); 3401 fputc ('\n', asm_out_file); 3402 } 3403 else 3404 gcc_unreachable (); 3405 break; 3406 3407 default: 3408 /* Other codes have no operands. */ 3409 break; 3410 } 3411} 3412 3413/* Output a sequence of location operations. */ 3414 3415static void 3416output_loc_sequence (dw_loc_descr_ref loc) 3417{ 3418 for (; loc != NULL; loc = loc->dw_loc_next) 3419 { 3420 /* Output the opcode. */ 3421 dw2_asm_output_data (1, loc->dw_loc_opc, 3422 "%s", dwarf_stack_op_name (loc->dw_loc_opc)); 3423 3424 /* Output the operand(s) (if any). */ 3425 output_loc_operands (loc); 3426 } 3427} 3428 3429/* This routine will generate the correct assembly data for a location 3430 description based on a cfi entry with a complex address. */ 3431 3432static void 3433output_cfa_loc (dw_cfi_ref cfi) 3434{ 3435 dw_loc_descr_ref loc; 3436 unsigned long size; 3437 3438 /* Output the size of the block. */ 3439 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc; 3440 size = size_of_locs (loc); 3441 dw2_asm_output_data_uleb128 (size, NULL); 3442 3443 /* Now output the operations themselves. */ 3444 output_loc_sequence (loc); 3445} 3446 3447/* This function builds a dwarf location descriptor sequence from a 3448 dw_cfa_location, adding the given OFFSET to the result of the 3449 expression. */ 3450 3451static struct dw_loc_descr_struct * 3452build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset) 3453{ 3454 struct dw_loc_descr_struct *head, *tmp; 3455 3456 offset += cfa->offset; 3457 3458 if (cfa->indirect) 3459 { 3460 if (cfa->base_offset) 3461 { 3462 if (cfa->reg <= 31) 3463 head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0); 3464 else 3465 head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset); 3466 } 3467 else if (cfa->reg <= 31) 3468 head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0); 3469 else 3470 head = new_loc_descr (DW_OP_regx, cfa->reg, 0); 3471 3472 head->dw_loc_oprnd1.val_class = dw_val_class_const; 3473 tmp = new_loc_descr (DW_OP_deref, 0, 0); 3474 add_loc_descr (&head, tmp); 3475 if (offset != 0) 3476 { 3477 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0); 3478 add_loc_descr (&head, tmp); 3479 } 3480 } 3481 else 3482 { 3483 if (offset == 0) 3484 if (cfa->reg <= 31) 3485 head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0); 3486 else 3487 head = new_loc_descr (DW_OP_regx, cfa->reg, 0); 3488 else if (cfa->reg <= 31) 3489 head = new_loc_descr (DW_OP_breg0 + cfa->reg, offset, 0); 3490 else 3491 head = new_loc_descr (DW_OP_bregx, cfa->reg, offset); 3492 } 3493 3494 return head; 3495} 3496 3497/* This function fills in aa dw_cfa_location structure from a dwarf location 3498 descriptor sequence. */ 3499 3500static void 3501get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc) 3502{ 3503 struct dw_loc_descr_struct *ptr; 3504 cfa->offset = 0; 3505 cfa->base_offset = 0; 3506 cfa->indirect = 0; 3507 cfa->reg = -1; 3508 3509 for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next) 3510 { 3511 enum dwarf_location_atom op = ptr->dw_loc_opc; 3512 3513 switch (op) 3514 { 3515 case DW_OP_reg0: 3516 case DW_OP_reg1: 3517 case DW_OP_reg2: 3518 case DW_OP_reg3: 3519 case DW_OP_reg4: 3520 case DW_OP_reg5: 3521 case DW_OP_reg6: 3522 case DW_OP_reg7: 3523 case DW_OP_reg8: 3524 case DW_OP_reg9: 3525 case DW_OP_reg10: 3526 case DW_OP_reg11: 3527 case DW_OP_reg12: 3528 case DW_OP_reg13: 3529 case DW_OP_reg14: 3530 case DW_OP_reg15: 3531 case DW_OP_reg16: 3532 case DW_OP_reg17: 3533 case DW_OP_reg18: 3534 case DW_OP_reg19: 3535 case DW_OP_reg20: 3536 case DW_OP_reg21: 3537 case DW_OP_reg22: 3538 case DW_OP_reg23: 3539 case DW_OP_reg24: 3540 case DW_OP_reg25: 3541 case DW_OP_reg26: 3542 case DW_OP_reg27: 3543 case DW_OP_reg28: 3544 case DW_OP_reg29: 3545 case DW_OP_reg30: 3546 case DW_OP_reg31: 3547 cfa->reg = op - DW_OP_reg0; 3548 break; 3549 case DW_OP_regx: 3550 cfa->reg = ptr->dw_loc_oprnd1.v.val_int; 3551 break; 3552 case DW_OP_breg0: 3553 case DW_OP_breg1: 3554 case DW_OP_breg2: 3555 case DW_OP_breg3: 3556 case DW_OP_breg4: 3557 case DW_OP_breg5: 3558 case DW_OP_breg6: 3559 case DW_OP_breg7: 3560 case DW_OP_breg8: 3561 case DW_OP_breg9: 3562 case DW_OP_breg10: 3563 case DW_OP_breg11: 3564 case DW_OP_breg12: 3565 case DW_OP_breg13: 3566 case DW_OP_breg14: 3567 case DW_OP_breg15: 3568 case DW_OP_breg16: 3569 case DW_OP_breg17: 3570 case DW_OP_breg18: 3571 case DW_OP_breg19: 3572 case DW_OP_breg20: 3573 case DW_OP_breg21: 3574 case DW_OP_breg22: 3575 case DW_OP_breg23: 3576 case DW_OP_breg24: 3577 case DW_OP_breg25: 3578 case DW_OP_breg26: 3579 case DW_OP_breg27: 3580 case DW_OP_breg28: 3581 case DW_OP_breg29: 3582 case DW_OP_breg30: 3583 case DW_OP_breg31: 3584 cfa->reg = op - DW_OP_breg0; 3585 cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int; 3586 break; 3587 case DW_OP_bregx: 3588 cfa->reg = ptr->dw_loc_oprnd1.v.val_int; 3589 cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int; 3590 break; 3591 case DW_OP_deref: 3592 cfa->indirect = 1; 3593 break; 3594 case DW_OP_plus_uconst: 3595 cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned; 3596 break; 3597 default: 3598 internal_error ("DW_LOC_OP %s not implemented", 3599 dwarf_stack_op_name (ptr->dw_loc_opc)); 3600 } 3601 } 3602} 3603#endif /* .debug_frame support */ 3604 3605/* And now, the support for symbolic debugging information. */ 3606#ifdef DWARF2_DEBUGGING_INFO 3607 3608/* .debug_str support. */ 3609static int output_indirect_string (void **, void *); 3610 3611static void dwarf2out_init (const char *); 3612static void dwarf2out_finish (const char *); 3613static void dwarf2out_define (unsigned int, const char *); 3614static void dwarf2out_undef (unsigned int, const char *); 3615static void dwarf2out_start_source_file (unsigned, const char *); 3616static void dwarf2out_end_source_file (unsigned); 3617static void dwarf2out_begin_block (unsigned, unsigned); 3618static void dwarf2out_end_block (unsigned, unsigned); 3619static bool dwarf2out_ignore_block (tree); 3620static void dwarf2out_global_decl (tree); 3621static void dwarf2out_type_decl (tree, int); 3622static void dwarf2out_imported_module_or_decl (tree, tree); 3623static void dwarf2out_abstract_function (tree); 3624static void dwarf2out_var_location (rtx); 3625static void dwarf2out_begin_function (tree); 3626static void dwarf2out_switch_text_section (void); 3627 3628/* The debug hooks structure. */ 3629 3630const struct gcc_debug_hooks dwarf2_debug_hooks = 3631{ 3632 dwarf2out_init, 3633 dwarf2out_finish, 3634 dwarf2out_define, 3635 dwarf2out_undef, 3636 dwarf2out_start_source_file, 3637 dwarf2out_end_source_file, 3638 dwarf2out_begin_block, 3639 dwarf2out_end_block, 3640 dwarf2out_ignore_block, 3641 dwarf2out_source_line, 3642 dwarf2out_begin_prologue, 3643 debug_nothing_int_charstar, /* end_prologue */ 3644 dwarf2out_end_epilogue, 3645 dwarf2out_begin_function, 3646 debug_nothing_int, /* end_function */ 3647 dwarf2out_decl, /* function_decl */ 3648 dwarf2out_global_decl, 3649 dwarf2out_type_decl, /* type_decl */ 3650 dwarf2out_imported_module_or_decl, 3651 debug_nothing_tree, /* deferred_inline_function */ 3652 /* The DWARF 2 backend tries to reduce debugging bloat by not 3653 emitting the abstract description of inline functions until 3654 something tries to reference them. */ 3655 dwarf2out_abstract_function, /* outlining_inline_function */ 3656 debug_nothing_rtx, /* label */ 3657 debug_nothing_int, /* handle_pch */ 3658 dwarf2out_var_location, 3659 dwarf2out_switch_text_section, 3660 1 /* start_end_main_source_file */ 3661}; 3662#endif 3663 3664/* NOTE: In the comments in this file, many references are made to 3665 "Debugging Information Entries". This term is abbreviated as `DIE' 3666 throughout the remainder of this file. */ 3667 3668/* An internal representation of the DWARF output is built, and then 3669 walked to generate the DWARF debugging info. The walk of the internal 3670 representation is done after the entire program has been compiled. 3671 The types below are used to describe the internal representation. */ 3672 3673/* Various DIE's use offsets relative to the beginning of the 3674 .debug_info section to refer to each other. */ 3675 3676typedef long int dw_offset; 3677 3678/* Define typedefs here to avoid circular dependencies. */ 3679 3680typedef struct dw_attr_struct *dw_attr_ref; 3681typedef struct dw_line_info_struct *dw_line_info_ref; 3682typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref; 3683typedef struct pubname_struct *pubname_ref; 3684typedef struct dw_ranges_struct *dw_ranges_ref; 3685 3686/* Each entry in the line_info_table maintains the file and 3687 line number associated with the label generated for that 3688 entry. The label gives the PC value associated with 3689 the line number entry. */ 3690 3691typedef struct dw_line_info_struct GTY(()) 3692{ 3693 unsigned long dw_file_num; 3694 unsigned long dw_line_num; 3695} 3696dw_line_info_entry; 3697 3698/* Line information for functions in separate sections; each one gets its 3699 own sequence. */ 3700typedef struct dw_separate_line_info_struct GTY(()) 3701{ 3702 unsigned long dw_file_num; 3703 unsigned long dw_line_num; 3704 unsigned long function; 3705} 3706dw_separate_line_info_entry; 3707 3708/* Each DIE attribute has a field specifying the attribute kind, 3709 a link to the next attribute in the chain, and an attribute value. 3710 Attributes are typically linked below the DIE they modify. */ 3711 3712typedef struct dw_attr_struct GTY(()) 3713{ 3714 enum dwarf_attribute dw_attr; 3715 dw_val_node dw_attr_val; 3716} 3717dw_attr_node; 3718 3719DEF_VEC_O(dw_attr_node); 3720DEF_VEC_ALLOC_O(dw_attr_node,gc); 3721 3722/* The Debugging Information Entry (DIE) structure. DIEs form a tree. 3723 The children of each node form a circular list linked by 3724 die_sib. die_child points to the node *before* the "first" child node. */ 3725 3726typedef struct die_struct GTY(()) 3727{ 3728 enum dwarf_tag die_tag; 3729 char *die_symbol; 3730 VEC(dw_attr_node,gc) * die_attr; 3731 dw_die_ref die_parent; 3732 dw_die_ref die_child; 3733 dw_die_ref die_sib; 3734 dw_die_ref die_definition; /* ref from a specification to its definition */ 3735 dw_offset die_offset; 3736 unsigned long die_abbrev; 3737 int die_mark; 3738 /* Die is used and must not be pruned as unused. */ 3739 int die_perennial_p; 3740 unsigned int decl_id; 3741} 3742die_node; 3743 3744/* Evaluate 'expr' while 'c' is set to each child of DIE in order. */ 3745#define FOR_EACH_CHILD(die, c, expr) do { \ 3746 c = die->die_child; \ 3747 if (c) do { \ 3748 c = c->die_sib; \ 3749 expr; \ 3750 } while (c != die->die_child); \ 3751} while (0) 3752 3753/* The pubname structure */ 3754 3755typedef struct pubname_struct GTY(()) 3756{ 3757 dw_die_ref die; 3758 char *name; 3759} 3760pubname_entry; 3761 3762struct dw_ranges_struct GTY(()) 3763{ 3764 int block_num; 3765}; 3766 3767/* The limbo die list structure. */ 3768typedef struct limbo_die_struct GTY(()) 3769{ 3770 dw_die_ref die; 3771 tree created_for; 3772 struct limbo_die_struct *next; 3773} 3774limbo_die_node; 3775 3776/* How to start an assembler comment. */ 3777#ifndef ASM_COMMENT_START 3778#define ASM_COMMENT_START ";#" 3779#endif 3780 3781/* Define a macro which returns nonzero for a TYPE_DECL which was 3782 implicitly generated for a tagged type. 3783 3784 Note that unlike the gcc front end (which generates a NULL named 3785 TYPE_DECL node for each complete tagged type, each array type, and 3786 each function type node created) the g++ front end generates a 3787 _named_ TYPE_DECL node for each tagged type node created. 3788 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to 3789 generate a DW_TAG_typedef DIE for them. */ 3790 3791#define TYPE_DECL_IS_STUB(decl) \ 3792 (DECL_NAME (decl) == NULL_TREE \ 3793 || (DECL_ARTIFICIAL (decl) \ 3794 && is_tagged_type (TREE_TYPE (decl)) \ 3795 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \ 3796 /* This is necessary for stub decls that \ 3797 appear in nested inline functions. */ \ 3798 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \ 3799 && (decl_ultimate_origin (decl) \ 3800 == TYPE_STUB_DECL (TREE_TYPE (decl))))))) 3801 3802/* Information concerning the compilation unit's programming 3803 language, and compiler version. */ 3804 3805/* Fixed size portion of the DWARF compilation unit header. */ 3806#define DWARF_COMPILE_UNIT_HEADER_SIZE \ 3807 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3) 3808 3809/* Fixed size portion of public names info. */ 3810#define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2) 3811 3812/* Fixed size portion of the address range info. */ 3813#define DWARF_ARANGES_HEADER_SIZE \ 3814 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \ 3815 DWARF2_ADDR_SIZE * 2) \ 3816 - DWARF_INITIAL_LENGTH_SIZE) 3817 3818/* Size of padding portion in the address range info. It must be 3819 aligned to twice the pointer size. */ 3820#define DWARF_ARANGES_PAD_SIZE \ 3821 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \ 3822 DWARF2_ADDR_SIZE * 2) \ 3823 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4)) 3824 3825/* Use assembler line directives if available. */ 3826#ifndef DWARF2_ASM_LINE_DEBUG_INFO 3827#ifdef HAVE_AS_DWARF2_DEBUG_LINE 3828#define DWARF2_ASM_LINE_DEBUG_INFO 1 3829#else 3830#define DWARF2_ASM_LINE_DEBUG_INFO 0 3831#endif 3832#endif 3833 3834/* Minimum line offset in a special line info. opcode. 3835 This value was chosen to give a reasonable range of values. */ 3836#define DWARF_LINE_BASE -10 3837 3838/* First special line opcode - leave room for the standard opcodes. */ 3839#define DWARF_LINE_OPCODE_BASE 10 3840 3841/* Range of line offsets in a special line info. opcode. */ 3842#define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1) 3843 3844/* Flag that indicates the initial value of the is_stmt_start flag. 3845 In the present implementation, we do not mark any lines as 3846 the beginning of a source statement, because that information 3847 is not made available by the GCC front-end. */ 3848#define DWARF_LINE_DEFAULT_IS_STMT_START 1 3849 3850#ifdef DWARF2_DEBUGGING_INFO 3851/* This location is used by calc_die_sizes() to keep track 3852 the offset of each DIE within the .debug_info section. */ 3853static unsigned long next_die_offset; 3854#endif 3855 3856/* Record the root of the DIE's built for the current compilation unit. */ 3857static GTY(()) dw_die_ref comp_unit_die; 3858 3859/* A list of DIEs with a NULL parent waiting to be relocated. */ 3860static GTY(()) limbo_die_node *limbo_die_list; 3861 3862/* Filenames referenced by this compilation unit. */ 3863static GTY((param_is (struct dwarf_file_data))) htab_t file_table; 3864 3865/* A hash table of references to DIE's that describe declarations. 3866 The key is a DECL_UID() which is a unique number identifying each decl. */ 3867static GTY ((param_is (struct die_struct))) htab_t decl_die_table; 3868 3869/* Node of the variable location list. */ 3870struct var_loc_node GTY ((chain_next ("%h.next"))) 3871{ 3872 rtx GTY (()) var_loc_note; 3873 const char * GTY (()) label; 3874 const char * GTY (()) section_label; 3875 struct var_loc_node * GTY (()) next; 3876}; 3877 3878/* Variable location list. */ 3879struct var_loc_list_def GTY (()) 3880{ 3881 struct var_loc_node * GTY (()) first; 3882 3883 /* Do not mark the last element of the chained list because 3884 it is marked through the chain. */ 3885 struct var_loc_node * GTY ((skip ("%h"))) last; 3886 3887 /* DECL_UID of the variable decl. */ 3888 unsigned int decl_id; 3889}; 3890typedef struct var_loc_list_def var_loc_list; 3891 3892 3893/* Table of decl location linked lists. */ 3894static GTY ((param_is (var_loc_list))) htab_t decl_loc_table; 3895 3896/* A pointer to the base of a list of references to DIE's that 3897 are uniquely identified by their tag, presence/absence of 3898 children DIE's, and list of attribute/value pairs. */ 3899static GTY((length ("abbrev_die_table_allocated"))) 3900 dw_die_ref *abbrev_die_table; 3901 3902/* Number of elements currently allocated for abbrev_die_table. */ 3903static GTY(()) unsigned abbrev_die_table_allocated; 3904 3905/* Number of elements in type_die_table currently in use. */ 3906static GTY(()) unsigned abbrev_die_table_in_use; 3907 3908/* Size (in elements) of increments by which we may expand the 3909 abbrev_die_table. */ 3910#define ABBREV_DIE_TABLE_INCREMENT 256 3911 3912/* A pointer to the base of a table that contains line information 3913 for each source code line in .text in the compilation unit. */ 3914static GTY((length ("line_info_table_allocated"))) 3915 dw_line_info_ref line_info_table; 3916 3917/* Number of elements currently allocated for line_info_table. */ 3918static GTY(()) unsigned line_info_table_allocated; 3919 3920/* Number of elements in line_info_table currently in use. */ 3921static GTY(()) unsigned line_info_table_in_use; 3922 3923/* True if the compilation unit places functions in more than one section. */ 3924static GTY(()) bool have_multiple_function_sections = false; 3925 3926/* A pointer to the base of a table that contains line information 3927 for each source code line outside of .text in the compilation unit. */ 3928static GTY ((length ("separate_line_info_table_allocated"))) 3929 dw_separate_line_info_ref separate_line_info_table; 3930 3931/* Number of elements currently allocated for separate_line_info_table. */ 3932static GTY(()) unsigned separate_line_info_table_allocated; 3933 3934/* Number of elements in separate_line_info_table currently in use. */ 3935static GTY(()) unsigned separate_line_info_table_in_use; 3936 3937/* Size (in elements) of increments by which we may expand the 3938 line_info_table. */ 3939#define LINE_INFO_TABLE_INCREMENT 1024 3940 3941/* A pointer to the base of a table that contains a list of publicly 3942 accessible names. */ 3943static GTY ((length ("pubname_table_allocated"))) pubname_ref pubname_table; 3944 3945/* Number of elements currently allocated for pubname_table. */ 3946static GTY(()) unsigned pubname_table_allocated; 3947 3948/* Number of elements in pubname_table currently in use. */ 3949static GTY(()) unsigned pubname_table_in_use; 3950 3951/* Size (in elements) of increments by which we may expand the 3952 pubname_table. */ 3953#define PUBNAME_TABLE_INCREMENT 64 3954 3955/* Array of dies for which we should generate .debug_arange info. */ 3956static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table; 3957 3958/* Number of elements currently allocated for arange_table. */ 3959static GTY(()) unsigned arange_table_allocated; 3960 3961/* Number of elements in arange_table currently in use. */ 3962static GTY(()) unsigned arange_table_in_use; 3963 3964/* Size (in elements) of increments by which we may expand the 3965 arange_table. */ 3966#define ARANGE_TABLE_INCREMENT 64 3967 3968/* Array of dies for which we should generate .debug_ranges info. */ 3969static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table; 3970 3971/* Number of elements currently allocated for ranges_table. */ 3972static GTY(()) unsigned ranges_table_allocated; 3973 3974/* Number of elements in ranges_table currently in use. */ 3975static GTY(()) unsigned ranges_table_in_use; 3976 3977/* Size (in elements) of increments by which we may expand the 3978 ranges_table. */ 3979#define RANGES_TABLE_INCREMENT 64 3980 3981/* Whether we have location lists that need outputting */ 3982static GTY(()) bool have_location_lists; 3983 3984/* Unique label counter. */ 3985static GTY(()) unsigned int loclabel_num; 3986 3987#ifdef DWARF2_DEBUGGING_INFO 3988/* Record whether the function being analyzed contains inlined functions. */ 3989static int current_function_has_inlines; 3990#endif 3991#if 0 && defined (MIPS_DEBUGGING_INFO) 3992static int comp_unit_has_inlines; 3993#endif 3994 3995/* The last file entry emitted by maybe_emit_file(). */ 3996static GTY(()) struct dwarf_file_data * last_emitted_file; 3997 3998/* Number of internal labels generated by gen_internal_sym(). */ 3999static GTY(()) int label_num; 4000 4001/* Cached result of previous call to lookup_filename. */ 4002static GTY(()) struct dwarf_file_data * file_table_last_lookup; 4003 4004#ifdef DWARF2_DEBUGGING_INFO 4005 4006/* Offset from the "steady-state frame pointer" to the frame base, 4007 within the current function. */ 4008static HOST_WIDE_INT frame_pointer_fb_offset; 4009 4010/* Forward declarations for functions defined in this file. */ 4011 4012static int is_pseudo_reg (rtx); 4013static tree type_main_variant (tree); 4014static int is_tagged_type (tree); 4015static const char *dwarf_tag_name (unsigned); 4016static const char *dwarf_attr_name (unsigned); 4017static const char *dwarf_form_name (unsigned); 4018static tree decl_ultimate_origin (tree); 4019static tree block_ultimate_origin (tree); 4020static tree decl_class_context (tree); 4021static void add_dwarf_attr (dw_die_ref, dw_attr_ref); 4022static inline enum dw_val_class AT_class (dw_attr_ref); 4023static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned); 4024static inline unsigned AT_flag (dw_attr_ref); 4025static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT); 4026static inline HOST_WIDE_INT AT_int (dw_attr_ref); 4027static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT); 4028static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref); 4029static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long, 4030 unsigned long); 4031static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int, 4032 unsigned int, unsigned char *); 4033static hashval_t debug_str_do_hash (const void *); 4034static int debug_str_eq (const void *, const void *); 4035static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *); 4036static inline const char *AT_string (dw_attr_ref); 4037static int AT_string_form (dw_attr_ref); 4038static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref); 4039static void add_AT_specification (dw_die_ref, dw_die_ref); 4040static inline dw_die_ref AT_ref (dw_attr_ref); 4041static inline int AT_ref_external (dw_attr_ref); 4042static inline void set_AT_ref_external (dw_attr_ref, int); 4043static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned); 4044static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref); 4045static inline dw_loc_descr_ref AT_loc (dw_attr_ref); 4046static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute, 4047 dw_loc_list_ref); 4048static inline dw_loc_list_ref AT_loc_list (dw_attr_ref); 4049static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx); 4050static inline rtx AT_addr (dw_attr_ref); 4051static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *); 4052static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *); 4053static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *); 4054static void add_AT_offset (dw_die_ref, enum dwarf_attribute, 4055 unsigned HOST_WIDE_INT); 4056static void add_AT_range_list (dw_die_ref, enum dwarf_attribute, 4057 unsigned long); 4058static inline const char *AT_lbl (dw_attr_ref); 4059static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute); 4060static const char *get_AT_low_pc (dw_die_ref); 4061static const char *get_AT_hi_pc (dw_die_ref); 4062static const char *get_AT_string (dw_die_ref, enum dwarf_attribute); 4063static int get_AT_flag (dw_die_ref, enum dwarf_attribute); 4064static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute); 4065static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute); 4066static bool is_c_family (void); 4067static bool is_cxx (void); 4068static bool is_java (void); 4069static bool is_fortran (void); 4070static bool is_ada (void); 4071static void remove_AT (dw_die_ref, enum dwarf_attribute); 4072static void remove_child_TAG (dw_die_ref, enum dwarf_tag); 4073static void add_child_die (dw_die_ref, dw_die_ref); 4074static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree); 4075static dw_die_ref lookup_type_die (tree); 4076static void equate_type_number_to_die (tree, dw_die_ref); 4077static hashval_t decl_die_table_hash (const void *); 4078static int decl_die_table_eq (const void *, const void *); 4079static dw_die_ref lookup_decl_die (tree); 4080static hashval_t decl_loc_table_hash (const void *); 4081static int decl_loc_table_eq (const void *, const void *); 4082static var_loc_list *lookup_decl_loc (tree); 4083static void equate_decl_number_to_die (tree, dw_die_ref); 4084static void add_var_loc_to_decl (tree, struct var_loc_node *); 4085static void print_spaces (FILE *); 4086static void print_die (dw_die_ref, FILE *); 4087static void print_dwarf_line_table (FILE *); 4088static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref); 4089static dw_die_ref pop_compile_unit (dw_die_ref); 4090static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *); 4091static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *); 4092static void die_checksum (dw_die_ref, struct md5_ctx *, int *); 4093static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *); 4094static int same_dw_val_p (dw_val_node *, dw_val_node *, int *); 4095static int same_attr_p (dw_attr_ref, dw_attr_ref, int *); 4096static int same_die_p (dw_die_ref, dw_die_ref, int *); 4097static int same_die_p_wrap (dw_die_ref, dw_die_ref); 4098static void compute_section_prefix (dw_die_ref); 4099static int is_type_die (dw_die_ref); 4100static int is_comdat_die (dw_die_ref); 4101static int is_symbol_die (dw_die_ref); 4102static void assign_symbol_names (dw_die_ref); 4103static void break_out_includes (dw_die_ref); 4104static hashval_t htab_cu_hash (const void *); 4105static int htab_cu_eq (const void *, const void *); 4106static void htab_cu_del (void *); 4107static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *); 4108static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned); 4109static void add_sibling_attributes (dw_die_ref); 4110static void build_abbrev_table (dw_die_ref); 4111static void output_location_lists (dw_die_ref); 4112static int constant_size (long unsigned); 4113static unsigned long size_of_die (dw_die_ref); 4114static void calc_die_sizes (dw_die_ref); 4115static void mark_dies (dw_die_ref); 4116static void unmark_dies (dw_die_ref); 4117static void unmark_all_dies (dw_die_ref); 4118static unsigned long size_of_pubnames (void); 4119static unsigned long size_of_aranges (void); 4120static enum dwarf_form value_format (dw_attr_ref); 4121static void output_value_format (dw_attr_ref); 4122static void output_abbrev_section (void); 4123static void output_die_symbol (dw_die_ref); 4124static void output_die (dw_die_ref); 4125static void output_compilation_unit_header (void); 4126static void output_comp_unit (dw_die_ref, int); 4127static const char *dwarf2_name (tree, int); 4128static void add_pubname (tree, dw_die_ref); 4129static void output_pubnames (void); 4130static void add_arange (tree, dw_die_ref); 4131static void output_aranges (void); 4132static unsigned int add_ranges (tree); 4133static void output_ranges (void); 4134static void output_line_info (void); 4135static void output_file_names (void); 4136static dw_die_ref base_type_die (tree); 4137static tree root_type (tree); 4138static int is_base_type (tree); 4139static bool is_subrange_type (tree); 4140static dw_die_ref subrange_type_die (tree, dw_die_ref); 4141static dw_die_ref modified_type_die (tree, int, int, dw_die_ref); 4142static int type_is_enum (tree); 4143static unsigned int dbx_reg_number (rtx); 4144static void add_loc_descr_op_piece (dw_loc_descr_ref *, int); 4145static dw_loc_descr_ref reg_loc_descriptor (rtx); 4146static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int); 4147static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx); 4148static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT); 4149static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT); 4150static int is_based_loc (rtx); 4151static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode); 4152static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx); 4153static dw_loc_descr_ref loc_descriptor (rtx); 4154static dw_loc_descr_ref loc_descriptor_from_tree_1 (tree, int); 4155static dw_loc_descr_ref loc_descriptor_from_tree (tree); 4156static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int); 4157static tree field_type (tree); 4158static unsigned int simple_type_align_in_bits (tree); 4159static unsigned int simple_decl_align_in_bits (tree); 4160static unsigned HOST_WIDE_INT simple_type_size_in_bits (tree); 4161static HOST_WIDE_INT field_byte_offset (tree); 4162static void add_AT_location_description (dw_die_ref, enum dwarf_attribute, 4163 dw_loc_descr_ref); 4164static void add_data_member_location_attribute (dw_die_ref, tree); 4165static void add_const_value_attribute (dw_die_ref, rtx); 4166static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *); 4167static HOST_WIDE_INT extract_int (const unsigned char *, unsigned); 4168static void insert_float (rtx, unsigned char *); 4169static rtx rtl_for_decl_location (tree); 4170static void add_location_or_const_value_attribute (dw_die_ref, tree, 4171 enum dwarf_attribute); 4172static void tree_add_const_value_attribute (dw_die_ref, tree); 4173static void add_name_attribute (dw_die_ref, const char *); 4174static void add_comp_dir_attribute (dw_die_ref); 4175static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree); 4176static void add_subscript_info (dw_die_ref, tree); 4177static void add_byte_size_attribute (dw_die_ref, tree); 4178static void add_bit_offset_attribute (dw_die_ref, tree); 4179static void add_bit_size_attribute (dw_die_ref, tree); 4180static void add_prototyped_attribute (dw_die_ref, tree); 4181static void add_abstract_origin_attribute (dw_die_ref, tree); 4182static void add_pure_or_virtual_attribute (dw_die_ref, tree); 4183static void add_src_coords_attributes (dw_die_ref, tree); 4184static void add_name_and_src_coords_attributes (dw_die_ref, tree); 4185static void push_decl_scope (tree); 4186static void pop_decl_scope (void); 4187static dw_die_ref scope_die_for (tree, dw_die_ref); 4188static inline int local_scope_p (dw_die_ref); 4189static inline int class_or_namespace_scope_p (dw_die_ref); 4190static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref); 4191static void add_calling_convention_attribute (dw_die_ref, tree); 4192static const char *type_tag (tree); 4193static tree member_declared_type (tree); 4194#if 0 4195static const char *decl_start_label (tree); 4196#endif 4197static void gen_array_type_die (tree, dw_die_ref); 4198#if 0 4199static void gen_entry_point_die (tree, dw_die_ref); 4200#endif 4201static void gen_inlined_enumeration_type_die (tree, dw_die_ref); 4202static void gen_inlined_structure_type_die (tree, dw_die_ref); 4203static void gen_inlined_union_type_die (tree, dw_die_ref); 4204static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref); 4205static dw_die_ref gen_formal_parameter_die (tree, dw_die_ref); 4206static void gen_unspecified_parameters_die (tree, dw_die_ref); 4207static void gen_formal_types_die (tree, dw_die_ref); 4208static void gen_subprogram_die (tree, dw_die_ref); 4209static void gen_variable_die (tree, dw_die_ref); 4210static void gen_label_die (tree, dw_die_ref); 4211static void gen_lexical_block_die (tree, dw_die_ref, int); 4212static void gen_inlined_subroutine_die (tree, dw_die_ref, int); 4213static void gen_field_die (tree, dw_die_ref); 4214static void gen_ptr_to_mbr_type_die (tree, dw_die_ref); 4215static dw_die_ref gen_compile_unit_die (const char *); 4216static void gen_inheritance_die (tree, tree, dw_die_ref); 4217static void gen_member_die (tree, dw_die_ref); 4218static void gen_struct_or_union_type_die (tree, dw_die_ref, 4219 enum debug_info_usage); 4220static void gen_subroutine_type_die (tree, dw_die_ref); 4221static void gen_typedef_die (tree, dw_die_ref); 4222static void gen_type_die (tree, dw_die_ref); 4223static void gen_tagged_type_instantiation_die (tree, dw_die_ref); 4224static void gen_block_die (tree, dw_die_ref, int); 4225static void decls_for_scope (tree, dw_die_ref, int); 4226static int is_redundant_typedef (tree); 4227static void gen_namespace_die (tree); 4228static void gen_decl_die (tree, dw_die_ref); 4229static dw_die_ref force_decl_die (tree); 4230static dw_die_ref force_type_die (tree); 4231static dw_die_ref setup_namespace_context (tree, dw_die_ref); 4232static void declare_in_namespace (tree, dw_die_ref); 4233static struct dwarf_file_data * lookup_filename (const char *); 4234static void retry_incomplete_types (void); 4235static void gen_type_die_for_member (tree, tree, dw_die_ref); 4236static void splice_child_die (dw_die_ref, dw_die_ref); 4237static int file_info_cmp (const void *, const void *); 4238static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *, 4239 const char *, const char *, unsigned); 4240static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref, 4241 const char *, const char *, 4242 const char *); 4243static void output_loc_list (dw_loc_list_ref); 4244static char *gen_internal_sym (const char *); 4245 4246static void prune_unmark_dies (dw_die_ref); 4247static void prune_unused_types_mark (dw_die_ref, int); 4248static void prune_unused_types_walk (dw_die_ref); 4249static void prune_unused_types_walk_attribs (dw_die_ref); 4250static void prune_unused_types_prune (dw_die_ref); 4251static void prune_unused_types (void); 4252static int maybe_emit_file (struct dwarf_file_data *fd); 4253 4254/* Section names used to hold DWARF debugging information. */ 4255#ifndef DEBUG_INFO_SECTION 4256#define DEBUG_INFO_SECTION ".debug_info" 4257#endif 4258#ifndef DEBUG_ABBREV_SECTION 4259#define DEBUG_ABBREV_SECTION ".debug_abbrev" 4260#endif 4261#ifndef DEBUG_ARANGES_SECTION 4262#define DEBUG_ARANGES_SECTION ".debug_aranges" 4263#endif 4264#ifndef DEBUG_MACINFO_SECTION 4265#define DEBUG_MACINFO_SECTION ".debug_macinfo" 4266#endif 4267#ifndef DEBUG_LINE_SECTION 4268#define DEBUG_LINE_SECTION ".debug_line" 4269#endif 4270#ifndef DEBUG_LOC_SECTION 4271#define DEBUG_LOC_SECTION ".debug_loc" 4272#endif 4273#ifndef DEBUG_PUBNAMES_SECTION 4274#define DEBUG_PUBNAMES_SECTION ".debug_pubnames" 4275#endif 4276#ifndef DEBUG_STR_SECTION 4277#define DEBUG_STR_SECTION ".debug_str" 4278#endif 4279#ifndef DEBUG_RANGES_SECTION 4280#define DEBUG_RANGES_SECTION ".debug_ranges" 4281#endif 4282 4283/* Standard ELF section names for compiled code and data. */ 4284#ifndef TEXT_SECTION_NAME 4285#define TEXT_SECTION_NAME ".text" 4286#endif 4287 4288/* Section flags for .debug_str section. */ 4289#define DEBUG_STR_SECTION_FLAGS \ 4290 (HAVE_GAS_SHF_MERGE && flag_merge_constants \ 4291 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \ 4292 : SECTION_DEBUG) 4293 4294/* Labels we insert at beginning sections we can reference instead of 4295 the section names themselves. */ 4296 4297#ifndef TEXT_SECTION_LABEL 4298#define TEXT_SECTION_LABEL "Ltext" 4299#endif 4300#ifndef COLD_TEXT_SECTION_LABEL 4301#define COLD_TEXT_SECTION_LABEL "Ltext_cold" 4302#endif 4303#ifndef DEBUG_LINE_SECTION_LABEL 4304#define DEBUG_LINE_SECTION_LABEL "Ldebug_line" 4305#endif 4306#ifndef DEBUG_INFO_SECTION_LABEL 4307#define DEBUG_INFO_SECTION_LABEL "Ldebug_info" 4308#endif 4309#ifndef DEBUG_ABBREV_SECTION_LABEL 4310#define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev" 4311#endif 4312#ifndef DEBUG_LOC_SECTION_LABEL 4313#define DEBUG_LOC_SECTION_LABEL "Ldebug_loc" 4314#endif 4315#ifndef DEBUG_RANGES_SECTION_LABEL 4316#define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges" 4317#endif 4318#ifndef DEBUG_MACINFO_SECTION_LABEL 4319#define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo" 4320#endif 4321 4322/* Definitions of defaults for formats and names of various special 4323 (artificial) labels which may be generated within this file (when the -g 4324 options is used and DWARF2_DEBUGGING_INFO is in effect. 4325 If necessary, these may be overridden from within the tm.h file, but 4326 typically, overriding these defaults is unnecessary. */ 4327 4328static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4329static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4330static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4331static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4332static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4333static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4334static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4335static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4336static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES]; 4337static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES]; 4338 4339#ifndef TEXT_END_LABEL 4340#define TEXT_END_LABEL "Letext" 4341#endif 4342#ifndef COLD_END_LABEL 4343#define COLD_END_LABEL "Letext_cold" 4344#endif 4345#ifndef BLOCK_BEGIN_LABEL 4346#define BLOCK_BEGIN_LABEL "LBB" 4347#endif 4348#ifndef BLOCK_END_LABEL 4349#define BLOCK_END_LABEL "LBE" 4350#endif 4351#ifndef LINE_CODE_LABEL 4352#define LINE_CODE_LABEL "LM" 4353#endif 4354#ifndef SEPARATE_LINE_CODE_LABEL 4355#define SEPARATE_LINE_CODE_LABEL "LSM" 4356#endif 4357 4358/* We allow a language front-end to designate a function that is to be 4359 called to "demangle" any name before it is put into a DIE. */ 4360 4361static const char *(*demangle_name_func) (const char *); 4362 4363void 4364dwarf2out_set_demangle_name_func (const char *(*func) (const char *)) 4365{ 4366 demangle_name_func = func; 4367} 4368 4369/* Test if rtl node points to a pseudo register. */ 4370 4371static inline int 4372is_pseudo_reg (rtx rtl) 4373{ 4374 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER) 4375 || (GET_CODE (rtl) == SUBREG 4376 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER)); 4377} 4378 4379/* Return a reference to a type, with its const and volatile qualifiers 4380 removed. */ 4381 4382static inline tree 4383type_main_variant (tree type) 4384{ 4385 type = TYPE_MAIN_VARIANT (type); 4386 4387 /* ??? There really should be only one main variant among any group of 4388 variants of a given type (and all of the MAIN_VARIANT values for all 4389 members of the group should point to that one type) but sometimes the C 4390 front-end messes this up for array types, so we work around that bug 4391 here. */ 4392 if (TREE_CODE (type) == ARRAY_TYPE) 4393 while (type != TYPE_MAIN_VARIANT (type)) 4394 type = TYPE_MAIN_VARIANT (type); 4395 4396 return type; 4397} 4398 4399/* Return nonzero if the given type node represents a tagged type. */ 4400 4401static inline int 4402is_tagged_type (tree type) 4403{ 4404 enum tree_code code = TREE_CODE (type); 4405 4406 return (code == RECORD_TYPE || code == UNION_TYPE 4407 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE); 4408} 4409 4410/* Convert a DIE tag into its string name. */ 4411 4412static const char * 4413dwarf_tag_name (unsigned int tag) 4414{ 4415 switch (tag) 4416 { 4417 case DW_TAG_padding: 4418 return "DW_TAG_padding"; 4419 case DW_TAG_array_type: 4420 return "DW_TAG_array_type"; 4421 case DW_TAG_class_type: 4422 return "DW_TAG_class_type"; 4423 case DW_TAG_entry_point: 4424 return "DW_TAG_entry_point"; 4425 case DW_TAG_enumeration_type: 4426 return "DW_TAG_enumeration_type"; 4427 case DW_TAG_formal_parameter: 4428 return "DW_TAG_formal_parameter"; 4429 case DW_TAG_imported_declaration: 4430 return "DW_TAG_imported_declaration"; 4431 case DW_TAG_label: 4432 return "DW_TAG_label"; 4433 case DW_TAG_lexical_block: 4434 return "DW_TAG_lexical_block"; 4435 case DW_TAG_member: 4436 return "DW_TAG_member"; 4437 case DW_TAG_pointer_type: 4438 return "DW_TAG_pointer_type"; 4439 case DW_TAG_reference_type: 4440 return "DW_TAG_reference_type"; 4441 case DW_TAG_compile_unit: 4442 return "DW_TAG_compile_unit"; 4443 case DW_TAG_string_type: 4444 return "DW_TAG_string_type"; 4445 case DW_TAG_structure_type: 4446 return "DW_TAG_structure_type"; 4447 case DW_TAG_subroutine_type: 4448 return "DW_TAG_subroutine_type"; 4449 case DW_TAG_typedef: 4450 return "DW_TAG_typedef"; 4451 case DW_TAG_union_type: 4452 return "DW_TAG_union_type"; 4453 case DW_TAG_unspecified_parameters: 4454 return "DW_TAG_unspecified_parameters"; 4455 case DW_TAG_variant: 4456 return "DW_TAG_variant"; 4457 case DW_TAG_common_block: 4458 return "DW_TAG_common_block"; 4459 case DW_TAG_common_inclusion: 4460 return "DW_TAG_common_inclusion"; 4461 case DW_TAG_inheritance: 4462 return "DW_TAG_inheritance"; 4463 case DW_TAG_inlined_subroutine: 4464 return "DW_TAG_inlined_subroutine"; 4465 case DW_TAG_module: 4466 return "DW_TAG_module"; 4467 case DW_TAG_ptr_to_member_type: 4468 return "DW_TAG_ptr_to_member_type"; 4469 case DW_TAG_set_type: 4470 return "DW_TAG_set_type"; 4471 case DW_TAG_subrange_type: 4472 return "DW_TAG_subrange_type"; 4473 case DW_TAG_with_stmt: 4474 return "DW_TAG_with_stmt"; 4475 case DW_TAG_access_declaration: 4476 return "DW_TAG_access_declaration"; 4477 case DW_TAG_base_type: 4478 return "DW_TAG_base_type"; 4479 case DW_TAG_catch_block: 4480 return "DW_TAG_catch_block"; 4481 case DW_TAG_const_type: 4482 return "DW_TAG_const_type"; 4483 case DW_TAG_constant: 4484 return "DW_TAG_constant"; 4485 case DW_TAG_enumerator: 4486 return "DW_TAG_enumerator"; 4487 case DW_TAG_file_type: 4488 return "DW_TAG_file_type"; 4489 case DW_TAG_friend: 4490 return "DW_TAG_friend"; 4491 case DW_TAG_namelist: 4492 return "DW_TAG_namelist"; 4493 case DW_TAG_namelist_item: 4494 return "DW_TAG_namelist_item"; 4495 case DW_TAG_namespace: 4496 return "DW_TAG_namespace"; 4497 case DW_TAG_packed_type: 4498 return "DW_TAG_packed_type"; 4499 case DW_TAG_subprogram: 4500 return "DW_TAG_subprogram"; 4501 case DW_TAG_template_type_param: 4502 return "DW_TAG_template_type_param"; 4503 case DW_TAG_template_value_param: 4504 return "DW_TAG_template_value_param"; 4505 case DW_TAG_thrown_type: 4506 return "DW_TAG_thrown_type"; 4507 case DW_TAG_try_block: 4508 return "DW_TAG_try_block"; 4509 case DW_TAG_variant_part: 4510 return "DW_TAG_variant_part"; 4511 case DW_TAG_variable: 4512 return "DW_TAG_variable"; 4513 case DW_TAG_volatile_type: 4514 return "DW_TAG_volatile_type"; 4515 case DW_TAG_imported_module: 4516 return "DW_TAG_imported_module"; 4517 case DW_TAG_MIPS_loop: 4518 return "DW_TAG_MIPS_loop"; 4519 case DW_TAG_format_label: 4520 return "DW_TAG_format_label"; 4521 case DW_TAG_function_template: 4522 return "DW_TAG_function_template"; 4523 case DW_TAG_class_template: 4524 return "DW_TAG_class_template"; 4525 case DW_TAG_GNU_BINCL: 4526 return "DW_TAG_GNU_BINCL"; 4527 case DW_TAG_GNU_EINCL: 4528 return "DW_TAG_GNU_EINCL"; 4529 default: 4530 return "DW_TAG_<unknown>"; 4531 } 4532} 4533 4534/* Convert a DWARF attribute code into its string name. */ 4535 4536static const char * 4537dwarf_attr_name (unsigned int attr) 4538{ 4539 switch (attr) 4540 { 4541 case DW_AT_sibling: 4542 return "DW_AT_sibling"; 4543 case DW_AT_location: 4544 return "DW_AT_location"; 4545 case DW_AT_name: 4546 return "DW_AT_name"; 4547 case DW_AT_ordering: 4548 return "DW_AT_ordering"; 4549 case DW_AT_subscr_data: 4550 return "DW_AT_subscr_data"; 4551 case DW_AT_byte_size: 4552 return "DW_AT_byte_size"; 4553 case DW_AT_bit_offset: 4554 return "DW_AT_bit_offset"; 4555 case DW_AT_bit_size: 4556 return "DW_AT_bit_size"; 4557 case DW_AT_element_list: 4558 return "DW_AT_element_list"; 4559 case DW_AT_stmt_list: 4560 return "DW_AT_stmt_list"; 4561 case DW_AT_low_pc: 4562 return "DW_AT_low_pc"; 4563 case DW_AT_high_pc: 4564 return "DW_AT_high_pc"; 4565 case DW_AT_language: 4566 return "DW_AT_language"; 4567 case DW_AT_member: 4568 return "DW_AT_member"; 4569 case DW_AT_discr: 4570 return "DW_AT_discr"; 4571 case DW_AT_discr_value: 4572 return "DW_AT_discr_value"; 4573 case DW_AT_visibility: 4574 return "DW_AT_visibility"; 4575 case DW_AT_import: 4576 return "DW_AT_import"; 4577 case DW_AT_string_length: 4578 return "DW_AT_string_length"; 4579 case DW_AT_common_reference: 4580 return "DW_AT_common_reference"; 4581 case DW_AT_comp_dir: 4582 return "DW_AT_comp_dir"; 4583 case DW_AT_const_value: 4584 return "DW_AT_const_value"; 4585 case DW_AT_containing_type: 4586 return "DW_AT_containing_type"; 4587 case DW_AT_default_value: 4588 return "DW_AT_default_value"; 4589 case DW_AT_inline: 4590 return "DW_AT_inline"; 4591 case DW_AT_is_optional: 4592 return "DW_AT_is_optional"; 4593 case DW_AT_lower_bound: 4594 return "DW_AT_lower_bound"; 4595 case DW_AT_producer: 4596 return "DW_AT_producer"; 4597 case DW_AT_prototyped: 4598 return "DW_AT_prototyped"; 4599 case DW_AT_return_addr: 4600 return "DW_AT_return_addr"; 4601 case DW_AT_start_scope: 4602 return "DW_AT_start_scope"; 4603 case DW_AT_stride_size: 4604 return "DW_AT_stride_size"; 4605 case DW_AT_upper_bound: 4606 return "DW_AT_upper_bound"; 4607 case DW_AT_abstract_origin: 4608 return "DW_AT_abstract_origin"; 4609 case DW_AT_accessibility: 4610 return "DW_AT_accessibility"; 4611 case DW_AT_address_class: 4612 return "DW_AT_address_class"; 4613 case DW_AT_artificial: 4614 return "DW_AT_artificial"; 4615 case DW_AT_base_types: 4616 return "DW_AT_base_types"; 4617 case DW_AT_calling_convention: 4618 return "DW_AT_calling_convention"; 4619 case DW_AT_count: 4620 return "DW_AT_count"; 4621 case DW_AT_data_member_location: 4622 return "DW_AT_data_member_location"; 4623 case DW_AT_decl_column: 4624 return "DW_AT_decl_column"; 4625 case DW_AT_decl_file: 4626 return "DW_AT_decl_file"; 4627 case DW_AT_decl_line: 4628 return "DW_AT_decl_line"; 4629 case DW_AT_declaration: 4630 return "DW_AT_declaration"; 4631 case DW_AT_discr_list: 4632 return "DW_AT_discr_list"; 4633 case DW_AT_encoding: 4634 return "DW_AT_encoding"; 4635 case DW_AT_external: 4636 return "DW_AT_external"; 4637 case DW_AT_frame_base: 4638 return "DW_AT_frame_base"; 4639 case DW_AT_friend: 4640 return "DW_AT_friend"; 4641 case DW_AT_identifier_case: 4642 return "DW_AT_identifier_case"; 4643 case DW_AT_macro_info: 4644 return "DW_AT_macro_info"; 4645 case DW_AT_namelist_items: 4646 return "DW_AT_namelist_items"; 4647 case DW_AT_priority: 4648 return "DW_AT_priority"; 4649 case DW_AT_segment: 4650 return "DW_AT_segment"; 4651 case DW_AT_specification: 4652 return "DW_AT_specification"; 4653 case DW_AT_static_link: 4654 return "DW_AT_static_link"; 4655 case DW_AT_type: 4656 return "DW_AT_type"; 4657 case DW_AT_use_location: 4658 return "DW_AT_use_location"; 4659 case DW_AT_variable_parameter: 4660 return "DW_AT_variable_parameter"; 4661 case DW_AT_virtuality: 4662 return "DW_AT_virtuality"; 4663 case DW_AT_vtable_elem_location: 4664 return "DW_AT_vtable_elem_location"; 4665 4666 case DW_AT_allocated: 4667 return "DW_AT_allocated"; 4668 case DW_AT_associated: 4669 return "DW_AT_associated"; 4670 case DW_AT_data_location: 4671 return "DW_AT_data_location"; 4672 case DW_AT_stride: 4673 return "DW_AT_stride"; 4674 case DW_AT_entry_pc: 4675 return "DW_AT_entry_pc"; 4676 case DW_AT_use_UTF8: 4677 return "DW_AT_use_UTF8"; 4678 case DW_AT_extension: 4679 return "DW_AT_extension"; 4680 case DW_AT_ranges: 4681 return "DW_AT_ranges"; 4682 case DW_AT_trampoline: 4683 return "DW_AT_trampoline"; 4684 case DW_AT_call_column: 4685 return "DW_AT_call_column"; 4686 case DW_AT_call_file: 4687 return "DW_AT_call_file"; 4688 case DW_AT_call_line: 4689 return "DW_AT_call_line"; 4690 4691 case DW_AT_MIPS_fde: 4692 return "DW_AT_MIPS_fde"; 4693 case DW_AT_MIPS_loop_begin: 4694 return "DW_AT_MIPS_loop_begin"; 4695 case DW_AT_MIPS_tail_loop_begin: 4696 return "DW_AT_MIPS_tail_loop_begin"; 4697 case DW_AT_MIPS_epilog_begin: 4698 return "DW_AT_MIPS_epilog_begin"; 4699 case DW_AT_MIPS_loop_unroll_factor: 4700 return "DW_AT_MIPS_loop_unroll_factor"; 4701 case DW_AT_MIPS_software_pipeline_depth: 4702 return "DW_AT_MIPS_software_pipeline_depth"; 4703 case DW_AT_MIPS_linkage_name: 4704 return "DW_AT_MIPS_linkage_name"; 4705 case DW_AT_MIPS_stride: 4706 return "DW_AT_MIPS_stride"; 4707 case DW_AT_MIPS_abstract_name: 4708 return "DW_AT_MIPS_abstract_name"; 4709 case DW_AT_MIPS_clone_origin: 4710 return "DW_AT_MIPS_clone_origin"; 4711 case DW_AT_MIPS_has_inlines: 4712 return "DW_AT_MIPS_has_inlines"; 4713 4714 case DW_AT_sf_names: 4715 return "DW_AT_sf_names"; 4716 case DW_AT_src_info: 4717 return "DW_AT_src_info"; 4718 case DW_AT_mac_info: 4719 return "DW_AT_mac_info"; 4720 case DW_AT_src_coords: 4721 return "DW_AT_src_coords"; 4722 case DW_AT_body_begin: 4723 return "DW_AT_body_begin"; 4724 case DW_AT_body_end: 4725 return "DW_AT_body_end"; 4726 case DW_AT_GNU_vector: 4727 return "DW_AT_GNU_vector"; 4728 4729 case DW_AT_VMS_rtnbeg_pd_address: 4730 return "DW_AT_VMS_rtnbeg_pd_address"; 4731 4732 default: 4733 return "DW_AT_<unknown>"; 4734 } 4735} 4736 4737/* Convert a DWARF value form code into its string name. */ 4738 4739static const char * 4740dwarf_form_name (unsigned int form) 4741{ 4742 switch (form) 4743 { 4744 case DW_FORM_addr: 4745 return "DW_FORM_addr"; 4746 case DW_FORM_block2: 4747 return "DW_FORM_block2"; 4748 case DW_FORM_block4: 4749 return "DW_FORM_block4"; 4750 case DW_FORM_data2: 4751 return "DW_FORM_data2"; 4752 case DW_FORM_data4: 4753 return "DW_FORM_data4"; 4754 case DW_FORM_data8: 4755 return "DW_FORM_data8"; 4756 case DW_FORM_string: 4757 return "DW_FORM_string"; 4758 case DW_FORM_block: 4759 return "DW_FORM_block"; 4760 case DW_FORM_block1: 4761 return "DW_FORM_block1"; 4762 case DW_FORM_data1: 4763 return "DW_FORM_data1"; 4764 case DW_FORM_flag: 4765 return "DW_FORM_flag"; 4766 case DW_FORM_sdata: 4767 return "DW_FORM_sdata"; 4768 case DW_FORM_strp: 4769 return "DW_FORM_strp"; 4770 case DW_FORM_udata: 4771 return "DW_FORM_udata"; 4772 case DW_FORM_ref_addr: 4773 return "DW_FORM_ref_addr"; 4774 case DW_FORM_ref1: 4775 return "DW_FORM_ref1"; 4776 case DW_FORM_ref2: 4777 return "DW_FORM_ref2"; 4778 case DW_FORM_ref4: 4779 return "DW_FORM_ref4"; 4780 case DW_FORM_ref8: 4781 return "DW_FORM_ref8"; 4782 case DW_FORM_ref_udata: 4783 return "DW_FORM_ref_udata"; 4784 case DW_FORM_indirect: 4785 return "DW_FORM_indirect"; 4786 default: 4787 return "DW_FORM_<unknown>"; 4788 } 4789} 4790 4791/* Determine the "ultimate origin" of a decl. The decl may be an inlined 4792 instance of an inlined instance of a decl which is local to an inline 4793 function, so we have to trace all of the way back through the origin chain 4794 to find out what sort of node actually served as the original seed for the 4795 given block. */ 4796 4797static tree 4798decl_ultimate_origin (tree decl) 4799{ 4800 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON)) 4801 return NULL_TREE; 4802 4803 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the 4804 nodes in the function to point to themselves; ignore that if 4805 we're trying to output the abstract instance of this function. */ 4806 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl) 4807 return NULL_TREE; 4808 4809 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the 4810 most distant ancestor, this should never happen. */ 4811 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl))); 4812 4813 return DECL_ABSTRACT_ORIGIN (decl); 4814} 4815 4816/* Determine the "ultimate origin" of a block. The block may be an inlined 4817 instance of an inlined instance of a block which is local to an inline 4818 function, so we have to trace all of the way back through the origin chain 4819 to find out what sort of node actually served as the original seed for the 4820 given block. */ 4821 4822static tree 4823block_ultimate_origin (tree block) 4824{ 4825 tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block); 4826 4827 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the 4828 nodes in the function to point to themselves; ignore that if 4829 we're trying to output the abstract instance of this function. */ 4830 if (BLOCK_ABSTRACT (block) && immediate_origin == block) 4831 return NULL_TREE; 4832 4833 if (immediate_origin == NULL_TREE) 4834 return NULL_TREE; 4835 else 4836 { 4837 tree ret_val; 4838 tree lookahead = immediate_origin; 4839 4840 do 4841 { 4842 ret_val = lookahead; 4843 lookahead = (TREE_CODE (ret_val) == BLOCK 4844 ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL); 4845 } 4846 while (lookahead != NULL && lookahead != ret_val); 4847 4848 /* The block's abstract origin chain may not be the *ultimate* origin of 4849 the block. It could lead to a DECL that has an abstract origin set. 4850 If so, we want that DECL's abstract origin (which is what DECL_ORIGIN 4851 will give us if it has one). Note that DECL's abstract origins are 4852 supposed to be the most distant ancestor (or so decl_ultimate_origin 4853 claims), so we don't need to loop following the DECL origins. */ 4854 if (DECL_P (ret_val)) 4855 return DECL_ORIGIN (ret_val); 4856 4857 return ret_val; 4858 } 4859} 4860 4861/* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT 4862 of a virtual function may refer to a base class, so we check the 'this' 4863 parameter. */ 4864 4865static tree 4866decl_class_context (tree decl) 4867{ 4868 tree context = NULL_TREE; 4869 4870 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl)) 4871 context = DECL_CONTEXT (decl); 4872 else 4873 context = TYPE_MAIN_VARIANT 4874 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))))); 4875 4876 if (context && !TYPE_P (context)) 4877 context = NULL_TREE; 4878 4879 return context; 4880} 4881 4882/* Add an attribute/value pair to a DIE. */ 4883 4884static inline void 4885add_dwarf_attr (dw_die_ref die, dw_attr_ref attr) 4886{ 4887 /* Maybe this should be an assert? */ 4888 if (die == NULL) 4889 return; 4890 4891 if (die->die_attr == NULL) 4892 die->die_attr = VEC_alloc (dw_attr_node, gc, 1); 4893 VEC_safe_push (dw_attr_node, gc, die->die_attr, attr); 4894} 4895 4896static inline enum dw_val_class 4897AT_class (dw_attr_ref a) 4898{ 4899 return a->dw_attr_val.val_class; 4900} 4901 4902/* Add a flag value attribute to a DIE. */ 4903 4904static inline void 4905add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag) 4906{ 4907 dw_attr_node attr; 4908 4909 attr.dw_attr = attr_kind; 4910 attr.dw_attr_val.val_class = dw_val_class_flag; 4911 attr.dw_attr_val.v.val_flag = flag; 4912 add_dwarf_attr (die, &attr); 4913} 4914 4915static inline unsigned 4916AT_flag (dw_attr_ref a) 4917{ 4918 gcc_assert (a && AT_class (a) == dw_val_class_flag); 4919 return a->dw_attr_val.v.val_flag; 4920} 4921 4922/* Add a signed integer attribute value to a DIE. */ 4923 4924static inline void 4925add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val) 4926{ 4927 dw_attr_node attr; 4928 4929 attr.dw_attr = attr_kind; 4930 attr.dw_attr_val.val_class = dw_val_class_const; 4931 attr.dw_attr_val.v.val_int = int_val; 4932 add_dwarf_attr (die, &attr); 4933} 4934 4935static inline HOST_WIDE_INT 4936AT_int (dw_attr_ref a) 4937{ 4938 gcc_assert (a && AT_class (a) == dw_val_class_const); 4939 return a->dw_attr_val.v.val_int; 4940} 4941 4942/* Add an unsigned integer attribute value to a DIE. */ 4943 4944static inline void 4945add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind, 4946 unsigned HOST_WIDE_INT unsigned_val) 4947{ 4948 dw_attr_node attr; 4949 4950 attr.dw_attr = attr_kind; 4951 attr.dw_attr_val.val_class = dw_val_class_unsigned_const; 4952 attr.dw_attr_val.v.val_unsigned = unsigned_val; 4953 add_dwarf_attr (die, &attr); 4954} 4955 4956static inline unsigned HOST_WIDE_INT 4957AT_unsigned (dw_attr_ref a) 4958{ 4959 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const); 4960 return a->dw_attr_val.v.val_unsigned; 4961} 4962 4963/* Add an unsigned double integer attribute value to a DIE. */ 4964 4965static inline void 4966add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind, 4967 long unsigned int val_hi, long unsigned int val_low) 4968{ 4969 dw_attr_node attr; 4970 4971 attr.dw_attr = attr_kind; 4972 attr.dw_attr_val.val_class = dw_val_class_long_long; 4973 attr.dw_attr_val.v.val_long_long.hi = val_hi; 4974 attr.dw_attr_val.v.val_long_long.low = val_low; 4975 add_dwarf_attr (die, &attr); 4976} 4977 4978/* Add a floating point attribute value to a DIE and return it. */ 4979 4980static inline void 4981add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind, 4982 unsigned int length, unsigned int elt_size, unsigned char *array) 4983{ 4984 dw_attr_node attr; 4985 4986 attr.dw_attr = attr_kind; 4987 attr.dw_attr_val.val_class = dw_val_class_vec; 4988 attr.dw_attr_val.v.val_vec.length = length; 4989 attr.dw_attr_val.v.val_vec.elt_size = elt_size; 4990 attr.dw_attr_val.v.val_vec.array = array; 4991 add_dwarf_attr (die, &attr); 4992} 4993 4994/* Hash and equality functions for debug_str_hash. */ 4995 4996static hashval_t 4997debug_str_do_hash (const void *x) 4998{ 4999 return htab_hash_string (((const struct indirect_string_node *)x)->str); 5000} 5001 5002static int 5003debug_str_eq (const void *x1, const void *x2) 5004{ 5005 return strcmp ((((const struct indirect_string_node *)x1)->str), 5006 (const char *)x2) == 0; 5007} 5008 5009/* Add a string attribute value to a DIE. */ 5010 5011static inline void 5012add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str) 5013{ 5014 dw_attr_node attr; 5015 struct indirect_string_node *node; 5016 void **slot; 5017 5018 if (! debug_str_hash) 5019 debug_str_hash = htab_create_ggc (10, debug_str_do_hash, 5020 debug_str_eq, NULL); 5021 5022 slot = htab_find_slot_with_hash (debug_str_hash, str, 5023 htab_hash_string (str), INSERT); 5024 if (*slot == NULL) 5025 *slot = ggc_alloc_cleared (sizeof (struct indirect_string_node)); 5026 node = (struct indirect_string_node *) *slot; 5027 node->str = ggc_strdup (str); 5028 node->refcount++; 5029 5030 attr.dw_attr = attr_kind; 5031 attr.dw_attr_val.val_class = dw_val_class_str; 5032 attr.dw_attr_val.v.val_str = node; 5033 add_dwarf_attr (die, &attr); 5034} 5035 5036static inline const char * 5037AT_string (dw_attr_ref a) 5038{ 5039 gcc_assert (a && AT_class (a) == dw_val_class_str); 5040 return a->dw_attr_val.v.val_str->str; 5041} 5042 5043/* Find out whether a string should be output inline in DIE 5044 or out-of-line in .debug_str section. */ 5045 5046static int 5047AT_string_form (dw_attr_ref a) 5048{ 5049 struct indirect_string_node *node; 5050 unsigned int len; 5051 char label[32]; 5052 5053 gcc_assert (a && AT_class (a) == dw_val_class_str); 5054 5055 node = a->dw_attr_val.v.val_str; 5056 if (node->form) 5057 return node->form; 5058 5059 len = strlen (node->str) + 1; 5060 5061 /* If the string is shorter or equal to the size of the reference, it is 5062 always better to put it inline. */ 5063 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0) 5064 return node->form = DW_FORM_string; 5065 5066 /* If we cannot expect the linker to merge strings in .debug_str 5067 section, only put it into .debug_str if it is worth even in this 5068 single module. */ 5069 if ((debug_str_section->common.flags & SECTION_MERGE) == 0 5070 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len) 5071 return node->form = DW_FORM_string; 5072 5073 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter); 5074 ++dw2_string_counter; 5075 node->label = xstrdup (label); 5076 5077 return node->form = DW_FORM_strp; 5078} 5079 5080/* Add a DIE reference attribute value to a DIE. */ 5081 5082static inline void 5083add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die) 5084{ 5085 dw_attr_node attr; 5086 5087 attr.dw_attr = attr_kind; 5088 attr.dw_attr_val.val_class = dw_val_class_die_ref; 5089 attr.dw_attr_val.v.val_die_ref.die = targ_die; 5090 attr.dw_attr_val.v.val_die_ref.external = 0; 5091 add_dwarf_attr (die, &attr); 5092} 5093 5094/* Add an AT_specification attribute to a DIE, and also make the back 5095 pointer from the specification to the definition. */ 5096 5097static inline void 5098add_AT_specification (dw_die_ref die, dw_die_ref targ_die) 5099{ 5100 add_AT_die_ref (die, DW_AT_specification, targ_die); 5101 gcc_assert (!targ_die->die_definition); 5102 targ_die->die_definition = die; 5103} 5104 5105static inline dw_die_ref 5106AT_ref (dw_attr_ref a) 5107{ 5108 gcc_assert (a && AT_class (a) == dw_val_class_die_ref); 5109 return a->dw_attr_val.v.val_die_ref.die; 5110} 5111 5112static inline int 5113AT_ref_external (dw_attr_ref a) 5114{ 5115 if (a && AT_class (a) == dw_val_class_die_ref) 5116 return a->dw_attr_val.v.val_die_ref.external; 5117 5118 return 0; 5119} 5120 5121static inline void 5122set_AT_ref_external (dw_attr_ref a, int i) 5123{ 5124 gcc_assert (a && AT_class (a) == dw_val_class_die_ref); 5125 a->dw_attr_val.v.val_die_ref.external = i; 5126} 5127 5128/* Add an FDE reference attribute value to a DIE. */ 5129 5130static inline void 5131add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde) 5132{ 5133 dw_attr_node attr; 5134 5135 attr.dw_attr = attr_kind; 5136 attr.dw_attr_val.val_class = dw_val_class_fde_ref; 5137 attr.dw_attr_val.v.val_fde_index = targ_fde; 5138 add_dwarf_attr (die, &attr); 5139} 5140 5141/* Add a location description attribute value to a DIE. */ 5142 5143static inline void 5144add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc) 5145{ 5146 dw_attr_node attr; 5147 5148 attr.dw_attr = attr_kind; 5149 attr.dw_attr_val.val_class = dw_val_class_loc; 5150 attr.dw_attr_val.v.val_loc = loc; 5151 add_dwarf_attr (die, &attr); 5152} 5153 5154static inline dw_loc_descr_ref 5155AT_loc (dw_attr_ref a) 5156{ 5157 gcc_assert (a && AT_class (a) == dw_val_class_loc); 5158 return a->dw_attr_val.v.val_loc; 5159} 5160 5161static inline void 5162add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list) 5163{ 5164 dw_attr_node attr; 5165 5166 attr.dw_attr = attr_kind; 5167 attr.dw_attr_val.val_class = dw_val_class_loc_list; 5168 attr.dw_attr_val.v.val_loc_list = loc_list; 5169 add_dwarf_attr (die, &attr); 5170 have_location_lists = true; 5171} 5172 5173static inline dw_loc_list_ref 5174AT_loc_list (dw_attr_ref a) 5175{ 5176 gcc_assert (a && AT_class (a) == dw_val_class_loc_list); 5177 return a->dw_attr_val.v.val_loc_list; 5178} 5179 5180/* Add an address constant attribute value to a DIE. */ 5181 5182static inline void 5183add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr) 5184{ 5185 dw_attr_node attr; 5186 5187 attr.dw_attr = attr_kind; 5188 attr.dw_attr_val.val_class = dw_val_class_addr; 5189 attr.dw_attr_val.v.val_addr = addr; 5190 add_dwarf_attr (die, &attr); 5191} 5192 5193/* Get the RTX from to an address DIE attribute. */ 5194 5195static inline rtx 5196AT_addr (dw_attr_ref a) 5197{ 5198 gcc_assert (a && AT_class (a) == dw_val_class_addr); 5199 return a->dw_attr_val.v.val_addr; 5200} 5201 5202/* Add a file attribute value to a DIE. */ 5203 5204static inline void 5205add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind, 5206 struct dwarf_file_data *fd) 5207{ 5208 dw_attr_node attr; 5209 5210 attr.dw_attr = attr_kind; 5211 attr.dw_attr_val.val_class = dw_val_class_file; 5212 attr.dw_attr_val.v.val_file = fd; 5213 add_dwarf_attr (die, &attr); 5214} 5215 5216/* Get the dwarf_file_data from a file DIE attribute. */ 5217 5218static inline struct dwarf_file_data * 5219AT_file (dw_attr_ref a) 5220{ 5221 gcc_assert (a && AT_class (a) == dw_val_class_file); 5222 return a->dw_attr_val.v.val_file; 5223} 5224 5225/* Add a label identifier attribute value to a DIE. */ 5226 5227static inline void 5228add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id) 5229{ 5230 dw_attr_node attr; 5231 5232 attr.dw_attr = attr_kind; 5233 attr.dw_attr_val.val_class = dw_val_class_lbl_id; 5234 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id); 5235 add_dwarf_attr (die, &attr); 5236} 5237 5238/* Add a section offset attribute value to a DIE, an offset into the 5239 debug_line section. */ 5240 5241static inline void 5242add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind, 5243 const char *label) 5244{ 5245 dw_attr_node attr; 5246 5247 attr.dw_attr = attr_kind; 5248 attr.dw_attr_val.val_class = dw_val_class_lineptr; 5249 attr.dw_attr_val.v.val_lbl_id = xstrdup (label); 5250 add_dwarf_attr (die, &attr); 5251} 5252 5253/* Add a section offset attribute value to a DIE, an offset into the 5254 debug_macinfo section. */ 5255 5256static inline void 5257add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind, 5258 const char *label) 5259{ 5260 dw_attr_node attr; 5261 5262 attr.dw_attr = attr_kind; 5263 attr.dw_attr_val.val_class = dw_val_class_macptr; 5264 attr.dw_attr_val.v.val_lbl_id = xstrdup (label); 5265 add_dwarf_attr (die, &attr); 5266} 5267 5268/* Add an offset attribute value to a DIE. */ 5269 5270static inline void 5271add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind, 5272 unsigned HOST_WIDE_INT offset) 5273{ 5274 dw_attr_node attr; 5275 5276 attr.dw_attr = attr_kind; 5277 attr.dw_attr_val.val_class = dw_val_class_offset; 5278 attr.dw_attr_val.v.val_offset = offset; 5279 add_dwarf_attr (die, &attr); 5280} 5281 5282/* Add an range_list attribute value to a DIE. */ 5283 5284static void 5285add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind, 5286 long unsigned int offset) 5287{ 5288 dw_attr_node attr; 5289 5290 attr.dw_attr = attr_kind; 5291 attr.dw_attr_val.val_class = dw_val_class_range_list; 5292 attr.dw_attr_val.v.val_offset = offset; 5293 add_dwarf_attr (die, &attr); 5294} 5295 5296static inline const char * 5297AT_lbl (dw_attr_ref a) 5298{ 5299 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id 5300 || AT_class (a) == dw_val_class_lineptr 5301 || AT_class (a) == dw_val_class_macptr)); 5302 return a->dw_attr_val.v.val_lbl_id; 5303} 5304 5305/* Get the attribute of type attr_kind. */ 5306 5307static dw_attr_ref 5308get_AT (dw_die_ref die, enum dwarf_attribute attr_kind) 5309{ 5310 dw_attr_ref a; 5311 unsigned ix; 5312 dw_die_ref spec = NULL; 5313 5314 if (! die) 5315 return NULL; 5316 5317 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 5318 if (a->dw_attr == attr_kind) 5319 return a; 5320 else if (a->dw_attr == DW_AT_specification 5321 || a->dw_attr == DW_AT_abstract_origin) 5322 spec = AT_ref (a); 5323 5324 if (spec) 5325 return get_AT (spec, attr_kind); 5326 5327 return NULL; 5328} 5329 5330/* Return the "low pc" attribute value, typically associated with a subprogram 5331 DIE. Return null if the "low pc" attribute is either not present, or if it 5332 cannot be represented as an assembler label identifier. */ 5333 5334static inline const char * 5335get_AT_low_pc (dw_die_ref die) 5336{ 5337 dw_attr_ref a = get_AT (die, DW_AT_low_pc); 5338 5339 return a ? AT_lbl (a) : NULL; 5340} 5341 5342/* Return the "high pc" attribute value, typically associated with a subprogram 5343 DIE. Return null if the "high pc" attribute is either not present, or if it 5344 cannot be represented as an assembler label identifier. */ 5345 5346static inline const char * 5347get_AT_hi_pc (dw_die_ref die) 5348{ 5349 dw_attr_ref a = get_AT (die, DW_AT_high_pc); 5350 5351 return a ? AT_lbl (a) : NULL; 5352} 5353 5354/* Return the value of the string attribute designated by ATTR_KIND, or 5355 NULL if it is not present. */ 5356 5357static inline const char * 5358get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind) 5359{ 5360 dw_attr_ref a = get_AT (die, attr_kind); 5361 5362 return a ? AT_string (a) : NULL; 5363} 5364 5365/* Return the value of the flag attribute designated by ATTR_KIND, or -1 5366 if it is not present. */ 5367 5368static inline int 5369get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind) 5370{ 5371 dw_attr_ref a = get_AT (die, attr_kind); 5372 5373 return a ? AT_flag (a) : 0; 5374} 5375 5376/* Return the value of the unsigned attribute designated by ATTR_KIND, or 0 5377 if it is not present. */ 5378 5379static inline unsigned 5380get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind) 5381{ 5382 dw_attr_ref a = get_AT (die, attr_kind); 5383 5384 return a ? AT_unsigned (a) : 0; 5385} 5386 5387static inline dw_die_ref 5388get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind) 5389{ 5390 dw_attr_ref a = get_AT (die, attr_kind); 5391 5392 return a ? AT_ref (a) : NULL; 5393} 5394 5395static inline struct dwarf_file_data * 5396get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind) 5397{ 5398 dw_attr_ref a = get_AT (die, attr_kind); 5399 5400 return a ? AT_file (a) : NULL; 5401} 5402 5403/* Return TRUE if the language is C or C++. */ 5404 5405static inline bool 5406is_c_family (void) 5407{ 5408 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5409 5410 return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_ObjC 5411 || lang == DW_LANG_C99 5412 || lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus); 5413} 5414 5415/* Return TRUE if the language is C++. */ 5416 5417static inline bool 5418is_cxx (void) 5419{ 5420 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5421 5422 return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus; 5423} 5424 5425/* Return TRUE if the language is Fortran. */ 5426 5427static inline bool 5428is_fortran (void) 5429{ 5430 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5431 5432 return (lang == DW_LANG_Fortran77 5433 || lang == DW_LANG_Fortran90 5434 || lang == DW_LANG_Fortran95); 5435} 5436 5437/* Return TRUE if the language is Java. */ 5438 5439static inline bool 5440is_java (void) 5441{ 5442 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5443 5444 return lang == DW_LANG_Java; 5445} 5446 5447/* Return TRUE if the language is Ada. */ 5448 5449static inline bool 5450is_ada (void) 5451{ 5452 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language); 5453 5454 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83; 5455} 5456 5457/* Remove the specified attribute if present. */ 5458 5459static void 5460remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind) 5461{ 5462 dw_attr_ref a; 5463 unsigned ix; 5464 5465 if (! die) 5466 return; 5467 5468 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 5469 if (a->dw_attr == attr_kind) 5470 { 5471 if (AT_class (a) == dw_val_class_str) 5472 if (a->dw_attr_val.v.val_str->refcount) 5473 a->dw_attr_val.v.val_str->refcount--; 5474 5475 /* VEC_ordered_remove should help reduce the number of abbrevs 5476 that are needed. */ 5477 VEC_ordered_remove (dw_attr_node, die->die_attr, ix); 5478 return; 5479 } 5480} 5481 5482/* Remove CHILD from its parent. PREV must have the property that 5483 PREV->DIE_SIB == CHILD. Does not alter CHILD. */ 5484 5485static void 5486remove_child_with_prev (dw_die_ref child, dw_die_ref prev) 5487{ 5488 gcc_assert (child->die_parent == prev->die_parent); 5489 gcc_assert (prev->die_sib == child); 5490 if (prev == child) 5491 { 5492 gcc_assert (child->die_parent->die_child == child); 5493 prev = NULL; 5494 } 5495 else 5496 prev->die_sib = child->die_sib; 5497 if (child->die_parent->die_child == child) 5498 child->die_parent->die_child = prev; 5499} 5500 5501/* Remove child DIE whose die_tag is TAG. Do nothing if no child 5502 matches TAG. */ 5503 5504static void 5505remove_child_TAG (dw_die_ref die, enum dwarf_tag tag) 5506{ 5507 dw_die_ref c; 5508 5509 c = die->die_child; 5510 if (c) do { 5511 dw_die_ref prev = c; 5512 c = c->die_sib; 5513 while (c->die_tag == tag) 5514 { 5515 remove_child_with_prev (c, prev); 5516 /* Might have removed every child. */ 5517 if (c == c->die_sib) 5518 return; 5519 c = c->die_sib; 5520 } 5521 } while (c != die->die_child); 5522} 5523 5524/* Add a CHILD_DIE as the last child of DIE. */ 5525 5526static void 5527add_child_die (dw_die_ref die, dw_die_ref child_die) 5528{ 5529 /* FIXME this should probably be an assert. */ 5530 if (! die || ! child_die) 5531 return; 5532 gcc_assert (die != child_die); 5533 5534 child_die->die_parent = die; 5535 if (die->die_child) 5536 { 5537 child_die->die_sib = die->die_child->die_sib; 5538 die->die_child->die_sib = child_die; 5539 } 5540 else 5541 child_die->die_sib = child_die; 5542 die->die_child = child_die; 5543} 5544 5545/* Move CHILD, which must be a child of PARENT or the DIE for which PARENT 5546 is the specification, to the end of PARENT's list of children. 5547 This is done by removing and re-adding it. */ 5548 5549static void 5550splice_child_die (dw_die_ref parent, dw_die_ref child) 5551{ 5552 dw_die_ref p; 5553 5554 /* We want the declaration DIE from inside the class, not the 5555 specification DIE at toplevel. */ 5556 if (child->die_parent != parent) 5557 { 5558 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification); 5559 5560 if (tmp) 5561 child = tmp; 5562 } 5563 5564 gcc_assert (child->die_parent == parent 5565 || (child->die_parent 5566 == get_AT_ref (parent, DW_AT_specification))); 5567 5568 for (p = child->die_parent->die_child; ; p = p->die_sib) 5569 if (p->die_sib == child) 5570 { 5571 remove_child_with_prev (child, p); 5572 break; 5573 } 5574 5575 add_child_die (parent, child); 5576} 5577 5578/* Return a pointer to a newly created DIE node. */ 5579 5580static inline dw_die_ref 5581new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t) 5582{ 5583 dw_die_ref die = ggc_alloc_cleared (sizeof (die_node)); 5584 5585 die->die_tag = tag_value; 5586 5587 if (parent_die != NULL) 5588 add_child_die (parent_die, die); 5589 else 5590 { 5591 limbo_die_node *limbo_node; 5592 5593 limbo_node = ggc_alloc_cleared (sizeof (limbo_die_node)); 5594 limbo_node->die = die; 5595 limbo_node->created_for = t; 5596 limbo_node->next = limbo_die_list; 5597 limbo_die_list = limbo_node; 5598 } 5599 5600 return die; 5601} 5602 5603/* Return the DIE associated with the given type specifier. */ 5604 5605static inline dw_die_ref 5606lookup_type_die (tree type) 5607{ 5608 return TYPE_SYMTAB_DIE (type); 5609} 5610 5611/* Equate a DIE to a given type specifier. */ 5612 5613static inline void 5614equate_type_number_to_die (tree type, dw_die_ref type_die) 5615{ 5616 TYPE_SYMTAB_DIE (type) = type_die; 5617} 5618 5619/* Returns a hash value for X (which really is a die_struct). */ 5620 5621static hashval_t 5622decl_die_table_hash (const void *x) 5623{ 5624 return (hashval_t) ((const dw_die_ref) x)->decl_id; 5625} 5626 5627/* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */ 5628 5629static int 5630decl_die_table_eq (const void *x, const void *y) 5631{ 5632 return (((const dw_die_ref) x)->decl_id == DECL_UID ((const tree) y)); 5633} 5634 5635/* Return the DIE associated with a given declaration. */ 5636 5637static inline dw_die_ref 5638lookup_decl_die (tree decl) 5639{ 5640 return htab_find_with_hash (decl_die_table, decl, DECL_UID (decl)); 5641} 5642 5643/* Returns a hash value for X (which really is a var_loc_list). */ 5644 5645static hashval_t 5646decl_loc_table_hash (const void *x) 5647{ 5648 return (hashval_t) ((const var_loc_list *) x)->decl_id; 5649} 5650 5651/* Return nonzero if decl_id of var_loc_list X is the same as 5652 UID of decl *Y. */ 5653 5654static int 5655decl_loc_table_eq (const void *x, const void *y) 5656{ 5657 return (((const var_loc_list *) x)->decl_id == DECL_UID ((const tree) y)); 5658} 5659 5660/* Return the var_loc list associated with a given declaration. */ 5661 5662static inline var_loc_list * 5663lookup_decl_loc (tree decl) 5664{ 5665 return htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl)); 5666} 5667 5668/* Equate a DIE to a particular declaration. */ 5669 5670static void 5671equate_decl_number_to_die (tree decl, dw_die_ref decl_die) 5672{ 5673 unsigned int decl_id = DECL_UID (decl); 5674 void **slot; 5675 5676 slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT); 5677 *slot = decl_die; 5678 decl_die->decl_id = decl_id; 5679} 5680 5681/* Add a variable location node to the linked list for DECL. */ 5682 5683static void 5684add_var_loc_to_decl (tree decl, struct var_loc_node *loc) 5685{ 5686 unsigned int decl_id = DECL_UID (decl); 5687 var_loc_list *temp; 5688 void **slot; 5689 5690 slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT); 5691 if (*slot == NULL) 5692 { 5693 temp = ggc_alloc_cleared (sizeof (var_loc_list)); 5694 temp->decl_id = decl_id; 5695 *slot = temp; 5696 } 5697 else 5698 temp = *slot; 5699 5700 if (temp->last) 5701 { 5702 /* If the current location is the same as the end of the list, 5703 we have nothing to do. */ 5704 if (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note), 5705 NOTE_VAR_LOCATION_LOC (loc->var_loc_note))) 5706 { 5707 /* Add LOC to the end of list and update LAST. */ 5708 temp->last->next = loc; 5709 temp->last = loc; 5710 } 5711 } 5712 /* Do not add empty location to the beginning of the list. */ 5713 else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX) 5714 { 5715 temp->first = loc; 5716 temp->last = loc; 5717 } 5718} 5719 5720/* Keep track of the number of spaces used to indent the 5721 output of the debugging routines that print the structure of 5722 the DIE internal representation. */ 5723static int print_indent; 5724 5725/* Indent the line the number of spaces given by print_indent. */ 5726 5727static inline void 5728print_spaces (FILE *outfile) 5729{ 5730 fprintf (outfile, "%*s", print_indent, ""); 5731} 5732 5733/* Print the information associated with a given DIE, and its children. 5734 This routine is a debugging aid only. */ 5735 5736static void 5737print_die (dw_die_ref die, FILE *outfile) 5738{ 5739 dw_attr_ref a; 5740 dw_die_ref c; 5741 unsigned ix; 5742 5743 print_spaces (outfile); 5744 fprintf (outfile, "DIE %4ld: %s\n", 5745 die->die_offset, dwarf_tag_name (die->die_tag)); 5746 print_spaces (outfile); 5747 fprintf (outfile, " abbrev id: %lu", die->die_abbrev); 5748 fprintf (outfile, " offset: %ld\n", die->die_offset); 5749 5750 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 5751 { 5752 print_spaces (outfile); 5753 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr)); 5754 5755 switch (AT_class (a)) 5756 { 5757 case dw_val_class_addr: 5758 fprintf (outfile, "address"); 5759 break; 5760 case dw_val_class_offset: 5761 fprintf (outfile, "offset"); 5762 break; 5763 case dw_val_class_loc: 5764 fprintf (outfile, "location descriptor"); 5765 break; 5766 case dw_val_class_loc_list: 5767 fprintf (outfile, "location list -> label:%s", 5768 AT_loc_list (a)->ll_symbol); 5769 break; 5770 case dw_val_class_range_list: 5771 fprintf (outfile, "range list"); 5772 break; 5773 case dw_val_class_const: 5774 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a)); 5775 break; 5776 case dw_val_class_unsigned_const: 5777 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a)); 5778 break; 5779 case dw_val_class_long_long: 5780 fprintf (outfile, "constant (%lu,%lu)", 5781 a->dw_attr_val.v.val_long_long.hi, 5782 a->dw_attr_val.v.val_long_long.low); 5783 break; 5784 case dw_val_class_vec: 5785 fprintf (outfile, "floating-point or vector constant"); 5786 break; 5787 case dw_val_class_flag: 5788 fprintf (outfile, "%u", AT_flag (a)); 5789 break; 5790 case dw_val_class_die_ref: 5791 if (AT_ref (a) != NULL) 5792 { 5793 if (AT_ref (a)->die_symbol) 5794 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol); 5795 else 5796 fprintf (outfile, "die -> %ld", AT_ref (a)->die_offset); 5797 } 5798 else 5799 fprintf (outfile, "die -> <null>"); 5800 break; 5801 case dw_val_class_lbl_id: 5802 case dw_val_class_lineptr: 5803 case dw_val_class_macptr: 5804 fprintf (outfile, "label: %s", AT_lbl (a)); 5805 break; 5806 case dw_val_class_str: 5807 if (AT_string (a) != NULL) 5808 fprintf (outfile, "\"%s\"", AT_string (a)); 5809 else 5810 fprintf (outfile, "<null>"); 5811 break; 5812 case dw_val_class_file: 5813 fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename, 5814 AT_file (a)->emitted_number); 5815 break; 5816 default: 5817 break; 5818 } 5819 5820 fprintf (outfile, "\n"); 5821 } 5822 5823 if (die->die_child != NULL) 5824 { 5825 print_indent += 4; 5826 FOR_EACH_CHILD (die, c, print_die (c, outfile)); 5827 print_indent -= 4; 5828 } 5829 if (print_indent == 0) 5830 fprintf (outfile, "\n"); 5831} 5832 5833/* Print the contents of the source code line number correspondence table. 5834 This routine is a debugging aid only. */ 5835 5836static void 5837print_dwarf_line_table (FILE *outfile) 5838{ 5839 unsigned i; 5840 dw_line_info_ref line_info; 5841 5842 fprintf (outfile, "\n\nDWARF source line information\n"); 5843 for (i = 1; i < line_info_table_in_use; i++) 5844 { 5845 line_info = &line_info_table[i]; 5846 fprintf (outfile, "%5d: %4ld %6ld\n", i, 5847 line_info->dw_file_num, 5848 line_info->dw_line_num); 5849 } 5850 5851 fprintf (outfile, "\n\n"); 5852} 5853 5854/* Print the information collected for a given DIE. */ 5855 5856void 5857debug_dwarf_die (dw_die_ref die) 5858{ 5859 print_die (die, stderr); 5860} 5861 5862/* Print all DWARF information collected for the compilation unit. 5863 This routine is a debugging aid only. */ 5864 5865void 5866debug_dwarf (void) 5867{ 5868 print_indent = 0; 5869 print_die (comp_unit_die, stderr); 5870 if (! DWARF2_ASM_LINE_DEBUG_INFO) 5871 print_dwarf_line_table (stderr); 5872} 5873 5874/* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU 5875 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL 5876 DIE that marks the start of the DIEs for this include file. */ 5877 5878static dw_die_ref 5879push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die) 5880{ 5881 const char *filename = get_AT_string (bincl_die, DW_AT_name); 5882 dw_die_ref new_unit = gen_compile_unit_die (filename); 5883 5884 new_unit->die_sib = old_unit; 5885 return new_unit; 5886} 5887 5888/* Close an include-file CU and reopen the enclosing one. */ 5889 5890static dw_die_ref 5891pop_compile_unit (dw_die_ref old_unit) 5892{ 5893 dw_die_ref new_unit = old_unit->die_sib; 5894 5895 old_unit->die_sib = NULL; 5896 return new_unit; 5897} 5898 5899#define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx) 5900#define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx) 5901 5902/* Calculate the checksum of a location expression. */ 5903 5904static inline void 5905loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx) 5906{ 5907 CHECKSUM (loc->dw_loc_opc); 5908 CHECKSUM (loc->dw_loc_oprnd1); 5909 CHECKSUM (loc->dw_loc_oprnd2); 5910} 5911 5912/* Calculate the checksum of an attribute. */ 5913 5914static void 5915attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark) 5916{ 5917 dw_loc_descr_ref loc; 5918 rtx r; 5919 5920 CHECKSUM (at->dw_attr); 5921 5922 /* We don't care that this was compiled with a different compiler 5923 snapshot; if the output is the same, that's what matters. */ 5924 if (at->dw_attr == DW_AT_producer) 5925 return; 5926 5927 switch (AT_class (at)) 5928 { 5929 case dw_val_class_const: 5930 CHECKSUM (at->dw_attr_val.v.val_int); 5931 break; 5932 case dw_val_class_unsigned_const: 5933 CHECKSUM (at->dw_attr_val.v.val_unsigned); 5934 break; 5935 case dw_val_class_long_long: 5936 CHECKSUM (at->dw_attr_val.v.val_long_long); 5937 break; 5938 case dw_val_class_vec: 5939 CHECKSUM (at->dw_attr_val.v.val_vec); 5940 break; 5941 case dw_val_class_flag: 5942 CHECKSUM (at->dw_attr_val.v.val_flag); 5943 break; 5944 case dw_val_class_str: 5945 CHECKSUM_STRING (AT_string (at)); 5946 break; 5947 5948 case dw_val_class_addr: 5949 r = AT_addr (at); 5950 gcc_assert (GET_CODE (r) == SYMBOL_REF); 5951 CHECKSUM_STRING (XSTR (r, 0)); 5952 break; 5953 5954 case dw_val_class_offset: 5955 CHECKSUM (at->dw_attr_val.v.val_offset); 5956 break; 5957 5958 case dw_val_class_loc: 5959 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next) 5960 loc_checksum (loc, ctx); 5961 break; 5962 5963 case dw_val_class_die_ref: 5964 die_checksum (AT_ref (at), ctx, mark); 5965 break; 5966 5967 case dw_val_class_fde_ref: 5968 case dw_val_class_lbl_id: 5969 case dw_val_class_lineptr: 5970 case dw_val_class_macptr: 5971 break; 5972 5973 case dw_val_class_file: 5974 CHECKSUM_STRING (AT_file (at)->filename); 5975 break; 5976 5977 default: 5978 break; 5979 } 5980} 5981 5982/* Calculate the checksum of a DIE. */ 5983 5984static void 5985die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark) 5986{ 5987 dw_die_ref c; 5988 dw_attr_ref a; 5989 unsigned ix; 5990 5991 /* To avoid infinite recursion. */ 5992 if (die->die_mark) 5993 { 5994 CHECKSUM (die->die_mark); 5995 return; 5996 } 5997 die->die_mark = ++(*mark); 5998 5999 CHECKSUM (die->die_tag); 6000 6001 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 6002 attr_checksum (a, ctx, mark); 6003 6004 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark)); 6005} 6006 6007#undef CHECKSUM 6008#undef CHECKSUM_STRING 6009 6010/* Do the location expressions look same? */ 6011static inline int 6012same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark) 6013{ 6014 return loc1->dw_loc_opc == loc2->dw_loc_opc 6015 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark) 6016 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark); 6017} 6018 6019/* Do the values look the same? */ 6020static int 6021same_dw_val_p (dw_val_node *v1, dw_val_node *v2, int *mark) 6022{ 6023 dw_loc_descr_ref loc1, loc2; 6024 rtx r1, r2; 6025 6026 if (v1->val_class != v2->val_class) 6027 return 0; 6028 6029 switch (v1->val_class) 6030 { 6031 case dw_val_class_const: 6032 return v1->v.val_int == v2->v.val_int; 6033 case dw_val_class_unsigned_const: 6034 return v1->v.val_unsigned == v2->v.val_unsigned; 6035 case dw_val_class_long_long: 6036 return v1->v.val_long_long.hi == v2->v.val_long_long.hi 6037 && v1->v.val_long_long.low == v2->v.val_long_long.low; 6038 case dw_val_class_vec: 6039 if (v1->v.val_vec.length != v2->v.val_vec.length 6040 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size) 6041 return 0; 6042 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array, 6043 v1->v.val_vec.length * v1->v.val_vec.elt_size)) 6044 return 0; 6045 return 1; 6046 case dw_val_class_flag: 6047 return v1->v.val_flag == v2->v.val_flag; 6048 case dw_val_class_str: 6049 return !strcmp(v1->v.val_str->str, v2->v.val_str->str); 6050 6051 case dw_val_class_addr: 6052 r1 = v1->v.val_addr; 6053 r2 = v2->v.val_addr; 6054 if (GET_CODE (r1) != GET_CODE (r2)) 6055 return 0; 6056 gcc_assert (GET_CODE (r1) == SYMBOL_REF); 6057 return !strcmp (XSTR (r1, 0), XSTR (r2, 0)); 6058 6059 case dw_val_class_offset: 6060 return v1->v.val_offset == v2->v.val_offset; 6061 6062 case dw_val_class_loc: 6063 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc; 6064 loc1 && loc2; 6065 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next) 6066 if (!same_loc_p (loc1, loc2, mark)) 6067 return 0; 6068 return !loc1 && !loc2; 6069 6070 case dw_val_class_die_ref: 6071 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark); 6072 6073 case dw_val_class_fde_ref: 6074 case dw_val_class_lbl_id: 6075 case dw_val_class_lineptr: 6076 case dw_val_class_macptr: 6077 return 1; 6078 6079 case dw_val_class_file: 6080 return v1->v.val_file == v2->v.val_file; 6081 6082 default: 6083 return 1; 6084 } 6085} 6086 6087/* Do the attributes look the same? */ 6088 6089static int 6090same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark) 6091{ 6092 if (at1->dw_attr != at2->dw_attr) 6093 return 0; 6094 6095 /* We don't care that this was compiled with a different compiler 6096 snapshot; if the output is the same, that's what matters. */ 6097 if (at1->dw_attr == DW_AT_producer) 6098 return 1; 6099 6100 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark); 6101} 6102 6103/* Do the dies look the same? */ 6104 6105static int 6106same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark) 6107{ 6108 dw_die_ref c1, c2; 6109 dw_attr_ref a1; 6110 unsigned ix; 6111 6112 /* To avoid infinite recursion. */ 6113 if (die1->die_mark) 6114 return die1->die_mark == die2->die_mark; 6115 die1->die_mark = die2->die_mark = ++(*mark); 6116 6117 if (die1->die_tag != die2->die_tag) 6118 return 0; 6119 6120 if (VEC_length (dw_attr_node, die1->die_attr) 6121 != VEC_length (dw_attr_node, die2->die_attr)) 6122 return 0; 6123 6124 for (ix = 0; VEC_iterate (dw_attr_node, die1->die_attr, ix, a1); ix++) 6125 if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark)) 6126 return 0; 6127 6128 c1 = die1->die_child; 6129 c2 = die2->die_child; 6130 if (! c1) 6131 { 6132 if (c2) 6133 return 0; 6134 } 6135 else 6136 for (;;) 6137 { 6138 if (!same_die_p (c1, c2, mark)) 6139 return 0; 6140 c1 = c1->die_sib; 6141 c2 = c2->die_sib; 6142 if (c1 == die1->die_child) 6143 { 6144 if (c2 == die2->die_child) 6145 break; 6146 else 6147 return 0; 6148 } 6149 } 6150 6151 return 1; 6152} 6153 6154/* Do the dies look the same? Wrapper around same_die_p. */ 6155 6156static int 6157same_die_p_wrap (dw_die_ref die1, dw_die_ref die2) 6158{ 6159 int mark = 0; 6160 int ret = same_die_p (die1, die2, &mark); 6161 6162 unmark_all_dies (die1); 6163 unmark_all_dies (die2); 6164 6165 return ret; 6166} 6167 6168/* The prefix to attach to symbols on DIEs in the current comdat debug 6169 info section. */ 6170static char *comdat_symbol_id; 6171 6172/* The index of the current symbol within the current comdat CU. */ 6173static unsigned int comdat_symbol_number; 6174 6175/* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its 6176 children, and set comdat_symbol_id accordingly. */ 6177 6178static void 6179compute_section_prefix (dw_die_ref unit_die) 6180{ 6181 const char *die_name = get_AT_string (unit_die, DW_AT_name); 6182 const char *base = die_name ? lbasename (die_name) : "anonymous"; 6183 char *name = alloca (strlen (base) + 64); 6184 char *p; 6185 int i, mark; 6186 unsigned char checksum[16]; 6187 struct md5_ctx ctx; 6188 6189 /* Compute the checksum of the DIE, then append part of it as hex digits to 6190 the name filename of the unit. */ 6191 6192 md5_init_ctx (&ctx); 6193 mark = 0; 6194 die_checksum (unit_die, &ctx, &mark); 6195 unmark_all_dies (unit_die); 6196 md5_finish_ctx (&ctx, checksum); 6197 6198 sprintf (name, "%s.", base); 6199 clean_symbol_name (name); 6200 6201 p = name + strlen (name); 6202 for (i = 0; i < 4; i++) 6203 { 6204 sprintf (p, "%.2x", checksum[i]); 6205 p += 2; 6206 } 6207 6208 comdat_symbol_id = unit_die->die_symbol = xstrdup (name); 6209 comdat_symbol_number = 0; 6210} 6211 6212/* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */ 6213 6214static int 6215is_type_die (dw_die_ref die) 6216{ 6217 switch (die->die_tag) 6218 { 6219 case DW_TAG_array_type: 6220 case DW_TAG_class_type: 6221 case DW_TAG_enumeration_type: 6222 case DW_TAG_pointer_type: 6223 case DW_TAG_reference_type: 6224 case DW_TAG_string_type: 6225 case DW_TAG_structure_type: 6226 case DW_TAG_subroutine_type: 6227 case DW_TAG_union_type: 6228 case DW_TAG_ptr_to_member_type: 6229 case DW_TAG_set_type: 6230 case DW_TAG_subrange_type: 6231 case DW_TAG_base_type: 6232 case DW_TAG_const_type: 6233 case DW_TAG_file_type: 6234 case DW_TAG_packed_type: 6235 case DW_TAG_volatile_type: 6236 case DW_TAG_typedef: 6237 return 1; 6238 default: 6239 return 0; 6240 } 6241} 6242 6243/* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU. 6244 Basically, we want to choose the bits that are likely to be shared between 6245 compilations (types) and leave out the bits that are specific to individual 6246 compilations (functions). */ 6247 6248static int 6249is_comdat_die (dw_die_ref c) 6250{ 6251 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as 6252 we do for stabs. The advantage is a greater likelihood of sharing between 6253 objects that don't include headers in the same order (and therefore would 6254 put the base types in a different comdat). jason 8/28/00 */ 6255 6256 if (c->die_tag == DW_TAG_base_type) 6257 return 0; 6258 6259 if (c->die_tag == DW_TAG_pointer_type 6260 || c->die_tag == DW_TAG_reference_type 6261 || c->die_tag == DW_TAG_const_type 6262 || c->die_tag == DW_TAG_volatile_type) 6263 { 6264 dw_die_ref t = get_AT_ref (c, DW_AT_type); 6265 6266 return t ? is_comdat_die (t) : 0; 6267 } 6268 6269 return is_type_die (c); 6270} 6271 6272/* Returns 1 iff C is the sort of DIE that might be referred to from another 6273 compilation unit. */ 6274 6275static int 6276is_symbol_die (dw_die_ref c) 6277{ 6278 return (is_type_die (c) 6279 || (get_AT (c, DW_AT_declaration) 6280 && !get_AT (c, DW_AT_specification)) 6281 || c->die_tag == DW_TAG_namespace); 6282} 6283 6284static char * 6285gen_internal_sym (const char *prefix) 6286{ 6287 char buf[256]; 6288 6289 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++); 6290 return xstrdup (buf); 6291} 6292 6293/* Assign symbols to all worthy DIEs under DIE. */ 6294 6295static void 6296assign_symbol_names (dw_die_ref die) 6297{ 6298 dw_die_ref c; 6299 6300 if (is_symbol_die (die)) 6301 { 6302 if (comdat_symbol_id) 6303 { 6304 char *p = alloca (strlen (comdat_symbol_id) + 64); 6305 6306 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX, 6307 comdat_symbol_id, comdat_symbol_number++); 6308 die->die_symbol = xstrdup (p); 6309 } 6310 else 6311 die->die_symbol = gen_internal_sym ("LDIE"); 6312 } 6313 6314 FOR_EACH_CHILD (die, c, assign_symbol_names (c)); 6315} 6316 6317struct cu_hash_table_entry 6318{ 6319 dw_die_ref cu; 6320 unsigned min_comdat_num, max_comdat_num; 6321 struct cu_hash_table_entry *next; 6322}; 6323 6324/* Routines to manipulate hash table of CUs. */ 6325static hashval_t 6326htab_cu_hash (const void *of) 6327{ 6328 const struct cu_hash_table_entry *entry = of; 6329 6330 return htab_hash_string (entry->cu->die_symbol); 6331} 6332 6333static int 6334htab_cu_eq (const void *of1, const void *of2) 6335{ 6336 const struct cu_hash_table_entry *entry1 = of1; 6337 const struct die_struct *entry2 = of2; 6338 6339 return !strcmp (entry1->cu->die_symbol, entry2->die_symbol); 6340} 6341 6342static void 6343htab_cu_del (void *what) 6344{ 6345 struct cu_hash_table_entry *next, *entry = what; 6346 6347 while (entry) 6348 { 6349 next = entry->next; 6350 free (entry); 6351 entry = next; 6352 } 6353} 6354 6355/* Check whether we have already seen this CU and set up SYM_NUM 6356 accordingly. */ 6357static int 6358check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num) 6359{ 6360 struct cu_hash_table_entry dummy; 6361 struct cu_hash_table_entry **slot, *entry, *last = &dummy; 6362 6363 dummy.max_comdat_num = 0; 6364 6365 slot = (struct cu_hash_table_entry **) 6366 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol), 6367 INSERT); 6368 entry = *slot; 6369 6370 for (; entry; last = entry, entry = entry->next) 6371 { 6372 if (same_die_p_wrap (cu, entry->cu)) 6373 break; 6374 } 6375 6376 if (entry) 6377 { 6378 *sym_num = entry->min_comdat_num; 6379 return 1; 6380 } 6381 6382 entry = XCNEW (struct cu_hash_table_entry); 6383 entry->cu = cu; 6384 entry->min_comdat_num = *sym_num = last->max_comdat_num; 6385 entry->next = *slot; 6386 *slot = entry; 6387 6388 return 0; 6389} 6390 6391/* Record SYM_NUM to record of CU in HTABLE. */ 6392static void 6393record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num) 6394{ 6395 struct cu_hash_table_entry **slot, *entry; 6396 6397 slot = (struct cu_hash_table_entry **) 6398 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol), 6399 NO_INSERT); 6400 entry = *slot; 6401 6402 entry->max_comdat_num = sym_num; 6403} 6404 6405/* Traverse the DIE (which is always comp_unit_die), and set up 6406 additional compilation units for each of the include files we see 6407 bracketed by BINCL/EINCL. */ 6408 6409static void 6410break_out_includes (dw_die_ref die) 6411{ 6412 dw_die_ref c; 6413 dw_die_ref unit = NULL; 6414 limbo_die_node *node, **pnode; 6415 htab_t cu_hash_table; 6416 6417 c = die->die_child; 6418 if (c) do { 6419 dw_die_ref prev = c; 6420 c = c->die_sib; 6421 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL 6422 || (unit && is_comdat_die (c))) 6423 { 6424 dw_die_ref next = c->die_sib; 6425 6426 /* This DIE is for a secondary CU; remove it from the main one. */ 6427 remove_child_with_prev (c, prev); 6428 6429 if (c->die_tag == DW_TAG_GNU_BINCL) 6430 unit = push_new_compile_unit (unit, c); 6431 else if (c->die_tag == DW_TAG_GNU_EINCL) 6432 unit = pop_compile_unit (unit); 6433 else 6434 add_child_die (unit, c); 6435 c = next; 6436 if (c == die->die_child) 6437 break; 6438 } 6439 } while (c != die->die_child); 6440 6441#if 0 6442 /* We can only use this in debugging, since the frontend doesn't check 6443 to make sure that we leave every include file we enter. */ 6444 gcc_assert (!unit); 6445#endif 6446 6447 assign_symbol_names (die); 6448 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del); 6449 for (node = limbo_die_list, pnode = &limbo_die_list; 6450 node; 6451 node = node->next) 6452 { 6453 int is_dupl; 6454 6455 compute_section_prefix (node->die); 6456 is_dupl = check_duplicate_cu (node->die, cu_hash_table, 6457 &comdat_symbol_number); 6458 assign_symbol_names (node->die); 6459 if (is_dupl) 6460 *pnode = node->next; 6461 else 6462 { 6463 pnode = &node->next; 6464 record_comdat_symbol_number (node->die, cu_hash_table, 6465 comdat_symbol_number); 6466 } 6467 } 6468 htab_delete (cu_hash_table); 6469} 6470 6471/* Traverse the DIE and add a sibling attribute if it may have the 6472 effect of speeding up access to siblings. To save some space, 6473 avoid generating sibling attributes for DIE's without children. */ 6474 6475static void 6476add_sibling_attributes (dw_die_ref die) 6477{ 6478 dw_die_ref c; 6479 6480 if (! die->die_child) 6481 return; 6482 6483 if (die->die_parent && die != die->die_parent->die_child) 6484 add_AT_die_ref (die, DW_AT_sibling, die->die_sib); 6485 6486 FOR_EACH_CHILD (die, c, add_sibling_attributes (c)); 6487} 6488 6489/* Output all location lists for the DIE and its children. */ 6490 6491static void 6492output_location_lists (dw_die_ref die) 6493{ 6494 dw_die_ref c; 6495 dw_attr_ref a; 6496 unsigned ix; 6497 6498 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 6499 if (AT_class (a) == dw_val_class_loc_list) 6500 output_loc_list (AT_loc_list (a)); 6501 6502 FOR_EACH_CHILD (die, c, output_location_lists (c)); 6503} 6504 6505/* The format of each DIE (and its attribute value pairs) is encoded in an 6506 abbreviation table. This routine builds the abbreviation table and assigns 6507 a unique abbreviation id for each abbreviation entry. The children of each 6508 die are visited recursively. */ 6509 6510static void 6511build_abbrev_table (dw_die_ref die) 6512{ 6513 unsigned long abbrev_id; 6514 unsigned int n_alloc; 6515 dw_die_ref c; 6516 dw_attr_ref a; 6517 unsigned ix; 6518 6519 /* Scan the DIE references, and mark as external any that refer to 6520 DIEs from other CUs (i.e. those which are not marked). */ 6521 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 6522 if (AT_class (a) == dw_val_class_die_ref 6523 && AT_ref (a)->die_mark == 0) 6524 { 6525 gcc_assert (AT_ref (a)->die_symbol); 6526 6527 set_AT_ref_external (a, 1); 6528 } 6529 6530 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id) 6531 { 6532 dw_die_ref abbrev = abbrev_die_table[abbrev_id]; 6533 dw_attr_ref die_a, abbrev_a; 6534 unsigned ix; 6535 bool ok = true; 6536 6537 if (abbrev->die_tag != die->die_tag) 6538 continue; 6539 if ((abbrev->die_child != NULL) != (die->die_child != NULL)) 6540 continue; 6541 6542 if (VEC_length (dw_attr_node, abbrev->die_attr) 6543 != VEC_length (dw_attr_node, die->die_attr)) 6544 continue; 6545 6546 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, die_a); ix++) 6547 { 6548 abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix); 6549 if ((abbrev_a->dw_attr != die_a->dw_attr) 6550 || (value_format (abbrev_a) != value_format (die_a))) 6551 { 6552 ok = false; 6553 break; 6554 } 6555 } 6556 if (ok) 6557 break; 6558 } 6559 6560 if (abbrev_id >= abbrev_die_table_in_use) 6561 { 6562 if (abbrev_die_table_in_use >= abbrev_die_table_allocated) 6563 { 6564 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT; 6565 abbrev_die_table = ggc_realloc (abbrev_die_table, 6566 sizeof (dw_die_ref) * n_alloc); 6567 6568 memset (&abbrev_die_table[abbrev_die_table_allocated], 0, 6569 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref)); 6570 abbrev_die_table_allocated = n_alloc; 6571 } 6572 6573 ++abbrev_die_table_in_use; 6574 abbrev_die_table[abbrev_id] = die; 6575 } 6576 6577 die->die_abbrev = abbrev_id; 6578 FOR_EACH_CHILD (die, c, build_abbrev_table (c)); 6579} 6580 6581/* Return the power-of-two number of bytes necessary to represent VALUE. */ 6582 6583static int 6584constant_size (long unsigned int value) 6585{ 6586 int log; 6587 6588 if (value == 0) 6589 log = 0; 6590 else 6591 log = floor_log2 (value); 6592 6593 log = log / 8; 6594 log = 1 << (floor_log2 (log) + 1); 6595 6596 return log; 6597} 6598 6599/* Return the size of a DIE as it is represented in the 6600 .debug_info section. */ 6601 6602static unsigned long 6603size_of_die (dw_die_ref die) 6604{ 6605 unsigned long size = 0; 6606 dw_attr_ref a; 6607 unsigned ix; 6608 6609 size += size_of_uleb128 (die->die_abbrev); 6610 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 6611 { 6612 switch (AT_class (a)) 6613 { 6614 case dw_val_class_addr: 6615 size += DWARF2_ADDR_SIZE; 6616 break; 6617 case dw_val_class_offset: 6618 size += DWARF_OFFSET_SIZE; 6619 break; 6620 case dw_val_class_loc: 6621 { 6622 unsigned long lsize = size_of_locs (AT_loc (a)); 6623 6624 /* Block length. */ 6625 size += constant_size (lsize); 6626 size += lsize; 6627 } 6628 break; 6629 case dw_val_class_loc_list: 6630 size += DWARF_OFFSET_SIZE; 6631 break; 6632 case dw_val_class_range_list: 6633 size += DWARF_OFFSET_SIZE; 6634 break; 6635 case dw_val_class_const: 6636 size += size_of_sleb128 (AT_int (a)); 6637 break; 6638 case dw_val_class_unsigned_const: 6639 size += constant_size (AT_unsigned (a)); 6640 break; 6641 case dw_val_class_long_long: 6642 size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */ 6643 break; 6644 case dw_val_class_vec: 6645 size += 1 + (a->dw_attr_val.v.val_vec.length 6646 * a->dw_attr_val.v.val_vec.elt_size); /* block */ 6647 break; 6648 case dw_val_class_flag: 6649 size += 1; 6650 break; 6651 case dw_val_class_die_ref: 6652 if (AT_ref_external (a)) 6653 size += DWARF2_ADDR_SIZE; 6654 else 6655 size += DWARF_OFFSET_SIZE; 6656 break; 6657 case dw_val_class_fde_ref: 6658 size += DWARF_OFFSET_SIZE; 6659 break; 6660 case dw_val_class_lbl_id: 6661 size += DWARF2_ADDR_SIZE; 6662 break; 6663 case dw_val_class_lineptr: 6664 case dw_val_class_macptr: 6665 size += DWARF_OFFSET_SIZE; 6666 break; 6667 case dw_val_class_str: 6668 if (AT_string_form (a) == DW_FORM_strp) 6669 size += DWARF_OFFSET_SIZE; 6670 else 6671 size += strlen (a->dw_attr_val.v.val_str->str) + 1; 6672 break; 6673 case dw_val_class_file: 6674 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)); 6675 break; 6676 default: 6677 gcc_unreachable (); 6678 } 6679 } 6680 6681 return size; 6682} 6683 6684/* Size the debugging information associated with a given DIE. Visits the 6685 DIE's children recursively. Updates the global variable next_die_offset, on 6686 each time through. Uses the current value of next_die_offset to update the 6687 die_offset field in each DIE. */ 6688 6689static void 6690calc_die_sizes (dw_die_ref die) 6691{ 6692 dw_die_ref c; 6693 6694 die->die_offset = next_die_offset; 6695 next_die_offset += size_of_die (die); 6696 6697 FOR_EACH_CHILD (die, c, calc_die_sizes (c)); 6698 6699 if (die->die_child != NULL) 6700 /* Count the null byte used to terminate sibling lists. */ 6701 next_die_offset += 1; 6702} 6703 6704/* Set the marks for a die and its children. We do this so 6705 that we know whether or not a reference needs to use FORM_ref_addr; only 6706 DIEs in the same CU will be marked. We used to clear out the offset 6707 and use that as the flag, but ran into ordering problems. */ 6708 6709static void 6710mark_dies (dw_die_ref die) 6711{ 6712 dw_die_ref c; 6713 6714 gcc_assert (!die->die_mark); 6715 6716 die->die_mark = 1; 6717 FOR_EACH_CHILD (die, c, mark_dies (c)); 6718} 6719 6720/* Clear the marks for a die and its children. */ 6721 6722static void 6723unmark_dies (dw_die_ref die) 6724{ 6725 dw_die_ref c; 6726 6727 gcc_assert (die->die_mark); 6728 6729 die->die_mark = 0; 6730 FOR_EACH_CHILD (die, c, unmark_dies (c)); 6731} 6732 6733/* Clear the marks for a die, its children and referred dies. */ 6734 6735static void 6736unmark_all_dies (dw_die_ref die) 6737{ 6738 dw_die_ref c; 6739 dw_attr_ref a; 6740 unsigned ix; 6741 6742 if (!die->die_mark) 6743 return; 6744 die->die_mark = 0; 6745 6746 FOR_EACH_CHILD (die, c, unmark_all_dies (c)); 6747 6748 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 6749 if (AT_class (a) == dw_val_class_die_ref) 6750 unmark_all_dies (AT_ref (a)); 6751} 6752 6753/* Return the size of the .debug_pubnames table generated for the 6754 compilation unit. */ 6755 6756static unsigned long 6757size_of_pubnames (void) 6758{ 6759 unsigned long size; 6760 unsigned i; 6761 6762 size = DWARF_PUBNAMES_HEADER_SIZE; 6763 for (i = 0; i < pubname_table_in_use; i++) 6764 { 6765 pubname_ref p = &pubname_table[i]; 6766 size += DWARF_OFFSET_SIZE + strlen (p->name) + 1; 6767 } 6768 6769 size += DWARF_OFFSET_SIZE; 6770 return size; 6771} 6772 6773/* Return the size of the information in the .debug_aranges section. */ 6774 6775static unsigned long 6776size_of_aranges (void) 6777{ 6778 unsigned long size; 6779 6780 size = DWARF_ARANGES_HEADER_SIZE; 6781 6782 /* Count the address/length pair for this compilation unit. */ 6783 size += 2 * DWARF2_ADDR_SIZE; 6784 size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use; 6785 6786 /* Count the two zero words used to terminated the address range table. */ 6787 size += 2 * DWARF2_ADDR_SIZE; 6788 return size; 6789} 6790 6791/* Select the encoding of an attribute value. */ 6792 6793static enum dwarf_form 6794value_format (dw_attr_ref a) 6795{ 6796 switch (a->dw_attr_val.val_class) 6797 { 6798 case dw_val_class_addr: 6799 return DW_FORM_addr; 6800 case dw_val_class_range_list: 6801 case dw_val_class_offset: 6802 case dw_val_class_loc_list: 6803 switch (DWARF_OFFSET_SIZE) 6804 { 6805 case 4: 6806 return DW_FORM_data4; 6807 case 8: 6808 return DW_FORM_data8; 6809 default: 6810 gcc_unreachable (); 6811 } 6812 case dw_val_class_loc: 6813 switch (constant_size (size_of_locs (AT_loc (a)))) 6814 { 6815 case 1: 6816 return DW_FORM_block1; 6817 case 2: 6818 return DW_FORM_block2; 6819 default: 6820 gcc_unreachable (); 6821 } 6822 case dw_val_class_const: 6823 return DW_FORM_sdata; 6824 case dw_val_class_unsigned_const: 6825 switch (constant_size (AT_unsigned (a))) 6826 { 6827 case 1: 6828 return DW_FORM_data1; 6829 case 2: 6830 return DW_FORM_data2; 6831 case 4: 6832 return DW_FORM_data4; 6833 case 8: 6834 return DW_FORM_data8; 6835 default: 6836 gcc_unreachable (); 6837 } 6838 case dw_val_class_long_long: 6839 return DW_FORM_block1; 6840 case dw_val_class_vec: 6841 return DW_FORM_block1; 6842 case dw_val_class_flag: 6843 return DW_FORM_flag; 6844 case dw_val_class_die_ref: 6845 if (AT_ref_external (a)) 6846 return DW_FORM_ref_addr; 6847 else 6848 return DW_FORM_ref; 6849 case dw_val_class_fde_ref: 6850 return DW_FORM_data; 6851 case dw_val_class_lbl_id: 6852 return DW_FORM_addr; 6853 case dw_val_class_lineptr: 6854 case dw_val_class_macptr: 6855 return DW_FORM_data; 6856 case dw_val_class_str: 6857 return AT_string_form (a); 6858 case dw_val_class_file: 6859 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file))) 6860 { 6861 case 1: 6862 return DW_FORM_data1; 6863 case 2: 6864 return DW_FORM_data2; 6865 case 4: 6866 return DW_FORM_data4; 6867 default: 6868 gcc_unreachable (); 6869 } 6870 6871 default: 6872 gcc_unreachable (); 6873 } 6874} 6875 6876/* Output the encoding of an attribute value. */ 6877 6878static void 6879output_value_format (dw_attr_ref a) 6880{ 6881 enum dwarf_form form = value_format (a); 6882 6883 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form)); 6884} 6885 6886/* Output the .debug_abbrev section which defines the DIE abbreviation 6887 table. */ 6888 6889static void 6890output_abbrev_section (void) 6891{ 6892 unsigned long abbrev_id; 6893 6894 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id) 6895 { 6896 dw_die_ref abbrev = abbrev_die_table[abbrev_id]; 6897 unsigned ix; 6898 dw_attr_ref a_attr; 6899 6900 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)"); 6901 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)", 6902 dwarf_tag_name (abbrev->die_tag)); 6903 6904 if (abbrev->die_child != NULL) 6905 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes"); 6906 else 6907 dw2_asm_output_data (1, DW_children_no, "DW_children_no"); 6908 6909 for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr); 6910 ix++) 6911 { 6912 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)", 6913 dwarf_attr_name (a_attr->dw_attr)); 6914 output_value_format (a_attr); 6915 } 6916 6917 dw2_asm_output_data (1, 0, NULL); 6918 dw2_asm_output_data (1, 0, NULL); 6919 } 6920 6921 /* Terminate the table. */ 6922 dw2_asm_output_data (1, 0, NULL); 6923} 6924 6925/* Output a symbol we can use to refer to this DIE from another CU. */ 6926 6927static inline void 6928output_die_symbol (dw_die_ref die) 6929{ 6930 char *sym = die->die_symbol; 6931 6932 if (sym == 0) 6933 return; 6934 6935 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0) 6936 /* We make these global, not weak; if the target doesn't support 6937 .linkonce, it doesn't support combining the sections, so debugging 6938 will break. */ 6939 targetm.asm_out.globalize_label (asm_out_file, sym); 6940 6941 ASM_OUTPUT_LABEL (asm_out_file, sym); 6942} 6943 6944/* Return a new location list, given the begin and end range, and the 6945 expression. gensym tells us whether to generate a new internal symbol for 6946 this location list node, which is done for the head of the list only. */ 6947 6948static inline dw_loc_list_ref 6949new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end, 6950 const char *section, unsigned int gensym) 6951{ 6952 dw_loc_list_ref retlist = ggc_alloc_cleared (sizeof (dw_loc_list_node)); 6953 6954 retlist->begin = begin; 6955 retlist->end = end; 6956 retlist->expr = expr; 6957 retlist->section = section; 6958 if (gensym) 6959 retlist->ll_symbol = gen_internal_sym ("LLST"); 6960 6961 return retlist; 6962} 6963 6964/* Add a location description expression to a location list. */ 6965 6966static inline void 6967add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr, 6968 const char *begin, const char *end, 6969 const char *section) 6970{ 6971 dw_loc_list_ref *d; 6972 6973 /* Find the end of the chain. */ 6974 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next) 6975 ; 6976 6977 /* Add a new location list node to the list. */ 6978 *d = new_loc_list (descr, begin, end, section, 0); 6979} 6980 6981static void 6982dwarf2out_switch_text_section (void) 6983{ 6984 dw_fde_ref fde; 6985 6986 gcc_assert (cfun); 6987 6988 fde = &fde_table[fde_table_in_use - 1]; 6989 fde->dw_fde_switched_sections = true; 6990 fde->dw_fde_hot_section_label = cfun->hot_section_label; 6991 fde->dw_fde_hot_section_end_label = cfun->hot_section_end_label; 6992 fde->dw_fde_unlikely_section_label = cfun->cold_section_label; 6993 fde->dw_fde_unlikely_section_end_label = cfun->cold_section_end_label; 6994 have_multiple_function_sections = true; 6995 6996 /* Reset the current label on switching text sections, so that we 6997 don't attempt to advance_loc4 between labels in different sections. */ 6998 fde->dw_fde_current_label = NULL; 6999} 7000 7001/* Output the location list given to us. */ 7002 7003static void 7004output_loc_list (dw_loc_list_ref list_head) 7005{ 7006 dw_loc_list_ref curr = list_head; 7007 7008 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol); 7009 7010 /* Walk the location list, and output each range + expression. */ 7011 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next) 7012 { 7013 unsigned long size; 7014 if (!have_multiple_function_sections) 7015 { 7016 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section, 7017 "Location list begin address (%s)", 7018 list_head->ll_symbol); 7019 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section, 7020 "Location list end address (%s)", 7021 list_head->ll_symbol); 7022 } 7023 else 7024 { 7025 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin, 7026 "Location list begin address (%s)", 7027 list_head->ll_symbol); 7028 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end, 7029 "Location list end address (%s)", 7030 list_head->ll_symbol); 7031 } 7032 size = size_of_locs (curr->expr); 7033 7034 /* Output the block length for this list of location operations. */ 7035 gcc_assert (size <= 0xffff); 7036 dw2_asm_output_data (2, size, "%s", "Location expression size"); 7037 7038 output_loc_sequence (curr->expr); 7039 } 7040 7041 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, 7042 "Location list terminator begin (%s)", 7043 list_head->ll_symbol); 7044 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, 7045 "Location list terminator end (%s)", 7046 list_head->ll_symbol); 7047} 7048 7049/* Output the DIE and its attributes. Called recursively to generate 7050 the definitions of each child DIE. */ 7051 7052static void 7053output_die (dw_die_ref die) 7054{ 7055 dw_attr_ref a; 7056 dw_die_ref c; 7057 unsigned long size; 7058 unsigned ix; 7059 7060 /* If someone in another CU might refer to us, set up a symbol for 7061 them to point to. */ 7062 if (die->die_symbol) 7063 output_die_symbol (die); 7064 7065 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)", 7066 (unsigned long)die->die_offset, 7067 dwarf_tag_name (die->die_tag)); 7068 7069 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 7070 { 7071 const char *name = dwarf_attr_name (a->dw_attr); 7072 7073 switch (AT_class (a)) 7074 { 7075 case dw_val_class_addr: 7076 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name); 7077 break; 7078 7079 case dw_val_class_offset: 7080 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset, 7081 "%s", name); 7082 break; 7083 7084 case dw_val_class_range_list: 7085 { 7086 char *p = strchr (ranges_section_label, '\0'); 7087 7088 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX, 7089 a->dw_attr_val.v.val_offset); 7090 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label, 7091 debug_ranges_section, "%s", name); 7092 *p = '\0'; 7093 } 7094 break; 7095 7096 case dw_val_class_loc: 7097 size = size_of_locs (AT_loc (a)); 7098 7099 /* Output the block length for this list of location operations. */ 7100 dw2_asm_output_data (constant_size (size), size, "%s", name); 7101 7102 output_loc_sequence (AT_loc (a)); 7103 break; 7104 7105 case dw_val_class_const: 7106 /* ??? It would be slightly more efficient to use a scheme like is 7107 used for unsigned constants below, but gdb 4.x does not sign 7108 extend. Gdb 5.x does sign extend. */ 7109 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name); 7110 break; 7111 7112 case dw_val_class_unsigned_const: 7113 dw2_asm_output_data (constant_size (AT_unsigned (a)), 7114 AT_unsigned (a), "%s", name); 7115 break; 7116 7117 case dw_val_class_long_long: 7118 { 7119 unsigned HOST_WIDE_INT first, second; 7120 7121 dw2_asm_output_data (1, 7122 2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR, 7123 "%s", name); 7124 7125 if (WORDS_BIG_ENDIAN) 7126 { 7127 first = a->dw_attr_val.v.val_long_long.hi; 7128 second = a->dw_attr_val.v.val_long_long.low; 7129 } 7130 else 7131 { 7132 first = a->dw_attr_val.v.val_long_long.low; 7133 second = a->dw_attr_val.v.val_long_long.hi; 7134 } 7135 7136 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR, 7137 first, "long long constant"); 7138 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR, 7139 second, NULL); 7140 } 7141 break; 7142 7143 case dw_val_class_vec: 7144 { 7145 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size; 7146 unsigned int len = a->dw_attr_val.v.val_vec.length; 7147 unsigned int i; 7148 unsigned char *p; 7149 7150 dw2_asm_output_data (1, len * elt_size, "%s", name); 7151 if (elt_size > sizeof (HOST_WIDE_INT)) 7152 { 7153 elt_size /= 2; 7154 len *= 2; 7155 } 7156 for (i = 0, p = a->dw_attr_val.v.val_vec.array; 7157 i < len; 7158 i++, p += elt_size) 7159 dw2_asm_output_data (elt_size, extract_int (p, elt_size), 7160 "fp or vector constant word %u", i); 7161 break; 7162 } 7163 7164 case dw_val_class_flag: 7165 dw2_asm_output_data (1, AT_flag (a), "%s", name); 7166 break; 7167 7168 case dw_val_class_loc_list: 7169 { 7170 char *sym = AT_loc_list (a)->ll_symbol; 7171 7172 gcc_assert (sym); 7173 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section, 7174 "%s", name); 7175 } 7176 break; 7177 7178 case dw_val_class_die_ref: 7179 if (AT_ref_external (a)) 7180 { 7181 char *sym = AT_ref (a)->die_symbol; 7182 7183 gcc_assert (sym); 7184 dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, debug_info_section, 7185 "%s", name); 7186 } 7187 else 7188 { 7189 gcc_assert (AT_ref (a)->die_offset); 7190 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset, 7191 "%s", name); 7192 } 7193 break; 7194 7195 case dw_val_class_fde_ref: 7196 { 7197 char l1[20]; 7198 7199 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL, 7200 a->dw_attr_val.v.val_fde_index * 2); 7201 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section, 7202 "%s", name); 7203 } 7204 break; 7205 7206 case dw_val_class_lbl_id: 7207 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name); 7208 break; 7209 7210 case dw_val_class_lineptr: 7211 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a), 7212 debug_line_section, "%s", name); 7213 break; 7214 7215 case dw_val_class_macptr: 7216 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a), 7217 debug_macinfo_section, "%s", name); 7218 break; 7219 7220 case dw_val_class_str: 7221 if (AT_string_form (a) == DW_FORM_strp) 7222 dw2_asm_output_offset (DWARF_OFFSET_SIZE, 7223 a->dw_attr_val.v.val_str->label, 7224 debug_str_section, 7225 "%s: \"%s\"", name, AT_string (a)); 7226 else 7227 dw2_asm_output_nstring (AT_string (a), -1, "%s", name); 7228 break; 7229 7230 case dw_val_class_file: 7231 { 7232 int f = maybe_emit_file (a->dw_attr_val.v.val_file); 7233 7234 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name, 7235 a->dw_attr_val.v.val_file->filename); 7236 break; 7237 } 7238 7239 default: 7240 gcc_unreachable (); 7241 } 7242 } 7243 7244 FOR_EACH_CHILD (die, c, output_die (c)); 7245 7246 /* Add null byte to terminate sibling list. */ 7247 if (die->die_child != NULL) 7248 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx", 7249 (unsigned long) die->die_offset); 7250} 7251 7252/* Output the compilation unit that appears at the beginning of the 7253 .debug_info section, and precedes the DIE descriptions. */ 7254 7255static void 7256output_compilation_unit_header (void) 7257{ 7258 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 7259 dw2_asm_output_data (4, 0xffffffff, 7260 "Initial length escape value indicating 64-bit DWARF extension"); 7261 dw2_asm_output_data (DWARF_OFFSET_SIZE, 7262 next_die_offset - DWARF_INITIAL_LENGTH_SIZE, 7263 "Length of Compilation Unit Info"); 7264 dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number"); 7265 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label, 7266 debug_abbrev_section, 7267 "Offset Into Abbrev. Section"); 7268 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)"); 7269} 7270 7271/* Output the compilation unit DIE and its children. */ 7272 7273static void 7274output_comp_unit (dw_die_ref die, int output_if_empty) 7275{ 7276 const char *secname; 7277 char *oldsym, *tmp; 7278 7279 /* Unless we are outputting main CU, we may throw away empty ones. */ 7280 if (!output_if_empty && die->die_child == NULL) 7281 return; 7282 7283 /* Even if there are no children of this DIE, we must output the information 7284 about the compilation unit. Otherwise, on an empty translation unit, we 7285 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm' 7286 will then complain when examining the file. First mark all the DIEs in 7287 this CU so we know which get local refs. */ 7288 mark_dies (die); 7289 7290 build_abbrev_table (die); 7291 7292 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */ 7293 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE; 7294 calc_die_sizes (die); 7295 7296 oldsym = die->die_symbol; 7297 if (oldsym) 7298 { 7299 tmp = alloca (strlen (oldsym) + 24); 7300 7301 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym); 7302 secname = tmp; 7303 die->die_symbol = NULL; 7304 switch_to_section (get_section (secname, SECTION_DEBUG, NULL)); 7305 } 7306 else 7307 switch_to_section (debug_info_section); 7308 7309 /* Output debugging information. */ 7310 output_compilation_unit_header (); 7311 output_die (die); 7312 7313 /* Leave the marks on the main CU, so we can check them in 7314 output_pubnames. */ 7315 if (oldsym) 7316 { 7317 unmark_dies (die); 7318 die->die_symbol = oldsym; 7319 } 7320} 7321 7322/* Return the DWARF2/3 pubname associated with a decl. */ 7323 7324static const char * 7325dwarf2_name (tree decl, int scope) 7326{ 7327 return lang_hooks.dwarf_name (decl, scope ? 1 : 0); 7328} 7329 7330/* Add a new entry to .debug_pubnames if appropriate. */ 7331 7332static void 7333add_pubname (tree decl, dw_die_ref die) 7334{ 7335 pubname_ref p; 7336 7337 if (! TREE_PUBLIC (decl)) 7338 return; 7339 7340 if (pubname_table_in_use == pubname_table_allocated) 7341 { 7342 pubname_table_allocated += PUBNAME_TABLE_INCREMENT; 7343 pubname_table 7344 = ggc_realloc (pubname_table, 7345 (pubname_table_allocated * sizeof (pubname_entry))); 7346 memset (pubname_table + pubname_table_in_use, 0, 7347 PUBNAME_TABLE_INCREMENT * sizeof (pubname_entry)); 7348 } 7349 7350 p = &pubname_table[pubname_table_in_use++]; 7351 p->die = die; 7352 p->name = xstrdup (dwarf2_name (decl, 1)); 7353} 7354 7355/* Output the public names table used to speed up access to externally 7356 visible names. For now, only generate entries for externally 7357 visible procedures. */ 7358 7359static void 7360output_pubnames (void) 7361{ 7362 unsigned i; 7363 unsigned long pubnames_length = size_of_pubnames (); 7364 7365 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 7366 dw2_asm_output_data (4, 0xffffffff, 7367 "Initial length escape value indicating 64-bit DWARF extension"); 7368 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length, 7369 "Length of Public Names Info"); 7370 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version"); 7371 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label, 7372 debug_info_section, 7373 "Offset of Compilation Unit Info"); 7374 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset, 7375 "Compilation Unit Length"); 7376 7377 for (i = 0; i < pubname_table_in_use; i++) 7378 { 7379 pubname_ref pub = &pubname_table[i]; 7380 7381 /* We shouldn't see pubnames for DIEs outside of the main CU. */ 7382 gcc_assert (pub->die->die_mark); 7383 7384 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset, 7385 "DIE offset"); 7386 7387 dw2_asm_output_nstring (pub->name, -1, "external name"); 7388 } 7389 7390 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL); 7391} 7392 7393/* Add a new entry to .debug_aranges if appropriate. */ 7394 7395static void 7396add_arange (tree decl, dw_die_ref die) 7397{ 7398 if (! DECL_SECTION_NAME (decl)) 7399 return; 7400 7401 if (arange_table_in_use == arange_table_allocated) 7402 { 7403 arange_table_allocated += ARANGE_TABLE_INCREMENT; 7404 arange_table = ggc_realloc (arange_table, 7405 (arange_table_allocated 7406 * sizeof (dw_die_ref))); 7407 memset (arange_table + arange_table_in_use, 0, 7408 ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref)); 7409 } 7410 7411 arange_table[arange_table_in_use++] = die; 7412} 7413 7414/* Output the information that goes into the .debug_aranges table. 7415 Namely, define the beginning and ending address range of the 7416 text section generated for this compilation unit. */ 7417 7418static void 7419output_aranges (void) 7420{ 7421 unsigned i; 7422 unsigned long aranges_length = size_of_aranges (); 7423 7424 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 7425 dw2_asm_output_data (4, 0xffffffff, 7426 "Initial length escape value indicating 64-bit DWARF extension"); 7427 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length, 7428 "Length of Address Ranges Info"); 7429 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version"); 7430 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label, 7431 debug_info_section, 7432 "Offset of Compilation Unit Info"); 7433 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address"); 7434 dw2_asm_output_data (1, 0, "Size of Segment Descriptor"); 7435 7436 /* We need to align to twice the pointer size here. */ 7437 if (DWARF_ARANGES_PAD_SIZE) 7438 { 7439 /* Pad using a 2 byte words so that padding is correct for any 7440 pointer size. */ 7441 dw2_asm_output_data (2, 0, "Pad to %d byte boundary", 7442 2 * DWARF2_ADDR_SIZE); 7443 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2) 7444 dw2_asm_output_data (2, 0, NULL); 7445 } 7446 7447 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address"); 7448 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label, 7449 text_section_label, "Length"); 7450 if (flag_reorder_blocks_and_partition) 7451 { 7452 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label, 7453 "Address"); 7454 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label, 7455 cold_text_section_label, "Length"); 7456 } 7457 7458 for (i = 0; i < arange_table_in_use; i++) 7459 { 7460 dw_die_ref die = arange_table[i]; 7461 7462 /* We shouldn't see aranges for DIEs outside of the main CU. */ 7463 gcc_assert (die->die_mark); 7464 7465 if (die->die_tag == DW_TAG_subprogram) 7466 { 7467 dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die), 7468 "Address"); 7469 dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die), 7470 get_AT_low_pc (die), "Length"); 7471 } 7472 else 7473 { 7474 /* A static variable; extract the symbol from DW_AT_location. 7475 Note that this code isn't currently hit, as we only emit 7476 aranges for functions (jason 9/23/99). */ 7477 dw_attr_ref a = get_AT (die, DW_AT_location); 7478 dw_loc_descr_ref loc; 7479 7480 gcc_assert (a && AT_class (a) == dw_val_class_loc); 7481 7482 loc = AT_loc (a); 7483 gcc_assert (loc->dw_loc_opc == DW_OP_addr); 7484 7485 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, 7486 loc->dw_loc_oprnd1.v.val_addr, "Address"); 7487 dw2_asm_output_data (DWARF2_ADDR_SIZE, 7488 get_AT_unsigned (die, DW_AT_byte_size), 7489 "Length"); 7490 } 7491 } 7492 7493 /* Output the terminator words. */ 7494 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 7495 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 7496} 7497 7498/* Add a new entry to .debug_ranges. Return the offset at which it 7499 was placed. */ 7500 7501static unsigned int 7502add_ranges (tree block) 7503{ 7504 unsigned int in_use = ranges_table_in_use; 7505 7506 if (in_use == ranges_table_allocated) 7507 { 7508 ranges_table_allocated += RANGES_TABLE_INCREMENT; 7509 ranges_table 7510 = ggc_realloc (ranges_table, (ranges_table_allocated 7511 * sizeof (struct dw_ranges_struct))); 7512 memset (ranges_table + ranges_table_in_use, 0, 7513 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct)); 7514 } 7515 7516 ranges_table[in_use].block_num = (block ? BLOCK_NUMBER (block) : 0); 7517 ranges_table_in_use = in_use + 1; 7518 7519 return in_use * 2 * DWARF2_ADDR_SIZE; 7520} 7521 7522static void 7523output_ranges (void) 7524{ 7525 unsigned i; 7526 static const char *const start_fmt = "Offset 0x%x"; 7527 const char *fmt = start_fmt; 7528 7529 for (i = 0; i < ranges_table_in_use; i++) 7530 { 7531 int block_num = ranges_table[i].block_num; 7532 7533 if (block_num) 7534 { 7535 char blabel[MAX_ARTIFICIAL_LABEL_BYTES]; 7536 char elabel[MAX_ARTIFICIAL_LABEL_BYTES]; 7537 7538 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num); 7539 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num); 7540 7541 /* If all code is in the text section, then the compilation 7542 unit base address defaults to DW_AT_low_pc, which is the 7543 base of the text section. */ 7544 if (!have_multiple_function_sections) 7545 { 7546 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel, 7547 text_section_label, 7548 fmt, i * 2 * DWARF2_ADDR_SIZE); 7549 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel, 7550 text_section_label, NULL); 7551 } 7552 7553 /* Otherwise, we add a DW_AT_entry_pc attribute to force the 7554 compilation unit base address to zero, which allows us to 7555 use absolute addresses, and not worry about whether the 7556 target supports cross-section arithmetic. */ 7557 else 7558 { 7559 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel, 7560 fmt, i * 2 * DWARF2_ADDR_SIZE); 7561 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL); 7562 } 7563 7564 fmt = NULL; 7565 } 7566 else 7567 { 7568 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 7569 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); 7570 fmt = start_fmt; 7571 } 7572 } 7573} 7574 7575/* Data structure containing information about input files. */ 7576struct file_info 7577{ 7578 const char *path; /* Complete file name. */ 7579 const char *fname; /* File name part. */ 7580 int length; /* Length of entire string. */ 7581 struct dwarf_file_data * file_idx; /* Index in input file table. */ 7582 int dir_idx; /* Index in directory table. */ 7583}; 7584 7585/* Data structure containing information about directories with source 7586 files. */ 7587struct dir_info 7588{ 7589 const char *path; /* Path including directory name. */ 7590 int length; /* Path length. */ 7591 int prefix; /* Index of directory entry which is a prefix. */ 7592 int count; /* Number of files in this directory. */ 7593 int dir_idx; /* Index of directory used as base. */ 7594}; 7595 7596/* Callback function for file_info comparison. We sort by looking at 7597 the directories in the path. */ 7598 7599static int 7600file_info_cmp (const void *p1, const void *p2) 7601{ 7602 const struct file_info *s1 = p1; 7603 const struct file_info *s2 = p2; 7604 unsigned char *cp1; 7605 unsigned char *cp2; 7606 7607 /* Take care of file names without directories. We need to make sure that 7608 we return consistent values to qsort since some will get confused if 7609 we return the same value when identical operands are passed in opposite 7610 orders. So if neither has a directory, return 0 and otherwise return 7611 1 or -1 depending on which one has the directory. */ 7612 if ((s1->path == s1->fname || s2->path == s2->fname)) 7613 return (s2->path == s2->fname) - (s1->path == s1->fname); 7614 7615 cp1 = (unsigned char *) s1->path; 7616 cp2 = (unsigned char *) s2->path; 7617 7618 while (1) 7619 { 7620 ++cp1; 7621 ++cp2; 7622 /* Reached the end of the first path? If so, handle like above. */ 7623 if ((cp1 == (unsigned char *) s1->fname) 7624 || (cp2 == (unsigned char *) s2->fname)) 7625 return ((cp2 == (unsigned char *) s2->fname) 7626 - (cp1 == (unsigned char *) s1->fname)); 7627 7628 /* Character of current path component the same? */ 7629 else if (*cp1 != *cp2) 7630 return *cp1 - *cp2; 7631 } 7632} 7633 7634struct file_name_acquire_data 7635{ 7636 struct file_info *files; 7637 int used_files; 7638 int max_files; 7639}; 7640 7641/* Traversal function for the hash table. */ 7642 7643static int 7644file_name_acquire (void ** slot, void *data) 7645{ 7646 struct file_name_acquire_data *fnad = data; 7647 struct dwarf_file_data *d = *slot; 7648 struct file_info *fi; 7649 const char *f; 7650 7651 gcc_assert (fnad->max_files >= d->emitted_number); 7652 7653 if (! d->emitted_number) 7654 return 1; 7655 7656 gcc_assert (fnad->max_files != fnad->used_files); 7657 7658 fi = fnad->files + fnad->used_files++; 7659 7660 /* Skip all leading "./". */ 7661 f = d->filename; 7662 while (f[0] == '.' && f[1] == '/') 7663 f += 2; 7664 7665 /* Create a new array entry. */ 7666 fi->path = f; 7667 fi->length = strlen (f); 7668 fi->file_idx = d; 7669 7670 /* Search for the file name part. */ 7671 f = strrchr (f, '/'); 7672 fi->fname = f == NULL ? fi->path : f + 1; 7673 return 1; 7674} 7675 7676/* Output the directory table and the file name table. We try to minimize 7677 the total amount of memory needed. A heuristic is used to avoid large 7678 slowdowns with many input files. */ 7679 7680static void 7681output_file_names (void) 7682{ 7683 struct file_name_acquire_data fnad; 7684 int numfiles; 7685 struct file_info *files; 7686 struct dir_info *dirs; 7687 int *saved; 7688 int *savehere; 7689 int *backmap; 7690 int ndirs; 7691 int idx_offset; 7692 int i; 7693 int idx; 7694 7695 if (!last_emitted_file) 7696 { 7697 dw2_asm_output_data (1, 0, "End directory table"); 7698 dw2_asm_output_data (1, 0, "End file name table"); 7699 return; 7700 } 7701 7702 numfiles = last_emitted_file->emitted_number; 7703 7704 /* Allocate the various arrays we need. */ 7705 files = alloca (numfiles * sizeof (struct file_info)); 7706 dirs = alloca (numfiles * sizeof (struct dir_info)); 7707 7708 fnad.files = files; 7709 fnad.used_files = 0; 7710 fnad.max_files = numfiles; 7711 htab_traverse (file_table, file_name_acquire, &fnad); 7712 gcc_assert (fnad.used_files == fnad.max_files); 7713 7714 qsort (files, numfiles, sizeof (files[0]), file_info_cmp); 7715 7716 /* Find all the different directories used. */ 7717 dirs[0].path = files[0].path; 7718 dirs[0].length = files[0].fname - files[0].path; 7719 dirs[0].prefix = -1; 7720 dirs[0].count = 1; 7721 dirs[0].dir_idx = 0; 7722 files[0].dir_idx = 0; 7723 ndirs = 1; 7724 7725 for (i = 1; i < numfiles; i++) 7726 if (files[i].fname - files[i].path == dirs[ndirs - 1].length 7727 && memcmp (dirs[ndirs - 1].path, files[i].path, 7728 dirs[ndirs - 1].length) == 0) 7729 { 7730 /* Same directory as last entry. */ 7731 files[i].dir_idx = ndirs - 1; 7732 ++dirs[ndirs - 1].count; 7733 } 7734 else 7735 { 7736 int j; 7737 7738 /* This is a new directory. */ 7739 dirs[ndirs].path = files[i].path; 7740 dirs[ndirs].length = files[i].fname - files[i].path; 7741 dirs[ndirs].count = 1; 7742 dirs[ndirs].dir_idx = ndirs; 7743 files[i].dir_idx = ndirs; 7744 7745 /* Search for a prefix. */ 7746 dirs[ndirs].prefix = -1; 7747 for (j = 0; j < ndirs; j++) 7748 if (dirs[j].length < dirs[ndirs].length 7749 && dirs[j].length > 1 7750 && (dirs[ndirs].prefix == -1 7751 || dirs[j].length > dirs[dirs[ndirs].prefix].length) 7752 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0) 7753 dirs[ndirs].prefix = j; 7754 7755 ++ndirs; 7756 } 7757 7758 /* Now to the actual work. We have to find a subset of the directories which 7759 allow expressing the file name using references to the directory table 7760 with the least amount of characters. We do not do an exhaustive search 7761 where we would have to check out every combination of every single 7762 possible prefix. Instead we use a heuristic which provides nearly optimal 7763 results in most cases and never is much off. */ 7764 saved = alloca (ndirs * sizeof (int)); 7765 savehere = alloca (ndirs * sizeof (int)); 7766 7767 memset (saved, '\0', ndirs * sizeof (saved[0])); 7768 for (i = 0; i < ndirs; i++) 7769 { 7770 int j; 7771 int total; 7772 7773 /* We can always save some space for the current directory. But this 7774 does not mean it will be enough to justify adding the directory. */ 7775 savehere[i] = dirs[i].length; 7776 total = (savehere[i] - saved[i]) * dirs[i].count; 7777 7778 for (j = i + 1; j < ndirs; j++) 7779 { 7780 savehere[j] = 0; 7781 if (saved[j] < dirs[i].length) 7782 { 7783 /* Determine whether the dirs[i] path is a prefix of the 7784 dirs[j] path. */ 7785 int k; 7786 7787 k = dirs[j].prefix; 7788 while (k != -1 && k != (int) i) 7789 k = dirs[k].prefix; 7790 7791 if (k == (int) i) 7792 { 7793 /* Yes it is. We can possibly save some memory by 7794 writing the filenames in dirs[j] relative to 7795 dirs[i]. */ 7796 savehere[j] = dirs[i].length; 7797 total += (savehere[j] - saved[j]) * dirs[j].count; 7798 } 7799 } 7800 } 7801 7802 /* Check whether we can save enough to justify adding the dirs[i] 7803 directory. */ 7804 if (total > dirs[i].length + 1) 7805 { 7806 /* It's worthwhile adding. */ 7807 for (j = i; j < ndirs; j++) 7808 if (savehere[j] > 0) 7809 { 7810 /* Remember how much we saved for this directory so far. */ 7811 saved[j] = savehere[j]; 7812 7813 /* Remember the prefix directory. */ 7814 dirs[j].dir_idx = i; 7815 } 7816 } 7817 } 7818 7819 /* Emit the directory name table. */ 7820 idx = 1; 7821 idx_offset = dirs[0].length > 0 ? 1 : 0; 7822 for (i = 1 - idx_offset; i < ndirs; i++) 7823 dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1, 7824 "Directory Entry: 0x%x", i + idx_offset); 7825 7826 dw2_asm_output_data (1, 0, "End directory table"); 7827 7828 /* We have to emit them in the order of emitted_number since that's 7829 used in the debug info generation. To do this efficiently we 7830 generate a back-mapping of the indices first. */ 7831 backmap = alloca (numfiles * sizeof (int)); 7832 for (i = 0; i < numfiles; i++) 7833 backmap[files[i].file_idx->emitted_number - 1] = i; 7834 7835 /* Now write all the file names. */ 7836 for (i = 0; i < numfiles; i++) 7837 { 7838 int file_idx = backmap[i]; 7839 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx; 7840 7841 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1, 7842 "File Entry: 0x%x", (unsigned) i + 1); 7843 7844 /* Include directory index. */ 7845 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL); 7846 7847 /* Modification time. */ 7848 dw2_asm_output_data_uleb128 (0, NULL); 7849 7850 /* File length in bytes. */ 7851 dw2_asm_output_data_uleb128 (0, NULL); 7852 } 7853 7854 dw2_asm_output_data (1, 0, "End file name table"); 7855} 7856 7857 7858/* Output the source line number correspondence information. This 7859 information goes into the .debug_line section. */ 7860 7861static void 7862output_line_info (void) 7863{ 7864 char l1[20], l2[20], p1[20], p2[20]; 7865 char line_label[MAX_ARTIFICIAL_LABEL_BYTES]; 7866 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES]; 7867 unsigned opc; 7868 unsigned n_op_args; 7869 unsigned long lt_index; 7870 unsigned long current_line; 7871 long line_offset; 7872 long line_delta; 7873 unsigned long current_file; 7874 unsigned long function; 7875 7876 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0); 7877 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0); 7878 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0); 7879 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0); 7880 7881 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4) 7882 dw2_asm_output_data (4, 0xffffffff, 7883 "Initial length escape value indicating 64-bit DWARF extension"); 7884 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1, 7885 "Length of Source Line Info"); 7886 ASM_OUTPUT_LABEL (asm_out_file, l1); 7887 7888 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version"); 7889 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length"); 7890 ASM_OUTPUT_LABEL (asm_out_file, p1); 7891 7892 /* Define the architecture-dependent minimum instruction length (in 7893 bytes). In this implementation of DWARF, this field is used for 7894 information purposes only. Since GCC generates assembly language, 7895 we have no a priori knowledge of how many instruction bytes are 7896 generated for each source line, and therefore can use only the 7897 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information 7898 commands. Accordingly, we fix this as `1', which is "correct 7899 enough" for all architectures, and don't let the target override. */ 7900 dw2_asm_output_data (1, 1, 7901 "Minimum Instruction Length"); 7902 7903 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START, 7904 "Default is_stmt_start flag"); 7905 dw2_asm_output_data (1, DWARF_LINE_BASE, 7906 "Line Base Value (Special Opcodes)"); 7907 dw2_asm_output_data (1, DWARF_LINE_RANGE, 7908 "Line Range Value (Special Opcodes)"); 7909 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE, 7910 "Special Opcode Base"); 7911 7912 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++) 7913 { 7914 switch (opc) 7915 { 7916 case DW_LNS_advance_pc: 7917 case DW_LNS_advance_line: 7918 case DW_LNS_set_file: 7919 case DW_LNS_set_column: 7920 case DW_LNS_fixed_advance_pc: 7921 n_op_args = 1; 7922 break; 7923 default: 7924 n_op_args = 0; 7925 break; 7926 } 7927 7928 dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args", 7929 opc, n_op_args); 7930 } 7931 7932 /* Write out the information about the files we use. */ 7933 output_file_names (); 7934 ASM_OUTPUT_LABEL (asm_out_file, p2); 7935 7936 /* We used to set the address register to the first location in the text 7937 section here, but that didn't accomplish anything since we already 7938 have a line note for the opening brace of the first function. */ 7939 7940 /* Generate the line number to PC correspondence table, encoded as 7941 a series of state machine operations. */ 7942 current_file = 1; 7943 current_line = 1; 7944 7945 if (cfun && in_cold_section_p) 7946 strcpy (prev_line_label, cfun->cold_section_label); 7947 else 7948 strcpy (prev_line_label, text_section_label); 7949 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index) 7950 { 7951 dw_line_info_ref line_info = &line_info_table[lt_index]; 7952 7953#if 0 7954 /* Disable this optimization for now; GDB wants to see two line notes 7955 at the beginning of a function so it can find the end of the 7956 prologue. */ 7957 7958 /* Don't emit anything for redundant notes. Just updating the 7959 address doesn't accomplish anything, because we already assume 7960 that anything after the last address is this line. */ 7961 if (line_info->dw_line_num == current_line 7962 && line_info->dw_file_num == current_file) 7963 continue; 7964#endif 7965 7966 /* Emit debug info for the address of the current line. 7967 7968 Unfortunately, we have little choice here currently, and must always 7969 use the most general form. GCC does not know the address delta 7970 itself, so we can't use DW_LNS_advance_pc. Many ports do have length 7971 attributes which will give an upper bound on the address range. We 7972 could perhaps use length attributes to determine when it is safe to 7973 use DW_LNS_fixed_advance_pc. */ 7974 7975 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index); 7976 if (0) 7977 { 7978 /* This can handle deltas up to 0xffff. This takes 3 bytes. */ 7979 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, 7980 "DW_LNS_fixed_advance_pc"); 7981 dw2_asm_output_delta (2, line_label, prev_line_label, NULL); 7982 } 7983 else 7984 { 7985 /* This can handle any delta. This takes 7986 4+DWARF2_ADDR_SIZE bytes. */ 7987 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 7988 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 7989 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 7990 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL); 7991 } 7992 7993 strcpy (prev_line_label, line_label); 7994 7995 /* Emit debug info for the source file of the current line, if 7996 different from the previous line. */ 7997 if (line_info->dw_file_num != current_file) 7998 { 7999 current_file = line_info->dw_file_num; 8000 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file"); 8001 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file); 8002 } 8003 8004 /* Emit debug info for the current line number, choosing the encoding 8005 that uses the least amount of space. */ 8006 if (line_info->dw_line_num != current_line) 8007 { 8008 line_offset = line_info->dw_line_num - current_line; 8009 line_delta = line_offset - DWARF_LINE_BASE; 8010 current_line = line_info->dw_line_num; 8011 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1)) 8012 /* This can handle deltas from -10 to 234, using the current 8013 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This 8014 takes 1 byte. */ 8015 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta, 8016 "line %lu", current_line); 8017 else 8018 { 8019 /* This can handle any delta. This takes at least 4 bytes, 8020 depending on the value being encoded. */ 8021 dw2_asm_output_data (1, DW_LNS_advance_line, 8022 "advance to line %lu", current_line); 8023 dw2_asm_output_data_sleb128 (line_offset, NULL); 8024 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); 8025 } 8026 } 8027 else 8028 /* We still need to start a new row, so output a copy insn. */ 8029 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); 8030 } 8031 8032 /* Emit debug info for the address of the end of the function. */ 8033 if (0) 8034 { 8035 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, 8036 "DW_LNS_fixed_advance_pc"); 8037 dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL); 8038 } 8039 else 8040 { 8041 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 8042 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 8043 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 8044 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL); 8045 } 8046 8047 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence"); 8048 dw2_asm_output_data_uleb128 (1, NULL); 8049 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL); 8050 8051 function = 0; 8052 current_file = 1; 8053 current_line = 1; 8054 for (lt_index = 0; lt_index < separate_line_info_table_in_use;) 8055 { 8056 dw_separate_line_info_ref line_info 8057 = &separate_line_info_table[lt_index]; 8058 8059#if 0 8060 /* Don't emit anything for redundant notes. */ 8061 if (line_info->dw_line_num == current_line 8062 && line_info->dw_file_num == current_file 8063 && line_info->function == function) 8064 goto cont; 8065#endif 8066 8067 /* Emit debug info for the address of the current line. If this is 8068 a new function, or the first line of a function, then we need 8069 to handle it differently. */ 8070 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL, 8071 lt_index); 8072 if (function != line_info->function) 8073 { 8074 function = line_info->function; 8075 8076 /* Set the address register to the first line in the function. */ 8077 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 8078 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 8079 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 8080 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL); 8081 } 8082 else 8083 { 8084 /* ??? See the DW_LNS_advance_pc comment above. */ 8085 if (0) 8086 { 8087 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, 8088 "DW_LNS_fixed_advance_pc"); 8089 dw2_asm_output_delta (2, line_label, prev_line_label, NULL); 8090 } 8091 else 8092 { 8093 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 8094 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 8095 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 8096 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL); 8097 } 8098 } 8099 8100 strcpy (prev_line_label, line_label); 8101 8102 /* Emit debug info for the source file of the current line, if 8103 different from the previous line. */ 8104 if (line_info->dw_file_num != current_file) 8105 { 8106 current_file = line_info->dw_file_num; 8107 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file"); 8108 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file); 8109 } 8110 8111 /* Emit debug info for the current line number, choosing the encoding 8112 that uses the least amount of space. */ 8113 if (line_info->dw_line_num != current_line) 8114 { 8115 line_offset = line_info->dw_line_num - current_line; 8116 line_delta = line_offset - DWARF_LINE_BASE; 8117 current_line = line_info->dw_line_num; 8118 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1)) 8119 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta, 8120 "line %lu", current_line); 8121 else 8122 { 8123 dw2_asm_output_data (1, DW_LNS_advance_line, 8124 "advance to line %lu", current_line); 8125 dw2_asm_output_data_sleb128 (line_offset, NULL); 8126 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); 8127 } 8128 } 8129 else 8130 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); 8131 8132#if 0 8133 cont: 8134#endif 8135 8136 lt_index++; 8137 8138 /* If we're done with a function, end its sequence. */ 8139 if (lt_index == separate_line_info_table_in_use 8140 || separate_line_info_table[lt_index].function != function) 8141 { 8142 current_file = 1; 8143 current_line = 1; 8144 8145 /* Emit debug info for the address of the end of the function. */ 8146 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function); 8147 if (0) 8148 { 8149 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, 8150 "DW_LNS_fixed_advance_pc"); 8151 dw2_asm_output_delta (2, line_label, prev_line_label, NULL); 8152 } 8153 else 8154 { 8155 dw2_asm_output_data (1, 0, "DW_LNE_set_address"); 8156 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); 8157 dw2_asm_output_data (1, DW_LNE_set_address, NULL); 8158 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL); 8159 } 8160 8161 /* Output the marker for the end of this sequence. */ 8162 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence"); 8163 dw2_asm_output_data_uleb128 (1, NULL); 8164 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL); 8165 } 8166 } 8167 8168 /* Output the marker for the end of the line number info. */ 8169 ASM_OUTPUT_LABEL (asm_out_file, l2); 8170} 8171 8172/* Given a pointer to a tree node for some base type, return a pointer to 8173 a DIE that describes the given type. 8174 8175 This routine must only be called for GCC type nodes that correspond to 8176 Dwarf base (fundamental) types. */ 8177 8178static dw_die_ref 8179base_type_die (tree type) 8180{ 8181 dw_die_ref base_type_result; 8182 enum dwarf_type encoding; 8183 8184 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE) 8185 return 0; 8186 8187 switch (TREE_CODE (type)) 8188 { 8189 case INTEGER_TYPE: 8190 if (TYPE_STRING_FLAG (type)) 8191 { 8192 if (TYPE_UNSIGNED (type)) 8193 encoding = DW_ATE_unsigned_char; 8194 else 8195 encoding = DW_ATE_signed_char; 8196 } 8197 else if (TYPE_UNSIGNED (type)) 8198 encoding = DW_ATE_unsigned; 8199 else 8200 encoding = DW_ATE_signed; 8201 break; 8202 8203 case REAL_TYPE: 8204 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type))) 8205 encoding = DW_ATE_decimal_float; 8206 else 8207 encoding = DW_ATE_float; 8208 break; 8209 8210 /* Dwarf2 doesn't know anything about complex ints, so use 8211 a user defined type for it. */ 8212 case COMPLEX_TYPE: 8213 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE) 8214 encoding = DW_ATE_complex_float; 8215 else 8216 encoding = DW_ATE_lo_user; 8217 break; 8218 8219 case BOOLEAN_TYPE: 8220 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */ 8221 encoding = DW_ATE_boolean; 8222 break; 8223 8224 default: 8225 /* No other TREE_CODEs are Dwarf fundamental types. */ 8226 gcc_unreachable (); 8227 } 8228 8229 base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type); 8230 8231 /* This probably indicates a bug. */ 8232 if (! TYPE_NAME (type)) 8233 add_name_attribute (base_type_result, "__unknown__"); 8234 8235 add_AT_unsigned (base_type_result, DW_AT_byte_size, 8236 int_size_in_bytes (type)); 8237 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding); 8238 8239 return base_type_result; 8240} 8241 8242/* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to 8243 the Dwarf "root" type for the given input type. The Dwarf "root" type of 8244 a given type is generally the same as the given type, except that if the 8245 given type is a pointer or reference type, then the root type of the given 8246 type is the root type of the "basis" type for the pointer or reference 8247 type. (This definition of the "root" type is recursive.) Also, the root 8248 type of a `const' qualified type or a `volatile' qualified type is the 8249 root type of the given type without the qualifiers. */ 8250 8251static tree 8252root_type (tree type) 8253{ 8254 if (TREE_CODE (type) == ERROR_MARK) 8255 return error_mark_node; 8256 8257 switch (TREE_CODE (type)) 8258 { 8259 case ERROR_MARK: 8260 return error_mark_node; 8261 8262 case POINTER_TYPE: 8263 case REFERENCE_TYPE: 8264 return type_main_variant (root_type (TREE_TYPE (type))); 8265 8266 default: 8267 return type_main_variant (type); 8268 } 8269} 8270 8271/* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the 8272 given input type is a Dwarf "fundamental" type. Otherwise return null. */ 8273 8274static inline int 8275is_base_type (tree type) 8276{ 8277 switch (TREE_CODE (type)) 8278 { 8279 case ERROR_MARK: 8280 case VOID_TYPE: 8281 case INTEGER_TYPE: 8282 case REAL_TYPE: 8283 case COMPLEX_TYPE: 8284 case BOOLEAN_TYPE: 8285 return 1; 8286 8287 case ARRAY_TYPE: 8288 case RECORD_TYPE: 8289 case UNION_TYPE: 8290 case QUAL_UNION_TYPE: 8291 case ENUMERAL_TYPE: 8292 case FUNCTION_TYPE: 8293 case METHOD_TYPE: 8294 case POINTER_TYPE: 8295 case REFERENCE_TYPE: 8296 case OFFSET_TYPE: 8297 case LANG_TYPE: 8298 case VECTOR_TYPE: 8299 return 0; 8300 8301 default: 8302 gcc_unreachable (); 8303 } 8304 8305 return 0; 8306} 8307 8308/* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE 8309 node, return the size in bits for the type if it is a constant, or else 8310 return the alignment for the type if the type's size is not constant, or 8311 else return BITS_PER_WORD if the type actually turns out to be an 8312 ERROR_MARK node. */ 8313 8314static inline unsigned HOST_WIDE_INT 8315simple_type_size_in_bits (tree type) 8316{ 8317 if (TREE_CODE (type) == ERROR_MARK) 8318 return BITS_PER_WORD; 8319 else if (TYPE_SIZE (type) == NULL_TREE) 8320 return 0; 8321 else if (host_integerp (TYPE_SIZE (type), 1)) 8322 return tree_low_cst (TYPE_SIZE (type), 1); 8323 else 8324 return TYPE_ALIGN (type); 8325} 8326 8327/* Return true if the debug information for the given type should be 8328 emitted as a subrange type. */ 8329 8330static inline bool 8331is_subrange_type (tree type) 8332{ 8333 tree subtype = TREE_TYPE (type); 8334 8335 /* Subrange types are identified by the fact that they are integer 8336 types, and that they have a subtype which is either an integer type 8337 or an enumeral type. */ 8338 8339 if (TREE_CODE (type) != INTEGER_TYPE 8340 || subtype == NULL_TREE) 8341 return false; 8342 8343 if (TREE_CODE (subtype) != INTEGER_TYPE 8344 && TREE_CODE (subtype) != ENUMERAL_TYPE) 8345 return false; 8346 8347 if (TREE_CODE (type) == TREE_CODE (subtype) 8348 && int_size_in_bytes (type) == int_size_in_bytes (subtype) 8349 && TYPE_MIN_VALUE (type) != NULL 8350 && TYPE_MIN_VALUE (subtype) != NULL 8351 && tree_int_cst_equal (TYPE_MIN_VALUE (type), TYPE_MIN_VALUE (subtype)) 8352 && TYPE_MAX_VALUE (type) != NULL 8353 && TYPE_MAX_VALUE (subtype) != NULL 8354 && tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype))) 8355 { 8356 /* The type and its subtype have the same representation. If in 8357 addition the two types also have the same name, then the given 8358 type is not a subrange type, but rather a plain base type. */ 8359 /* FIXME: brobecker/2004-03-22: 8360 Sizetype INTEGER_CSTs nodes are canonicalized. It should 8361 therefore be sufficient to check the TYPE_SIZE node pointers 8362 rather than checking the actual size. Unfortunately, we have 8363 found some cases, such as in the Ada "integer" type, where 8364 this is not the case. Until this problem is solved, we need to 8365 keep checking the actual size. */ 8366 tree type_name = TYPE_NAME (type); 8367 tree subtype_name = TYPE_NAME (subtype); 8368 8369 if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL) 8370 type_name = DECL_NAME (type_name); 8371 8372 if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL) 8373 subtype_name = DECL_NAME (subtype_name); 8374 8375 if (type_name == subtype_name) 8376 return false; 8377 } 8378 8379 return true; 8380} 8381 8382/* Given a pointer to a tree node for a subrange type, return a pointer 8383 to a DIE that describes the given type. */ 8384 8385static dw_die_ref 8386subrange_type_die (tree type, dw_die_ref context_die) 8387{ 8388 dw_die_ref subrange_die; 8389 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type); 8390 8391 if (context_die == NULL) 8392 context_die = comp_unit_die; 8393 8394 subrange_die = new_die (DW_TAG_subrange_type, context_die, type); 8395 8396 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes) 8397 { 8398 /* The size of the subrange type and its base type do not match, 8399 so we need to generate a size attribute for the subrange type. */ 8400 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes); 8401 } 8402 8403 if (TYPE_MIN_VALUE (type) != NULL) 8404 add_bound_info (subrange_die, DW_AT_lower_bound, 8405 TYPE_MIN_VALUE (type)); 8406 if (TYPE_MAX_VALUE (type) != NULL) 8407 add_bound_info (subrange_die, DW_AT_upper_bound, 8408 TYPE_MAX_VALUE (type)); 8409 8410 return subrange_die; 8411} 8412 8413/* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging 8414 entry that chains various modifiers in front of the given type. */ 8415 8416static dw_die_ref 8417modified_type_die (tree type, int is_const_type, int is_volatile_type, 8418 dw_die_ref context_die) 8419{ 8420 enum tree_code code = TREE_CODE (type); 8421 dw_die_ref mod_type_die; 8422 dw_die_ref sub_die = NULL; 8423 tree item_type = NULL; 8424 tree qualified_type; 8425 tree name; 8426 8427 if (code == ERROR_MARK) 8428 return NULL; 8429 8430 /* See if we already have the appropriately qualified variant of 8431 this type. */ 8432 qualified_type 8433 = get_qualified_type (type, 8434 ((is_const_type ? TYPE_QUAL_CONST : 0) 8435 | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0))); 8436 8437 /* If we do, then we can just use its DIE, if it exists. */ 8438 if (qualified_type) 8439 { 8440 mod_type_die = lookup_type_die (qualified_type); 8441 if (mod_type_die) 8442 return mod_type_die; 8443 } 8444 8445 name = qualified_type ? TYPE_NAME (qualified_type) : NULL; 8446 8447 /* Handle C typedef types. */ 8448 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name)) 8449 { 8450 tree dtype = TREE_TYPE (name); 8451 8452 if (qualified_type == dtype) 8453 { 8454 /* For a named type, use the typedef. */ 8455 gen_type_die (qualified_type, context_die); 8456 return lookup_type_die (qualified_type); 8457 } 8458 else if (is_const_type < TYPE_READONLY (dtype) 8459 || is_volatile_type < TYPE_VOLATILE (dtype) 8460 || (is_const_type <= TYPE_READONLY (dtype) 8461 && is_volatile_type <= TYPE_VOLATILE (dtype) 8462 && DECL_ORIGINAL_TYPE (name) != type)) 8463 /* cv-unqualified version of named type. Just use the unnamed 8464 type to which it refers. */ 8465 return modified_type_die (DECL_ORIGINAL_TYPE (name), 8466 is_const_type, is_volatile_type, 8467 context_die); 8468 /* Else cv-qualified version of named type; fall through. */ 8469 } 8470 8471 if (is_const_type) 8472 { 8473 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type); 8474 sub_die = modified_type_die (type, 0, is_volatile_type, context_die); 8475 } 8476 else if (is_volatile_type) 8477 { 8478 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type); 8479 sub_die = modified_type_die (type, 0, 0, context_die); 8480 } 8481 else if (code == POINTER_TYPE) 8482 { 8483 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type); 8484 add_AT_unsigned (mod_type_die, DW_AT_byte_size, 8485 simple_type_size_in_bits (type) / BITS_PER_UNIT); 8486 item_type = TREE_TYPE (type); 8487 } 8488 else if (code == REFERENCE_TYPE) 8489 { 8490 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type); 8491 add_AT_unsigned (mod_type_die, DW_AT_byte_size, 8492 simple_type_size_in_bits (type) / BITS_PER_UNIT); 8493 item_type = TREE_TYPE (type); 8494 } 8495 else if (is_subrange_type (type)) 8496 { 8497 mod_type_die = subrange_type_die (type, context_die); 8498 item_type = TREE_TYPE (type); 8499 } 8500 else if (is_base_type (type)) 8501 mod_type_die = base_type_die (type); 8502 else 8503 { 8504 gen_type_die (type, context_die); 8505 8506 /* We have to get the type_main_variant here (and pass that to the 8507 `lookup_type_die' routine) because the ..._TYPE node we have 8508 might simply be a *copy* of some original type node (where the 8509 copy was created to help us keep track of typedef names) and 8510 that copy might have a different TYPE_UID from the original 8511 ..._TYPE node. */ 8512 if (TREE_CODE (type) != VECTOR_TYPE) 8513 return lookup_type_die (type_main_variant (type)); 8514 else 8515 /* Vectors have the debugging information in the type, 8516 not the main variant. */ 8517 return lookup_type_die (type); 8518 } 8519 8520 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those, 8521 don't output a DW_TAG_typedef, since there isn't one in the 8522 user's program; just attach a DW_AT_name to the type. */ 8523 if (name 8524 && (TREE_CODE (name) != TYPE_DECL || TREE_TYPE (name) == qualified_type)) 8525 { 8526 if (TREE_CODE (name) == TYPE_DECL) 8527 /* Could just call add_name_and_src_coords_attributes here, 8528 but since this is a builtin type it doesn't have any 8529 useful source coordinates anyway. */ 8530 name = DECL_NAME (name); 8531 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name)); 8532 } 8533 8534 if (qualified_type) 8535 equate_type_number_to_die (qualified_type, mod_type_die); 8536 8537 if (item_type) 8538 /* We must do this after the equate_type_number_to_die call, in case 8539 this is a recursive type. This ensures that the modified_type_die 8540 recursion will terminate even if the type is recursive. Recursive 8541 types are possible in Ada. */ 8542 sub_die = modified_type_die (item_type, 8543 TYPE_READONLY (item_type), 8544 TYPE_VOLATILE (item_type), 8545 context_die); 8546 8547 if (sub_die != NULL) 8548 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die); 8549 8550 return mod_type_die; 8551} 8552 8553/* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is 8554 an enumerated type. */ 8555 8556static inline int 8557type_is_enum (tree type) 8558{ 8559 return TREE_CODE (type) == ENUMERAL_TYPE; 8560} 8561 8562/* Return the DBX register number described by a given RTL node. */ 8563 8564static unsigned int 8565dbx_reg_number (rtx rtl) 8566{ 8567 unsigned regno = REGNO (rtl); 8568 8569 gcc_assert (regno < FIRST_PSEUDO_REGISTER); 8570 8571#ifdef LEAF_REG_REMAP 8572 if (current_function_uses_only_leaf_regs) 8573 { 8574 int leaf_reg = LEAF_REG_REMAP (regno); 8575 if (leaf_reg != -1) 8576 regno = (unsigned) leaf_reg; 8577 } 8578#endif 8579 8580 return DBX_REGISTER_NUMBER (regno); 8581} 8582 8583/* Optionally add a DW_OP_piece term to a location description expression. 8584 DW_OP_piece is only added if the location description expression already 8585 doesn't end with DW_OP_piece. */ 8586 8587static void 8588add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size) 8589{ 8590 dw_loc_descr_ref loc; 8591 8592 if (*list_head != NULL) 8593 { 8594 /* Find the end of the chain. */ 8595 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next) 8596 ; 8597 8598 if (loc->dw_loc_opc != DW_OP_piece) 8599 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0); 8600 } 8601} 8602 8603/* Return a location descriptor that designates a machine register or 8604 zero if there is none. */ 8605 8606static dw_loc_descr_ref 8607reg_loc_descriptor (rtx rtl) 8608{ 8609 rtx regs; 8610 8611 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER) 8612 return 0; 8613 8614 regs = targetm.dwarf_register_span (rtl); 8615 8616 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs) 8617 return multiple_reg_loc_descriptor (rtl, regs); 8618 else 8619 return one_reg_loc_descriptor (dbx_reg_number (rtl)); 8620} 8621 8622/* Return a location descriptor that designates a machine register for 8623 a given hard register number. */ 8624 8625static dw_loc_descr_ref 8626one_reg_loc_descriptor (unsigned int regno) 8627{ 8628 if (regno <= 31) 8629 return new_loc_descr (DW_OP_reg0 + regno, 0, 0); 8630 else 8631 return new_loc_descr (DW_OP_regx, regno, 0); 8632} 8633 8634/* Given an RTL of a register, return a location descriptor that 8635 designates a value that spans more than one register. */ 8636 8637static dw_loc_descr_ref 8638multiple_reg_loc_descriptor (rtx rtl, rtx regs) 8639{ 8640 int nregs, size, i; 8641 unsigned reg; 8642 dw_loc_descr_ref loc_result = NULL; 8643 8644 reg = REGNO (rtl); 8645#ifdef LEAF_REG_REMAP 8646 if (current_function_uses_only_leaf_regs) 8647 { 8648 int leaf_reg = LEAF_REG_REMAP (reg); 8649 if (leaf_reg != -1) 8650 reg = (unsigned) leaf_reg; 8651 } 8652#endif 8653 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl)); 8654 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)]; 8655 8656 /* Simple, contiguous registers. */ 8657 if (regs == NULL_RTX) 8658 { 8659 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs; 8660 8661 loc_result = NULL; 8662 while (nregs--) 8663 { 8664 dw_loc_descr_ref t; 8665 8666 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg)); 8667 add_loc_descr (&loc_result, t); 8668 add_loc_descr_op_piece (&loc_result, size); 8669 ++reg; 8670 } 8671 return loc_result; 8672 } 8673 8674 /* Now onto stupid register sets in non contiguous locations. */ 8675 8676 gcc_assert (GET_CODE (regs) == PARALLEL); 8677 8678 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0))); 8679 loc_result = NULL; 8680 8681 for (i = 0; i < XVECLEN (regs, 0); ++i) 8682 { 8683 dw_loc_descr_ref t; 8684 8685 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i))); 8686 add_loc_descr (&loc_result, t); 8687 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0))); 8688 add_loc_descr_op_piece (&loc_result, size); 8689 } 8690 return loc_result; 8691} 8692 8693/* Return a location descriptor that designates a constant. */ 8694 8695static dw_loc_descr_ref 8696int_loc_descriptor (HOST_WIDE_INT i) 8697{ 8698 enum dwarf_location_atom op; 8699 8700 /* Pick the smallest representation of a constant, rather than just 8701 defaulting to the LEB encoding. */ 8702 if (i >= 0) 8703 { 8704 if (i <= 31) 8705 op = DW_OP_lit0 + i; 8706 else if (i <= 0xff) 8707 op = DW_OP_const1u; 8708 else if (i <= 0xffff) 8709 op = DW_OP_const2u; 8710 else if (HOST_BITS_PER_WIDE_INT == 32 8711 || i <= 0xffffffff) 8712 op = DW_OP_const4u; 8713 else 8714 op = DW_OP_constu; 8715 } 8716 else 8717 { 8718 if (i >= -0x80) 8719 op = DW_OP_const1s; 8720 else if (i >= -0x8000) 8721 op = DW_OP_const2s; 8722 else if (HOST_BITS_PER_WIDE_INT == 32 8723 || i >= -0x80000000) 8724 op = DW_OP_const4s; 8725 else 8726 op = DW_OP_consts; 8727 } 8728 8729 return new_loc_descr (op, i, 0); 8730} 8731 8732/* Return a location descriptor that designates a base+offset location. */ 8733 8734static dw_loc_descr_ref 8735based_loc_descr (rtx reg, HOST_WIDE_INT offset) 8736{ 8737 unsigned int regno; 8738 8739 /* We only use "frame base" when we're sure we're talking about the 8740 post-prologue local stack frame. We do this by *not* running 8741 register elimination until this point, and recognizing the special 8742 argument pointer and soft frame pointer rtx's. */ 8743 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx) 8744 { 8745 rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX); 8746 8747 if (elim != reg) 8748 { 8749 if (GET_CODE (elim) == PLUS) 8750 { 8751 offset += INTVAL (XEXP (elim, 1)); 8752 elim = XEXP (elim, 0); 8753 } 8754 gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx 8755 : stack_pointer_rtx)); 8756 offset += frame_pointer_fb_offset; 8757 8758 return new_loc_descr (DW_OP_fbreg, offset, 0); 8759 } 8760 } 8761 8762 regno = dbx_reg_number (reg); 8763 if (regno <= 31) 8764 return new_loc_descr (DW_OP_breg0 + regno, offset, 0); 8765 else 8766 return new_loc_descr (DW_OP_bregx, regno, offset); 8767} 8768 8769/* Return true if this RTL expression describes a base+offset calculation. */ 8770 8771static inline int 8772is_based_loc (rtx rtl) 8773{ 8774 return (GET_CODE (rtl) == PLUS 8775 && ((REG_P (XEXP (rtl, 0)) 8776 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER 8777 && GET_CODE (XEXP (rtl, 1)) == CONST_INT))); 8778} 8779 8780/* The following routine converts the RTL for a variable or parameter 8781 (resident in memory) into an equivalent Dwarf representation of a 8782 mechanism for getting the address of that same variable onto the top of a 8783 hypothetical "address evaluation" stack. 8784 8785 When creating memory location descriptors, we are effectively transforming 8786 the RTL for a memory-resident object into its Dwarf postfix expression 8787 equivalent. This routine recursively descends an RTL tree, turning 8788 it into Dwarf postfix code as it goes. 8789 8790 MODE is the mode of the memory reference, needed to handle some 8791 autoincrement addressing modes. 8792 8793 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the 8794 location list for RTL. 8795 8796 Return 0 if we can't represent the location. */ 8797 8798static dw_loc_descr_ref 8799mem_loc_descriptor (rtx rtl, enum machine_mode mode) 8800{ 8801 dw_loc_descr_ref mem_loc_result = NULL; 8802 enum dwarf_location_atom op; 8803 8804 /* Note that for a dynamically sized array, the location we will generate a 8805 description of here will be the lowest numbered location which is 8806 actually within the array. That's *not* necessarily the same as the 8807 zeroth element of the array. */ 8808 8809 rtl = targetm.delegitimize_address (rtl); 8810 8811 switch (GET_CODE (rtl)) 8812 { 8813 case POST_INC: 8814 case POST_DEC: 8815 case POST_MODIFY: 8816 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we 8817 just fall into the SUBREG code. */ 8818 8819 /* ... fall through ... */ 8820 8821 case SUBREG: 8822 /* The case of a subreg may arise when we have a local (register) 8823 variable or a formal (register) parameter which doesn't quite fill 8824 up an entire register. For now, just assume that it is 8825 legitimate to make the Dwarf info refer to the whole register which 8826 contains the given subreg. */ 8827 rtl = XEXP (rtl, 0); 8828 8829 /* ... fall through ... */ 8830 8831 case REG: 8832 /* Whenever a register number forms a part of the description of the 8833 method for calculating the (dynamic) address of a memory resident 8834 object, DWARF rules require the register number be referred to as 8835 a "base register". This distinction is not based in any way upon 8836 what category of register the hardware believes the given register 8837 belongs to. This is strictly DWARF terminology we're dealing with 8838 here. Note that in cases where the location of a memory-resident 8839 data object could be expressed as: OP_ADD (OP_BASEREG (basereg), 8840 OP_CONST (0)) the actual DWARF location descriptor that we generate 8841 may just be OP_BASEREG (basereg). This may look deceptively like 8842 the object in question was allocated to a register (rather than in 8843 memory) so DWARF consumers need to be aware of the subtle 8844 distinction between OP_REG and OP_BASEREG. */ 8845 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER) 8846 mem_loc_result = based_loc_descr (rtl, 0); 8847 break; 8848 8849 case MEM: 8850 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl)); 8851 if (mem_loc_result != 0) 8852 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0)); 8853 break; 8854 8855 case LO_SUM: 8856 rtl = XEXP (rtl, 1); 8857 8858 /* ... fall through ... */ 8859 8860 case LABEL_REF: 8861 /* Some ports can transform a symbol ref into a label ref, because 8862 the symbol ref is too far away and has to be dumped into a constant 8863 pool. */ 8864 case CONST: 8865 case SYMBOL_REF: 8866 /* Alternatively, the symbol in the constant pool might be referenced 8867 by a different symbol. */ 8868 if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl)) 8869 { 8870 bool marked; 8871 rtx tmp = get_pool_constant_mark (rtl, &marked); 8872 8873 if (GET_CODE (tmp) == SYMBOL_REF) 8874 { 8875 rtl = tmp; 8876 if (CONSTANT_POOL_ADDRESS_P (tmp)) 8877 get_pool_constant_mark (tmp, &marked); 8878 else 8879 marked = true; 8880 } 8881 8882 /* If all references to this pool constant were optimized away, 8883 it was not output and thus we can't represent it. 8884 FIXME: might try to use DW_OP_const_value here, though 8885 DW_OP_piece complicates it. */ 8886 if (!marked) 8887 return 0; 8888 } 8889 8890 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0); 8891 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr; 8892 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl; 8893 VEC_safe_push (rtx, gc, used_rtx_array, rtl); 8894 break; 8895 8896 case PRE_MODIFY: 8897 /* Extract the PLUS expression nested inside and fall into 8898 PLUS code below. */ 8899 rtl = XEXP (rtl, 1); 8900 goto plus; 8901 8902 case PRE_INC: 8903 case PRE_DEC: 8904 /* Turn these into a PLUS expression and fall into the PLUS code 8905 below. */ 8906 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0), 8907 GEN_INT (GET_CODE (rtl) == PRE_INC 8908 ? GET_MODE_UNIT_SIZE (mode) 8909 : -GET_MODE_UNIT_SIZE (mode))); 8910 8911 /* ... fall through ... */ 8912 8913 case PLUS: 8914 plus: 8915 if (is_based_loc (rtl)) 8916 mem_loc_result = based_loc_descr (XEXP (rtl, 0), 8917 INTVAL (XEXP (rtl, 1))); 8918 else 8919 { 8920 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode); 8921 if (mem_loc_result == 0) 8922 break; 8923 8924 if (GET_CODE (XEXP (rtl, 1)) == CONST_INT 8925 && INTVAL (XEXP (rtl, 1)) >= 0) 8926 add_loc_descr (&mem_loc_result, 8927 new_loc_descr (DW_OP_plus_uconst, 8928 INTVAL (XEXP (rtl, 1)), 0)); 8929 else 8930 { 8931 add_loc_descr (&mem_loc_result, 8932 mem_loc_descriptor (XEXP (rtl, 1), mode)); 8933 add_loc_descr (&mem_loc_result, 8934 new_loc_descr (DW_OP_plus, 0, 0)); 8935 } 8936 } 8937 break; 8938 8939 /* If a pseudo-reg is optimized away, it is possible for it to 8940 be replaced with a MEM containing a multiply or shift. */ 8941 case MULT: 8942 op = DW_OP_mul; 8943 goto do_binop; 8944 8945 case ASHIFT: 8946 op = DW_OP_shl; 8947 goto do_binop; 8948 8949 case ASHIFTRT: 8950 op = DW_OP_shra; 8951 goto do_binop; 8952 8953 case LSHIFTRT: 8954 op = DW_OP_shr; 8955 goto do_binop; 8956 8957 do_binop: 8958 { 8959 dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode); 8960 dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode); 8961 8962 if (op0 == 0 || op1 == 0) 8963 break; 8964 8965 mem_loc_result = op0; 8966 add_loc_descr (&mem_loc_result, op1); 8967 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0)); 8968 break; 8969 } 8970 8971 case CONST_INT: 8972 mem_loc_result = int_loc_descriptor (INTVAL (rtl)); 8973 break; 8974 8975 default: 8976 gcc_unreachable (); 8977 } 8978 8979 return mem_loc_result; 8980} 8981 8982/* Return a descriptor that describes the concatenation of two locations. 8983 This is typically a complex variable. */ 8984 8985static dw_loc_descr_ref 8986concat_loc_descriptor (rtx x0, rtx x1) 8987{ 8988 dw_loc_descr_ref cc_loc_result = NULL; 8989 dw_loc_descr_ref x0_ref = loc_descriptor (x0); 8990 dw_loc_descr_ref x1_ref = loc_descriptor (x1); 8991 8992 if (x0_ref == 0 || x1_ref == 0) 8993 return 0; 8994 8995 cc_loc_result = x0_ref; 8996 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0))); 8997 8998 add_loc_descr (&cc_loc_result, x1_ref); 8999 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1))); 9000 9001 return cc_loc_result; 9002} 9003 9004/* Output a proper Dwarf location descriptor for a variable or parameter 9005 which is either allocated in a register or in a memory location. For a 9006 register, we just generate an OP_REG and the register number. For a 9007 memory location we provide a Dwarf postfix expression describing how to 9008 generate the (dynamic) address of the object onto the address stack. 9009 9010 If we don't know how to describe it, return 0. */ 9011 9012static dw_loc_descr_ref 9013loc_descriptor (rtx rtl) 9014{ 9015 dw_loc_descr_ref loc_result = NULL; 9016 9017 switch (GET_CODE (rtl)) 9018 { 9019 case SUBREG: 9020 /* The case of a subreg may arise when we have a local (register) 9021 variable or a formal (register) parameter which doesn't quite fill 9022 up an entire register. For now, just assume that it is 9023 legitimate to make the Dwarf info refer to the whole register which 9024 contains the given subreg. */ 9025 rtl = SUBREG_REG (rtl); 9026 9027 /* ... fall through ... */ 9028 9029 case REG: 9030 loc_result = reg_loc_descriptor (rtl); 9031 break; 9032 9033 case MEM: 9034 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl)); 9035 break; 9036 9037 case CONCAT: 9038 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1)); 9039 break; 9040 9041 case VAR_LOCATION: 9042 /* Single part. */ 9043 if (GET_CODE (XEXP (rtl, 1)) != PARALLEL) 9044 { 9045 loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0)); 9046 break; 9047 } 9048 9049 rtl = XEXP (rtl, 1); 9050 /* FALLTHRU */ 9051 9052 case PARALLEL: 9053 { 9054 rtvec par_elems = XVEC (rtl, 0); 9055 int num_elem = GET_NUM_ELEM (par_elems); 9056 enum machine_mode mode; 9057 int i; 9058 9059 /* Create the first one, so we have something to add to. */ 9060 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0)); 9061 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0)); 9062 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode)); 9063 for (i = 1; i < num_elem; i++) 9064 { 9065 dw_loc_descr_ref temp; 9066 9067 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0)); 9068 add_loc_descr (&loc_result, temp); 9069 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0)); 9070 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode)); 9071 } 9072 } 9073 break; 9074 9075 default: 9076 gcc_unreachable (); 9077 } 9078 9079 return loc_result; 9080} 9081 9082/* Similar, but generate the descriptor from trees instead of rtl. This comes 9083 up particularly with variable length arrays. WANT_ADDRESS is 2 if this is 9084 a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a 9085 top-level invocation, and we require the address of LOC; is 0 if we require 9086 the value of LOC. */ 9087 9088static dw_loc_descr_ref 9089loc_descriptor_from_tree_1 (tree loc, int want_address) 9090{ 9091 dw_loc_descr_ref ret, ret1; 9092 int have_address = 0; 9093 enum dwarf_location_atom op; 9094 9095 /* ??? Most of the time we do not take proper care for sign/zero 9096 extending the values properly. Hopefully this won't be a real 9097 problem... */ 9098 9099 switch (TREE_CODE (loc)) 9100 { 9101 case ERROR_MARK: 9102 return 0; 9103 9104 case PLACEHOLDER_EXPR: 9105 /* This case involves extracting fields from an object to determine the 9106 position of other fields. We don't try to encode this here. The 9107 only user of this is Ada, which encodes the needed information using 9108 the names of types. */ 9109 return 0; 9110 9111 case CALL_EXPR: 9112 return 0; 9113 9114 case PREINCREMENT_EXPR: 9115 case PREDECREMENT_EXPR: 9116 case POSTINCREMENT_EXPR: 9117 case POSTDECREMENT_EXPR: 9118 /* There are no opcodes for these operations. */ 9119 return 0; 9120 9121 case ADDR_EXPR: 9122 /* If we already want an address, there's nothing we can do. */ 9123 if (want_address) 9124 return 0; 9125 9126 /* Otherwise, process the argument and look for the address. */ 9127 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1); 9128 9129 case VAR_DECL: 9130 if (DECL_THREAD_LOCAL_P (loc)) 9131 { 9132 rtx rtl; 9133 9134 /* If this is not defined, we have no way to emit the data. */ 9135 if (!targetm.asm_out.output_dwarf_dtprel) 9136 return 0; 9137 9138 /* The way DW_OP_GNU_push_tls_address is specified, we can only 9139 look up addresses of objects in the current module. */ 9140 if (DECL_EXTERNAL (loc)) 9141 return 0; 9142 9143 rtl = rtl_for_decl_location (loc); 9144 if (rtl == NULL_RTX) 9145 return 0; 9146 9147 if (!MEM_P (rtl)) 9148 return 0; 9149 rtl = XEXP (rtl, 0); 9150 if (! CONSTANT_P (rtl)) 9151 return 0; 9152 9153 ret = new_loc_descr (INTERNAL_DW_OP_tls_addr, 0, 0); 9154 ret->dw_loc_oprnd1.val_class = dw_val_class_addr; 9155 ret->dw_loc_oprnd1.v.val_addr = rtl; 9156 9157 ret1 = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0); 9158 add_loc_descr (&ret, ret1); 9159 9160 have_address = 1; 9161 break; 9162 } 9163 /* FALLTHRU */ 9164 9165 case PARM_DECL: 9166 if (DECL_HAS_VALUE_EXPR_P (loc)) 9167 return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc), 9168 want_address); 9169 /* FALLTHRU */ 9170 9171 case RESULT_DECL: 9172 case FUNCTION_DECL: 9173 { 9174 rtx rtl = rtl_for_decl_location (loc); 9175 9176 if (rtl == NULL_RTX) 9177 return 0; 9178 else if (GET_CODE (rtl) == CONST_INT) 9179 { 9180 HOST_WIDE_INT val = INTVAL (rtl); 9181 if (TYPE_UNSIGNED (TREE_TYPE (loc))) 9182 val &= GET_MODE_MASK (DECL_MODE (loc)); 9183 ret = int_loc_descriptor (val); 9184 } 9185 else if (GET_CODE (rtl) == CONST_STRING) 9186 return 0; 9187 else if (CONSTANT_P (rtl)) 9188 { 9189 ret = new_loc_descr (DW_OP_addr, 0, 0); 9190 ret->dw_loc_oprnd1.val_class = dw_val_class_addr; 9191 ret->dw_loc_oprnd1.v.val_addr = rtl; 9192 } 9193 else 9194 { 9195 enum machine_mode mode; 9196 9197 /* Certain constructs can only be represented at top-level. */ 9198 if (want_address == 2) 9199 return loc_descriptor (rtl); 9200 9201 mode = GET_MODE (rtl); 9202 if (MEM_P (rtl)) 9203 { 9204 rtl = XEXP (rtl, 0); 9205 have_address = 1; 9206 } 9207 ret = mem_loc_descriptor (rtl, mode); 9208 } 9209 } 9210 break; 9211 9212 case INDIRECT_REF: 9213 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0); 9214 have_address = 1; 9215 break; 9216 9217 case COMPOUND_EXPR: 9218 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address); 9219 9220 case NOP_EXPR: 9221 case CONVERT_EXPR: 9222 case NON_LVALUE_EXPR: 9223 case VIEW_CONVERT_EXPR: 9224 case SAVE_EXPR: 9225 case MODIFY_EXPR: 9226 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), want_address); 9227 9228 case COMPONENT_REF: 9229 case BIT_FIELD_REF: 9230 case ARRAY_REF: 9231 case ARRAY_RANGE_REF: 9232 { 9233 tree obj, offset; 9234 HOST_WIDE_INT bitsize, bitpos, bytepos; 9235 enum machine_mode mode; 9236 int volatilep; 9237 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc)); 9238 9239 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode, 9240 &unsignedp, &volatilep, false); 9241 9242 if (obj == loc) 9243 return 0; 9244 9245 ret = loc_descriptor_from_tree_1 (obj, 1); 9246 if (ret == 0 9247 || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0) 9248 return 0; 9249 9250 if (offset != NULL_TREE) 9251 { 9252 /* Variable offset. */ 9253 add_loc_descr (&ret, loc_descriptor_from_tree_1 (offset, 0)); 9254 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0)); 9255 } 9256 9257 bytepos = bitpos / BITS_PER_UNIT; 9258 if (bytepos > 0) 9259 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0)); 9260 else if (bytepos < 0) 9261 { 9262 add_loc_descr (&ret, int_loc_descriptor (bytepos)); 9263 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0)); 9264 } 9265 9266 have_address = 1; 9267 break; 9268 } 9269 9270 case INTEGER_CST: 9271 if (host_integerp (loc, 0)) 9272 ret = int_loc_descriptor (tree_low_cst (loc, 0)); 9273 else 9274 return 0; 9275 break; 9276 9277 case CONSTRUCTOR: 9278 { 9279 /* Get an RTL for this, if something has been emitted. */ 9280 rtx rtl = lookup_constant_def (loc); 9281 enum machine_mode mode; 9282 9283 if (!rtl || !MEM_P (rtl)) 9284 return 0; 9285 mode = GET_MODE (rtl); 9286 rtl = XEXP (rtl, 0); 9287 ret = mem_loc_descriptor (rtl, mode); 9288 have_address = 1; 9289 break; 9290 } 9291 9292 case TRUTH_AND_EXPR: 9293 case TRUTH_ANDIF_EXPR: 9294 case BIT_AND_EXPR: 9295 op = DW_OP_and; 9296 goto do_binop; 9297 9298 case TRUTH_XOR_EXPR: 9299 case BIT_XOR_EXPR: 9300 op = DW_OP_xor; 9301 goto do_binop; 9302 9303 case TRUTH_OR_EXPR: 9304 case TRUTH_ORIF_EXPR: 9305 case BIT_IOR_EXPR: 9306 op = DW_OP_or; 9307 goto do_binop; 9308 9309 case FLOOR_DIV_EXPR: 9310 case CEIL_DIV_EXPR: 9311 case ROUND_DIV_EXPR: 9312 case TRUNC_DIV_EXPR: 9313 op = DW_OP_div; 9314 goto do_binop; 9315 9316 case MINUS_EXPR: 9317 op = DW_OP_minus; 9318 goto do_binop; 9319 9320 case FLOOR_MOD_EXPR: 9321 case CEIL_MOD_EXPR: 9322 case ROUND_MOD_EXPR: 9323 case TRUNC_MOD_EXPR: 9324 op = DW_OP_mod; 9325 goto do_binop; 9326 9327 case MULT_EXPR: 9328 op = DW_OP_mul; 9329 goto do_binop; 9330 9331 case LSHIFT_EXPR: 9332 op = DW_OP_shl; 9333 goto do_binop; 9334 9335 case RSHIFT_EXPR: 9336 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra); 9337 goto do_binop; 9338 9339 case PLUS_EXPR: 9340 if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST 9341 && host_integerp (TREE_OPERAND (loc, 1), 0)) 9342 { 9343 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0); 9344 if (ret == 0) 9345 return 0; 9346 9347 add_loc_descr (&ret, 9348 new_loc_descr (DW_OP_plus_uconst, 9349 tree_low_cst (TREE_OPERAND (loc, 1), 9350 0), 9351 0)); 9352 break; 9353 } 9354 9355 op = DW_OP_plus; 9356 goto do_binop; 9357 9358 case LE_EXPR: 9359 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 9360 return 0; 9361 9362 op = DW_OP_le; 9363 goto do_binop; 9364 9365 case GE_EXPR: 9366 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 9367 return 0; 9368 9369 op = DW_OP_ge; 9370 goto do_binop; 9371 9372 case LT_EXPR: 9373 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 9374 return 0; 9375 9376 op = DW_OP_lt; 9377 goto do_binop; 9378 9379 case GT_EXPR: 9380 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0)))) 9381 return 0; 9382 9383 op = DW_OP_gt; 9384 goto do_binop; 9385 9386 case EQ_EXPR: 9387 op = DW_OP_eq; 9388 goto do_binop; 9389 9390 case NE_EXPR: 9391 op = DW_OP_ne; 9392 goto do_binop; 9393 9394 do_binop: 9395 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0); 9396 ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0); 9397 if (ret == 0 || ret1 == 0) 9398 return 0; 9399 9400 add_loc_descr (&ret, ret1); 9401 add_loc_descr (&ret, new_loc_descr (op, 0, 0)); 9402 break; 9403 9404 case TRUTH_NOT_EXPR: 9405 case BIT_NOT_EXPR: 9406 op = DW_OP_not; 9407 goto do_unop; 9408 9409 case ABS_EXPR: 9410 op = DW_OP_abs; 9411 goto do_unop; 9412 9413 case NEGATE_EXPR: 9414 op = DW_OP_neg; 9415 goto do_unop; 9416 9417 do_unop: 9418 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0); 9419 if (ret == 0) 9420 return 0; 9421 9422 add_loc_descr (&ret, new_loc_descr (op, 0, 0)); 9423 break; 9424 9425 case MIN_EXPR: 9426 case MAX_EXPR: 9427 { 9428 const enum tree_code code = 9429 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR; 9430 9431 loc = build3 (COND_EXPR, TREE_TYPE (loc), 9432 build2 (code, integer_type_node, 9433 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)), 9434 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0)); 9435 } 9436 9437 /* ... fall through ... */ 9438 9439 case COND_EXPR: 9440 { 9441 dw_loc_descr_ref lhs 9442 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0); 9443 dw_loc_descr_ref rhs 9444 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0); 9445 dw_loc_descr_ref bra_node, jump_node, tmp; 9446 9447 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0); 9448 if (ret == 0 || lhs == 0 || rhs == 0) 9449 return 0; 9450 9451 bra_node = new_loc_descr (DW_OP_bra, 0, 0); 9452 add_loc_descr (&ret, bra_node); 9453 9454 add_loc_descr (&ret, rhs); 9455 jump_node = new_loc_descr (DW_OP_skip, 0, 0); 9456 add_loc_descr (&ret, jump_node); 9457 9458 add_loc_descr (&ret, lhs); 9459 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc; 9460 bra_node->dw_loc_oprnd1.v.val_loc = lhs; 9461 9462 /* ??? Need a node to point the skip at. Use a nop. */ 9463 tmp = new_loc_descr (DW_OP_nop, 0, 0); 9464 add_loc_descr (&ret, tmp); 9465 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc; 9466 jump_node->dw_loc_oprnd1.v.val_loc = tmp; 9467 } 9468 break; 9469 9470 case FIX_TRUNC_EXPR: 9471 case FIX_CEIL_EXPR: 9472 case FIX_FLOOR_EXPR: 9473 case FIX_ROUND_EXPR: 9474 return 0; 9475 9476 default: 9477 /* Leave front-end specific codes as simply unknown. This comes 9478 up, for instance, with the C STMT_EXPR. */ 9479 if ((unsigned int) TREE_CODE (loc) 9480 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE) 9481 return 0; 9482 9483#ifdef ENABLE_CHECKING 9484 /* Otherwise this is a generic code; we should just lists all of 9485 these explicitly. We forgot one. */ 9486 gcc_unreachable (); 9487#else 9488 /* In a release build, we want to degrade gracefully: better to 9489 generate incomplete debugging information than to crash. */ 9490 return NULL; 9491#endif 9492 } 9493 9494 /* Show if we can't fill the request for an address. */ 9495 if (want_address && !have_address) 9496 return 0; 9497 9498 /* If we've got an address and don't want one, dereference. */ 9499 if (!want_address && have_address && ret) 9500 { 9501 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc)); 9502 9503 if (size > DWARF2_ADDR_SIZE || size == -1) 9504 return 0; 9505 else if (size == DWARF2_ADDR_SIZE) 9506 op = DW_OP_deref; 9507 else 9508 op = DW_OP_deref_size; 9509 9510 add_loc_descr (&ret, new_loc_descr (op, size, 0)); 9511 } 9512 9513 return ret; 9514} 9515 9516static inline dw_loc_descr_ref 9517loc_descriptor_from_tree (tree loc) 9518{ 9519 return loc_descriptor_from_tree_1 (loc, 2); 9520} 9521 9522/* Given a value, round it up to the lowest multiple of `boundary' 9523 which is not less than the value itself. */ 9524 9525static inline HOST_WIDE_INT 9526ceiling (HOST_WIDE_INT value, unsigned int boundary) 9527{ 9528 return (((value + boundary - 1) / boundary) * boundary); 9529} 9530 9531/* Given a pointer to what is assumed to be a FIELD_DECL node, return a 9532 pointer to the declared type for the relevant field variable, or return 9533 `integer_type_node' if the given node turns out to be an 9534 ERROR_MARK node. */ 9535 9536static inline tree 9537field_type (tree decl) 9538{ 9539 tree type; 9540 9541 if (TREE_CODE (decl) == ERROR_MARK) 9542 return integer_type_node; 9543 9544 type = DECL_BIT_FIELD_TYPE (decl); 9545 if (type == NULL_TREE) 9546 type = TREE_TYPE (decl); 9547 9548 return type; 9549} 9550 9551/* Given a pointer to a tree node, return the alignment in bits for 9552 it, or else return BITS_PER_WORD if the node actually turns out to 9553 be an ERROR_MARK node. */ 9554 9555static inline unsigned 9556simple_type_align_in_bits (tree type) 9557{ 9558 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD; 9559} 9560 9561static inline unsigned 9562simple_decl_align_in_bits (tree decl) 9563{ 9564 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD; 9565} 9566 9567/* Given a pointer to a FIELD_DECL, compute and return the byte offset of the 9568 lowest addressed byte of the "containing object" for the given FIELD_DECL, 9569 or return 0 if we are unable to determine what that offset is, either 9570 because the argument turns out to be a pointer to an ERROR_MARK node, or 9571 because the offset is actually variable. (We can't handle the latter case 9572 just yet). */ 9573 9574static HOST_WIDE_INT 9575field_byte_offset (tree decl) 9576{ 9577 unsigned int type_align_in_bits; 9578 unsigned int decl_align_in_bits; 9579 unsigned HOST_WIDE_INT type_size_in_bits; 9580 HOST_WIDE_INT object_offset_in_bits; 9581 tree type; 9582 tree field_size_tree; 9583 HOST_WIDE_INT bitpos_int; 9584 HOST_WIDE_INT deepest_bitpos; 9585 unsigned HOST_WIDE_INT field_size_in_bits; 9586 9587 if (TREE_CODE (decl) == ERROR_MARK) 9588 return 0; 9589 9590 gcc_assert (TREE_CODE (decl) == FIELD_DECL); 9591 9592 type = field_type (decl); 9593 field_size_tree = DECL_SIZE (decl); 9594 9595 /* The size could be unspecified if there was an error, or for 9596 a flexible array member. */ 9597 if (! field_size_tree) 9598 field_size_tree = bitsize_zero_node; 9599 9600 /* We cannot yet cope with fields whose positions are variable, so 9601 for now, when we see such things, we simply return 0. Someday, we may 9602 be able to handle such cases, but it will be damn difficult. */ 9603 if (! host_integerp (bit_position (decl), 0)) 9604 return 0; 9605 9606 bitpos_int = int_bit_position (decl); 9607 9608 /* If we don't know the size of the field, pretend it's a full word. */ 9609 if (host_integerp (field_size_tree, 1)) 9610 field_size_in_bits = tree_low_cst (field_size_tree, 1); 9611 else 9612 field_size_in_bits = BITS_PER_WORD; 9613 9614 type_size_in_bits = simple_type_size_in_bits (type); 9615 type_align_in_bits = simple_type_align_in_bits (type); 9616 decl_align_in_bits = simple_decl_align_in_bits (decl); 9617 9618 /* The GCC front-end doesn't make any attempt to keep track of the starting 9619 bit offset (relative to the start of the containing structure type) of the 9620 hypothetical "containing object" for a bit-field. Thus, when computing 9621 the byte offset value for the start of the "containing object" of a 9622 bit-field, we must deduce this information on our own. This can be rather 9623 tricky to do in some cases. For example, handling the following structure 9624 type definition when compiling for an i386/i486 target (which only aligns 9625 long long's to 32-bit boundaries) can be very tricky: 9626 9627 struct S { int field1; long long field2:31; }; 9628 9629 Fortunately, there is a simple rule-of-thumb which can be used in such 9630 cases. When compiling for an i386/i486, GCC will allocate 8 bytes for the 9631 structure shown above. It decides to do this based upon one simple rule 9632 for bit-field allocation. GCC allocates each "containing object" for each 9633 bit-field at the first (i.e. lowest addressed) legitimate alignment 9634 boundary (based upon the required minimum alignment for the declared type 9635 of the field) which it can possibly use, subject to the condition that 9636 there is still enough available space remaining in the containing object 9637 (when allocated at the selected point) to fully accommodate all of the 9638 bits of the bit-field itself. 9639 9640 This simple rule makes it obvious why GCC allocates 8 bytes for each 9641 object of the structure type shown above. When looking for a place to 9642 allocate the "containing object" for `field2', the compiler simply tries 9643 to allocate a 64-bit "containing object" at each successive 32-bit 9644 boundary (starting at zero) until it finds a place to allocate that 64- 9645 bit field such that at least 31 contiguous (and previously unallocated) 9646 bits remain within that selected 64 bit field. (As it turns out, for the 9647 example above, the compiler finds it is OK to allocate the "containing 9648 object" 64-bit field at bit-offset zero within the structure type.) 9649 9650 Here we attempt to work backwards from the limited set of facts we're 9651 given, and we try to deduce from those facts, where GCC must have believed 9652 that the containing object started (within the structure type). The value 9653 we deduce is then used (by the callers of this routine) to generate 9654 DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields 9655 and, in the case of DW_AT_location, regular fields as well). */ 9656 9657 /* Figure out the bit-distance from the start of the structure to the 9658 "deepest" bit of the bit-field. */ 9659 deepest_bitpos = bitpos_int + field_size_in_bits; 9660 9661 /* This is the tricky part. Use some fancy footwork to deduce where the 9662 lowest addressed bit of the containing object must be. */ 9663 object_offset_in_bits = deepest_bitpos - type_size_in_bits; 9664 9665 /* Round up to type_align by default. This works best for bitfields. */ 9666 object_offset_in_bits += type_align_in_bits - 1; 9667 object_offset_in_bits /= type_align_in_bits; 9668 object_offset_in_bits *= type_align_in_bits; 9669 9670 if (object_offset_in_bits > bitpos_int) 9671 { 9672 /* Sigh, the decl must be packed. */ 9673 object_offset_in_bits = deepest_bitpos - type_size_in_bits; 9674 9675 /* Round up to decl_align instead. */ 9676 object_offset_in_bits += decl_align_in_bits - 1; 9677 object_offset_in_bits /= decl_align_in_bits; 9678 object_offset_in_bits *= decl_align_in_bits; 9679 } 9680 9681 return object_offset_in_bits / BITS_PER_UNIT; 9682} 9683 9684/* The following routines define various Dwarf attributes and any data 9685 associated with them. */ 9686 9687/* Add a location description attribute value to a DIE. 9688 9689 This emits location attributes suitable for whole variables and 9690 whole parameters. Note that the location attributes for struct fields are 9691 generated by the routine `data_member_location_attribute' below. */ 9692 9693static inline void 9694add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind, 9695 dw_loc_descr_ref descr) 9696{ 9697 if (descr != 0) 9698 add_AT_loc (die, attr_kind, descr); 9699} 9700 9701/* Attach the specialized form of location attribute used for data members of 9702 struct and union types. In the special case of a FIELD_DECL node which 9703 represents a bit-field, the "offset" part of this special location 9704 descriptor must indicate the distance in bytes from the lowest-addressed 9705 byte of the containing struct or union type to the lowest-addressed byte of 9706 the "containing object" for the bit-field. (See the `field_byte_offset' 9707 function above). 9708 9709 For any given bit-field, the "containing object" is a hypothetical object 9710 (of some integral or enum type) within which the given bit-field lives. The 9711 type of this hypothetical "containing object" is always the same as the 9712 declared type of the individual bit-field itself (for GCC anyway... the 9713 DWARF spec doesn't actually mandate this). Note that it is the size (in 9714 bytes) of the hypothetical "containing object" which will be given in the 9715 DW_AT_byte_size attribute for this bit-field. (See the 9716 `byte_size_attribute' function below.) It is also used when calculating the 9717 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute' 9718 function below.) */ 9719 9720static void 9721add_data_member_location_attribute (dw_die_ref die, tree decl) 9722{ 9723 HOST_WIDE_INT offset; 9724 dw_loc_descr_ref loc_descr = 0; 9725 9726 if (TREE_CODE (decl) == TREE_BINFO) 9727 { 9728 /* We're working on the TAG_inheritance for a base class. */ 9729 if (BINFO_VIRTUAL_P (decl) && is_cxx ()) 9730 { 9731 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they 9732 aren't at a fixed offset from all (sub)objects of the same 9733 type. We need to extract the appropriate offset from our 9734 vtable. The following dwarf expression means 9735 9736 BaseAddr = ObAddr + *((*ObAddr) - Offset) 9737 9738 This is specific to the V3 ABI, of course. */ 9739 9740 dw_loc_descr_ref tmp; 9741 9742 /* Make a copy of the object address. */ 9743 tmp = new_loc_descr (DW_OP_dup, 0, 0); 9744 add_loc_descr (&loc_descr, tmp); 9745 9746 /* Extract the vtable address. */ 9747 tmp = new_loc_descr (DW_OP_deref, 0, 0); 9748 add_loc_descr (&loc_descr, tmp); 9749 9750 /* Calculate the address of the offset. */ 9751 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0); 9752 gcc_assert (offset < 0); 9753 9754 tmp = int_loc_descriptor (-offset); 9755 add_loc_descr (&loc_descr, tmp); 9756 tmp = new_loc_descr (DW_OP_minus, 0, 0); 9757 add_loc_descr (&loc_descr, tmp); 9758 9759 /* Extract the offset. */ 9760 tmp = new_loc_descr (DW_OP_deref, 0, 0); 9761 add_loc_descr (&loc_descr, tmp); 9762 9763 /* Add it to the object address. */ 9764 tmp = new_loc_descr (DW_OP_plus, 0, 0); 9765 add_loc_descr (&loc_descr, tmp); 9766 } 9767 else 9768 offset = tree_low_cst (BINFO_OFFSET (decl), 0); 9769 } 9770 else 9771 offset = field_byte_offset (decl); 9772 9773 if (! loc_descr) 9774 { 9775 enum dwarf_location_atom op; 9776 9777 /* The DWARF2 standard says that we should assume that the structure 9778 address is already on the stack, so we can specify a structure field 9779 address by using DW_OP_plus_uconst. */ 9780 9781#ifdef MIPS_DEBUGGING_INFO 9782 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst 9783 operator correctly. It works only if we leave the offset on the 9784 stack. */ 9785 op = DW_OP_constu; 9786#else 9787 op = DW_OP_plus_uconst; 9788#endif 9789 9790 loc_descr = new_loc_descr (op, offset, 0); 9791 } 9792 9793 add_AT_loc (die, DW_AT_data_member_location, loc_descr); 9794} 9795 9796/* Writes integer values to dw_vec_const array. */ 9797 9798static void 9799insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest) 9800{ 9801 while (size != 0) 9802 { 9803 *dest++ = val & 0xff; 9804 val >>= 8; 9805 --size; 9806 } 9807} 9808 9809/* Reads integers from dw_vec_const array. Inverse of insert_int. */ 9810 9811static HOST_WIDE_INT 9812extract_int (const unsigned char *src, unsigned int size) 9813{ 9814 HOST_WIDE_INT val = 0; 9815 9816 src += size; 9817 while (size != 0) 9818 { 9819 val <<= 8; 9820 val |= *--src & 0xff; 9821 --size; 9822 } 9823 return val; 9824} 9825 9826/* Writes floating point values to dw_vec_const array. */ 9827 9828static void 9829insert_float (rtx rtl, unsigned char *array) 9830{ 9831 REAL_VALUE_TYPE rv; 9832 long val[4]; 9833 int i; 9834 9835 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl); 9836 real_to_target (val, &rv, GET_MODE (rtl)); 9837 9838 /* real_to_target puts 32-bit pieces in each long. Pack them. */ 9839 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++) 9840 { 9841 insert_int (val[i], 4, array); 9842 array += 4; 9843 } 9844} 9845 9846/* Attach a DW_AT_const_value attribute for a variable or a parameter which 9847 does not have a "location" either in memory or in a register. These 9848 things can arise in GNU C when a constant is passed as an actual parameter 9849 to an inlined function. They can also arise in C++ where declared 9850 constants do not necessarily get memory "homes". */ 9851 9852static void 9853add_const_value_attribute (dw_die_ref die, rtx rtl) 9854{ 9855 switch (GET_CODE (rtl)) 9856 { 9857 case CONST_INT: 9858 { 9859 HOST_WIDE_INT val = INTVAL (rtl); 9860 9861 if (val < 0) 9862 add_AT_int (die, DW_AT_const_value, val); 9863 else 9864 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val); 9865 } 9866 break; 9867 9868 case CONST_DOUBLE: 9869 /* Note that a CONST_DOUBLE rtx could represent either an integer or a 9870 floating-point constant. A CONST_DOUBLE is used whenever the 9871 constant requires more than one word in order to be adequately 9872 represented. We output CONST_DOUBLEs as blocks. */ 9873 { 9874 enum machine_mode mode = GET_MODE (rtl); 9875 9876 if (SCALAR_FLOAT_MODE_P (mode)) 9877 { 9878 unsigned int length = GET_MODE_SIZE (mode); 9879 unsigned char *array = ggc_alloc (length); 9880 9881 insert_float (rtl, array); 9882 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array); 9883 } 9884 else 9885 { 9886 /* ??? We really should be using HOST_WIDE_INT throughout. */ 9887 gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT); 9888 9889 add_AT_long_long (die, DW_AT_const_value, 9890 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl)); 9891 } 9892 } 9893 break; 9894 9895 case CONST_VECTOR: 9896 { 9897 enum machine_mode mode = GET_MODE (rtl); 9898 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode); 9899 unsigned int length = CONST_VECTOR_NUNITS (rtl); 9900 unsigned char *array = ggc_alloc (length * elt_size); 9901 unsigned int i; 9902 unsigned char *p; 9903 9904 switch (GET_MODE_CLASS (mode)) 9905 { 9906 case MODE_VECTOR_INT: 9907 for (i = 0, p = array; i < length; i++, p += elt_size) 9908 { 9909 rtx elt = CONST_VECTOR_ELT (rtl, i); 9910 HOST_WIDE_INT lo, hi; 9911 9912 switch (GET_CODE (elt)) 9913 { 9914 case CONST_INT: 9915 lo = INTVAL (elt); 9916 hi = -(lo < 0); 9917 break; 9918 9919 case CONST_DOUBLE: 9920 lo = CONST_DOUBLE_LOW (elt); 9921 hi = CONST_DOUBLE_HIGH (elt); 9922 break; 9923 9924 default: 9925 gcc_unreachable (); 9926 } 9927 9928 if (elt_size <= sizeof (HOST_WIDE_INT)) 9929 insert_int (lo, elt_size, p); 9930 else 9931 { 9932 unsigned char *p0 = p; 9933 unsigned char *p1 = p + sizeof (HOST_WIDE_INT); 9934 9935 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT)); 9936 if (WORDS_BIG_ENDIAN) 9937 { 9938 p0 = p1; 9939 p1 = p; 9940 } 9941 insert_int (lo, sizeof (HOST_WIDE_INT), p0); 9942 insert_int (hi, sizeof (HOST_WIDE_INT), p1); 9943 } 9944 } 9945 break; 9946 9947 case MODE_VECTOR_FLOAT: 9948 for (i = 0, p = array; i < length; i++, p += elt_size) 9949 { 9950 rtx elt = CONST_VECTOR_ELT (rtl, i); 9951 insert_float (elt, p); 9952 } 9953 break; 9954 9955 default: 9956 gcc_unreachable (); 9957 } 9958 9959 add_AT_vec (die, DW_AT_const_value, length, elt_size, array); 9960 } 9961 break; 9962 9963 case CONST_STRING: 9964 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0)); 9965 break; 9966 9967 case SYMBOL_REF: 9968 case LABEL_REF: 9969 case CONST: 9970 add_AT_addr (die, DW_AT_const_value, rtl); 9971 VEC_safe_push (rtx, gc, used_rtx_array, rtl); 9972 break; 9973 9974 case PLUS: 9975 /* In cases where an inlined instance of an inline function is passed 9976 the address of an `auto' variable (which is local to the caller) we 9977 can get a situation where the DECL_RTL of the artificial local 9978 variable (for the inlining) which acts as a stand-in for the 9979 corresponding formal parameter (of the inline function) will look 9980 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not 9981 exactly a compile-time constant expression, but it isn't the address 9982 of the (artificial) local variable either. Rather, it represents the 9983 *value* which the artificial local variable always has during its 9984 lifetime. We currently have no way to represent such quasi-constant 9985 values in Dwarf, so for now we just punt and generate nothing. */ 9986 break; 9987 9988 default: 9989 /* No other kinds of rtx should be possible here. */ 9990 gcc_unreachable (); 9991 } 9992 9993} 9994 9995/* Determine whether the evaluation of EXPR references any variables 9996 or functions which aren't otherwise used (and therefore may not be 9997 output). */ 9998static tree 9999reference_to_unused (tree * tp, int * walk_subtrees, 10000 void * data ATTRIBUTE_UNUSED) 10001{ 10002 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp)) 10003 *walk_subtrees = 0; 10004 10005 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp) 10006 && ! TREE_ASM_WRITTEN (*tp)) 10007 return *tp; 10008 else if (!flag_unit_at_a_time) 10009 return NULL_TREE; 10010 else if (!cgraph_global_info_ready 10011 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL)) 10012 return *tp; 10013 else if (DECL_P (*tp) && TREE_CODE (*tp) == VAR_DECL) 10014 { 10015 struct cgraph_varpool_node *node = cgraph_varpool_node (*tp); 10016 if (!node->needed) 10017 return *tp; 10018 } 10019 else if (DECL_P (*tp) && TREE_CODE (*tp) == FUNCTION_DECL 10020 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp))) 10021 { 10022 struct cgraph_node *node = cgraph_node (*tp); 10023 if (!node->output) 10024 return *tp; 10025 } 10026 10027 return NULL_TREE; 10028} 10029 10030/* Generate an RTL constant from a decl initializer INIT with decl type TYPE, 10031 for use in a later add_const_value_attribute call. */ 10032 10033static rtx 10034rtl_for_decl_init (tree init, tree type) 10035{ 10036 rtx rtl = NULL_RTX; 10037 10038 /* If a variable is initialized with a string constant without embedded 10039 zeros, build CONST_STRING. */ 10040 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE) 10041 { 10042 tree enttype = TREE_TYPE (type); 10043 tree domain = TYPE_DOMAIN (type); 10044 enum machine_mode mode = TYPE_MODE (enttype); 10045 10046 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1 10047 && domain 10048 && integer_zerop (TYPE_MIN_VALUE (domain)) 10049 && compare_tree_int (TYPE_MAX_VALUE (domain), 10050 TREE_STRING_LENGTH (init) - 1) == 0 10051 && ((size_t) TREE_STRING_LENGTH (init) 10052 == strlen (TREE_STRING_POINTER (init)) + 1)) 10053 rtl = gen_rtx_CONST_STRING (VOIDmode, 10054 ggc_strdup (TREE_STRING_POINTER (init))); 10055 } 10056 /* Other aggregates, and complex values, could be represented using 10057 CONCAT: FIXME! */ 10058 else if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE) 10059 ; 10060 /* Vectors only work if their mode is supported by the target. 10061 FIXME: generic vectors ought to work too. */ 10062 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_MODE (type) == BLKmode) 10063 ; 10064 /* If the initializer is something that we know will expand into an 10065 immediate RTL constant, expand it now. We must be careful not to 10066 reference variables which won't be output. */ 10067 else if (initializer_constant_valid_p (init, type) 10068 && ! walk_tree (&init, reference_to_unused, NULL, NULL)) 10069 { 10070 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if 10071 possible. */ 10072 if (TREE_CODE (type) == VECTOR_TYPE) 10073 switch (TREE_CODE (init)) 10074 { 10075 case VECTOR_CST: 10076 break; 10077 case CONSTRUCTOR: 10078 if (TREE_CONSTANT (init)) 10079 { 10080 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (init); 10081 bool constant_p = true; 10082 tree value; 10083 unsigned HOST_WIDE_INT ix; 10084 10085 /* Even when ctor is constant, it might contain non-*_CST 10086 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't 10087 belong into VECTOR_CST nodes. */ 10088 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value) 10089 if (!CONSTANT_CLASS_P (value)) 10090 { 10091 constant_p = false; 10092 break; 10093 } 10094 10095 if (constant_p) 10096 { 10097 init = build_vector_from_ctor (type, elts); 10098 break; 10099 } 10100 } 10101 /* FALLTHRU */ 10102 10103 default: 10104 return NULL; 10105 } 10106 10107 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER); 10108 10109 /* If expand_expr returns a MEM, it wasn't immediate. */ 10110 gcc_assert (!rtl || !MEM_P (rtl)); 10111 } 10112 10113 return rtl; 10114} 10115 10116/* Generate RTL for the variable DECL to represent its location. */ 10117 10118static rtx 10119rtl_for_decl_location (tree decl) 10120{ 10121 rtx rtl; 10122 10123 /* Here we have to decide where we are going to say the parameter "lives" 10124 (as far as the debugger is concerned). We only have a couple of 10125 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL. 10126 10127 DECL_RTL normally indicates where the parameter lives during most of the 10128 activation of the function. If optimization is enabled however, this 10129 could be either NULL or else a pseudo-reg. Both of those cases indicate 10130 that the parameter doesn't really live anywhere (as far as the code 10131 generation parts of GCC are concerned) during most of the function's 10132 activation. That will happen (for example) if the parameter is never 10133 referenced within the function. 10134 10135 We could just generate a location descriptor here for all non-NULL 10136 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be 10137 a little nicer than that if we also consider DECL_INCOMING_RTL in cases 10138 where DECL_RTL is NULL or is a pseudo-reg. 10139 10140 Note however that we can only get away with using DECL_INCOMING_RTL as 10141 a backup substitute for DECL_RTL in certain limited cases. In cases 10142 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl), 10143 we can be sure that the parameter was passed using the same type as it is 10144 declared to have within the function, and that its DECL_INCOMING_RTL 10145 points us to a place where a value of that type is passed. 10146 10147 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different, 10148 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL 10149 because in these cases DECL_INCOMING_RTL points us to a value of some 10150 type which is *different* from the type of the parameter itself. Thus, 10151 if we tried to use DECL_INCOMING_RTL to generate a location attribute in 10152 such cases, the debugger would end up (for example) trying to fetch a 10153 `float' from a place which actually contains the first part of a 10154 `double'. That would lead to really incorrect and confusing 10155 output at debug-time. 10156 10157 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL 10158 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There 10159 are a couple of exceptions however. On little-endian machines we can 10160 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is 10161 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is 10162 an integral type that is smaller than TREE_TYPE (decl). These cases arise 10163 when (on a little-endian machine) a non-prototyped function has a 10164 parameter declared to be of type `short' or `char'. In such cases, 10165 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will 10166 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the 10167 passed `int' value. If the debugger then uses that address to fetch 10168 a `short' or a `char' (on a little-endian machine) the result will be 10169 the correct data, so we allow for such exceptional cases below. 10170 10171 Note that our goal here is to describe the place where the given formal 10172 parameter lives during most of the function's activation (i.e. between the 10173 end of the prologue and the start of the epilogue). We'll do that as best 10174 as we can. Note however that if the given formal parameter is modified 10175 sometime during the execution of the function, then a stack backtrace (at 10176 debug-time) will show the function as having been called with the *new* 10177 value rather than the value which was originally passed in. This happens 10178 rarely enough that it is not a major problem, but it *is* a problem, and 10179 I'd like to fix it. 10180 10181 A future version of dwarf2out.c may generate two additional attributes for 10182 any given DW_TAG_formal_parameter DIE which will describe the "passed 10183 type" and the "passed location" for the given formal parameter in addition 10184 to the attributes we now generate to indicate the "declared type" and the 10185 "active location" for each parameter. This additional set of attributes 10186 could be used by debuggers for stack backtraces. Separately, note that 10187 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also. 10188 This happens (for example) for inlined-instances of inline function formal 10189 parameters which are never referenced. This really shouldn't be 10190 happening. All PARM_DECL nodes should get valid non-NULL 10191 DECL_INCOMING_RTL values. FIXME. */ 10192 10193 /* Use DECL_RTL as the "location" unless we find something better. */ 10194 rtl = DECL_RTL_IF_SET (decl); 10195 10196 /* When generating abstract instances, ignore everything except 10197 constants, symbols living in memory, and symbols living in 10198 fixed registers. */ 10199 if (! reload_completed) 10200 { 10201 if (rtl 10202 && (CONSTANT_P (rtl) 10203 || (MEM_P (rtl) 10204 && CONSTANT_P (XEXP (rtl, 0))) 10205 || (REG_P (rtl) 10206 && TREE_CODE (decl) == VAR_DECL 10207 && TREE_STATIC (decl)))) 10208 { 10209 rtl = targetm.delegitimize_address (rtl); 10210 return rtl; 10211 } 10212 rtl = NULL_RTX; 10213 } 10214 else if (TREE_CODE (decl) == PARM_DECL) 10215 { 10216 if (rtl == NULL_RTX || is_pseudo_reg (rtl)) 10217 { 10218 tree declared_type = TREE_TYPE (decl); 10219 tree passed_type = DECL_ARG_TYPE (decl); 10220 enum machine_mode dmode = TYPE_MODE (declared_type); 10221 enum machine_mode pmode = TYPE_MODE (passed_type); 10222 10223 /* This decl represents a formal parameter which was optimized out. 10224 Note that DECL_INCOMING_RTL may be NULL in here, but we handle 10225 all cases where (rtl == NULL_RTX) just below. */ 10226 if (dmode == pmode) 10227 rtl = DECL_INCOMING_RTL (decl); 10228 else if (SCALAR_INT_MODE_P (dmode) 10229 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode) 10230 && DECL_INCOMING_RTL (decl)) 10231 { 10232 rtx inc = DECL_INCOMING_RTL (decl); 10233 if (REG_P (inc)) 10234 rtl = inc; 10235 else if (MEM_P (inc)) 10236 { 10237 if (BYTES_BIG_ENDIAN) 10238 rtl = adjust_address_nv (inc, dmode, 10239 GET_MODE_SIZE (pmode) 10240 - GET_MODE_SIZE (dmode)); 10241 else 10242 rtl = inc; 10243 } 10244 } 10245 } 10246 10247 /* If the parm was passed in registers, but lives on the stack, then 10248 make a big endian correction if the mode of the type of the 10249 parameter is not the same as the mode of the rtl. */ 10250 /* ??? This is the same series of checks that are made in dbxout.c before 10251 we reach the big endian correction code there. It isn't clear if all 10252 of these checks are necessary here, but keeping them all is the safe 10253 thing to do. */ 10254 else if (MEM_P (rtl) 10255 && XEXP (rtl, 0) != const0_rtx 10256 && ! CONSTANT_P (XEXP (rtl, 0)) 10257 /* Not passed in memory. */ 10258 && !MEM_P (DECL_INCOMING_RTL (decl)) 10259 /* Not passed by invisible reference. */ 10260 && (!REG_P (XEXP (rtl, 0)) 10261 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM 10262 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM 10263#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM 10264 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM 10265#endif 10266 ) 10267 /* Big endian correction check. */ 10268 && BYTES_BIG_ENDIAN 10269 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl) 10270 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))) 10271 < UNITS_PER_WORD)) 10272 { 10273 int offset = (UNITS_PER_WORD 10274 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))); 10275 10276 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)), 10277 plus_constant (XEXP (rtl, 0), offset)); 10278 } 10279 } 10280 else if (TREE_CODE (decl) == VAR_DECL 10281 && rtl 10282 && MEM_P (rtl) 10283 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl)) 10284 && BYTES_BIG_ENDIAN) 10285 { 10286 int rsize = GET_MODE_SIZE (GET_MODE (rtl)); 10287 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))); 10288 10289 /* If a variable is declared "register" yet is smaller than 10290 a register, then if we store the variable to memory, it 10291 looks like we're storing a register-sized value, when in 10292 fact we are not. We need to adjust the offset of the 10293 storage location to reflect the actual value's bytes, 10294 else gdb will not be able to display it. */ 10295 if (rsize > dsize) 10296 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)), 10297 plus_constant (XEXP (rtl, 0), rsize-dsize)); 10298 } 10299 10300 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant, 10301 and will have been substituted directly into all expressions that use it. 10302 C does not have such a concept, but C++ and other languages do. */ 10303 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl)) 10304 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl)); 10305 10306 if (rtl) 10307 rtl = targetm.delegitimize_address (rtl); 10308 10309 /* If we don't look past the constant pool, we risk emitting a 10310 reference to a constant pool entry that isn't referenced from 10311 code, and thus is not emitted. */ 10312 if (rtl) 10313 rtl = avoid_constant_pool_reference (rtl); 10314 10315 return rtl; 10316} 10317 10318/* We need to figure out what section we should use as the base for the 10319 address ranges where a given location is valid. 10320 1. If this particular DECL has a section associated with it, use that. 10321 2. If this function has a section associated with it, use that. 10322 3. Otherwise, use the text section. 10323 XXX: If you split a variable across multiple sections, we won't notice. */ 10324 10325static const char * 10326secname_for_decl (tree decl) 10327{ 10328 const char *secname; 10329 10330 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl)) 10331 { 10332 tree sectree = DECL_SECTION_NAME (decl); 10333 secname = TREE_STRING_POINTER (sectree); 10334 } 10335 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl)) 10336 { 10337 tree sectree = DECL_SECTION_NAME (current_function_decl); 10338 secname = TREE_STRING_POINTER (sectree); 10339 } 10340 else if (cfun && in_cold_section_p) 10341 secname = cfun->cold_section_label; 10342 else 10343 secname = text_section_label; 10344 10345 return secname; 10346} 10347 10348/* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value 10349 data attribute for a variable or a parameter. We generate the 10350 DW_AT_const_value attribute only in those cases where the given variable 10351 or parameter does not have a true "location" either in memory or in a 10352 register. This can happen (for example) when a constant is passed as an 10353 actual argument in a call to an inline function. (It's possible that 10354 these things can crop up in other ways also.) Note that one type of 10355 constant value which can be passed into an inlined function is a constant 10356 pointer. This can happen for example if an actual argument in an inlined 10357 function call evaluates to a compile-time constant address. */ 10358 10359static void 10360add_location_or_const_value_attribute (dw_die_ref die, tree decl, 10361 enum dwarf_attribute attr) 10362{ 10363 rtx rtl; 10364 dw_loc_descr_ref descr; 10365 var_loc_list *loc_list; 10366 struct var_loc_node *node; 10367 if (TREE_CODE (decl) == ERROR_MARK) 10368 return; 10369 10370 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL 10371 || TREE_CODE (decl) == RESULT_DECL); 10372 10373 /* See if we possibly have multiple locations for this variable. */ 10374 loc_list = lookup_decl_loc (decl); 10375 10376 /* If it truly has multiple locations, the first and last node will 10377 differ. */ 10378 if (loc_list && loc_list->first != loc_list->last) 10379 { 10380 const char *endname, *secname; 10381 dw_loc_list_ref list; 10382 rtx varloc; 10383 10384 /* Now that we know what section we are using for a base, 10385 actually construct the list of locations. 10386 The first location information is what is passed to the 10387 function that creates the location list, and the remaining 10388 locations just get added on to that list. 10389 Note that we only know the start address for a location 10390 (IE location changes), so to build the range, we use 10391 the range [current location start, next location start]. 10392 This means we have to special case the last node, and generate 10393 a range of [last location start, end of function label]. */ 10394 10395 node = loc_list->first; 10396 varloc = NOTE_VAR_LOCATION (node->var_loc_note); 10397 secname = secname_for_decl (decl); 10398 10399 list = new_loc_list (loc_descriptor (varloc), 10400 node->label, node->next->label, secname, 1); 10401 node = node->next; 10402 10403 for (; node->next; node = node->next) 10404 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX) 10405 { 10406 /* The variable has a location between NODE->LABEL and 10407 NODE->NEXT->LABEL. */ 10408 varloc = NOTE_VAR_LOCATION (node->var_loc_note); 10409 add_loc_descr_to_loc_list (&list, loc_descriptor (varloc), 10410 node->label, node->next->label, secname); 10411 } 10412 10413 /* If the variable has a location at the last label 10414 it keeps its location until the end of function. */ 10415 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX) 10416 { 10417 char label_id[MAX_ARTIFICIAL_LABEL_BYTES]; 10418 10419 varloc = NOTE_VAR_LOCATION (node->var_loc_note); 10420 if (!current_function_decl) 10421 endname = text_end_label; 10422 else 10423 { 10424 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL, 10425 current_function_funcdef_no); 10426 endname = ggc_strdup (label_id); 10427 } 10428 add_loc_descr_to_loc_list (&list, loc_descriptor (varloc), 10429 node->label, endname, secname); 10430 } 10431 10432 /* Finally, add the location list to the DIE, and we are done. */ 10433 add_AT_loc_list (die, attr, list); 10434 return; 10435 } 10436 10437 /* Try to get some constant RTL for this decl, and use that as the value of 10438 the location. */ 10439 10440 rtl = rtl_for_decl_location (decl); 10441 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)) 10442 { 10443 add_const_value_attribute (die, rtl); 10444 return; 10445 } 10446 10447 /* If we have tried to generate the location otherwise, and it 10448 didn't work out (we wouldn't be here if we did), and we have a one entry 10449 location list, try generating a location from that. */ 10450 if (loc_list && loc_list->first) 10451 { 10452 node = loc_list->first; 10453 descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note)); 10454 if (descr) 10455 { 10456 add_AT_location_description (die, attr, descr); 10457 return; 10458 } 10459 } 10460 10461 /* We couldn't get any rtl, so try directly generating the location 10462 description from the tree. */ 10463 descr = loc_descriptor_from_tree (decl); 10464 if (descr) 10465 { 10466 add_AT_location_description (die, attr, descr); 10467 return; 10468 } 10469 /* None of that worked, so it must not really have a location; 10470 try adding a constant value attribute from the DECL_INITIAL. */ 10471 tree_add_const_value_attribute (die, decl); 10472} 10473 10474/* If we don't have a copy of this variable in memory for some reason (such 10475 as a C++ member constant that doesn't have an out-of-line definition), 10476 we should tell the debugger about the constant value. */ 10477 10478static void 10479tree_add_const_value_attribute (dw_die_ref var_die, tree decl) 10480{ 10481 tree init = DECL_INITIAL (decl); 10482 tree type = TREE_TYPE (decl); 10483 rtx rtl; 10484 10485 if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init) 10486 /* OK */; 10487 else 10488 return; 10489 10490 rtl = rtl_for_decl_init (init, type); 10491 if (rtl) 10492 add_const_value_attribute (var_die, rtl); 10493} 10494 10495/* Convert the CFI instructions for the current function into a 10496 location list. This is used for DW_AT_frame_base when we targeting 10497 a dwarf2 consumer that does not support the dwarf3 10498 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA 10499 expressions. */ 10500 10501static dw_loc_list_ref 10502convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset) 10503{ 10504 dw_fde_ref fde; 10505 dw_loc_list_ref list, *list_tail; 10506 dw_cfi_ref cfi; 10507 dw_cfa_location last_cfa, next_cfa; 10508 const char *start_label, *last_label, *section; 10509 10510 fde = &fde_table[fde_table_in_use - 1]; 10511 10512 section = secname_for_decl (current_function_decl); 10513 list_tail = &list; 10514 list = NULL; 10515 10516 next_cfa.reg = INVALID_REGNUM; 10517 next_cfa.offset = 0; 10518 next_cfa.indirect = 0; 10519 next_cfa.base_offset = 0; 10520 10521 start_label = fde->dw_fde_begin; 10522 10523 /* ??? Bald assumption that the CIE opcode list does not contain 10524 advance opcodes. */ 10525 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next) 10526 lookup_cfa_1 (cfi, &next_cfa); 10527 10528 last_cfa = next_cfa; 10529 last_label = start_label; 10530 10531 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next) 10532 switch (cfi->dw_cfi_opc) 10533 { 10534 case DW_CFA_set_loc: 10535 case DW_CFA_advance_loc1: 10536 case DW_CFA_advance_loc2: 10537 case DW_CFA_advance_loc4: 10538 if (!cfa_equal_p (&last_cfa, &next_cfa)) 10539 { 10540 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset), 10541 start_label, last_label, section, 10542 list == NULL); 10543 10544 list_tail = &(*list_tail)->dw_loc_next; 10545 last_cfa = next_cfa; 10546 start_label = last_label; 10547 } 10548 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; 10549 break; 10550 10551 case DW_CFA_advance_loc: 10552 /* The encoding is complex enough that we should never emit this. */ 10553 case DW_CFA_remember_state: 10554 case DW_CFA_restore_state: 10555 /* We don't handle these two in this function. It would be possible 10556 if it were to be required. */ 10557 gcc_unreachable (); 10558 10559 default: 10560 lookup_cfa_1 (cfi, &next_cfa); 10561 break; 10562 } 10563 10564 if (!cfa_equal_p (&last_cfa, &next_cfa)) 10565 { 10566 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset), 10567 start_label, last_label, section, 10568 list == NULL); 10569 list_tail = &(*list_tail)->dw_loc_next; 10570 start_label = last_label; 10571 } 10572 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset), 10573 start_label, fde->dw_fde_end, section, 10574 list == NULL); 10575 10576 return list; 10577} 10578 10579/* Compute a displacement from the "steady-state frame pointer" to the 10580 frame base (often the same as the CFA), and store it in 10581 frame_pointer_fb_offset. OFFSET is added to the displacement 10582 before the latter is negated. */ 10583 10584static void 10585compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset) 10586{ 10587 rtx reg, elim; 10588 10589#ifdef FRAME_POINTER_CFA_OFFSET 10590 reg = frame_pointer_rtx; 10591 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl); 10592#else 10593 reg = arg_pointer_rtx; 10594 offset += ARG_POINTER_CFA_OFFSET (current_function_decl); 10595#endif 10596 10597 elim = eliminate_regs (reg, VOIDmode, NULL_RTX); 10598 if (GET_CODE (elim) == PLUS) 10599 { 10600 offset += INTVAL (XEXP (elim, 1)); 10601 elim = XEXP (elim, 0); 10602 } 10603 gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx 10604 : stack_pointer_rtx)); 10605 10606 frame_pointer_fb_offset = -offset; 10607} 10608 10609/* Generate a DW_AT_name attribute given some string value to be included as 10610 the value of the attribute. */ 10611 10612static void 10613add_name_attribute (dw_die_ref die, const char *name_string) 10614{ 10615 if (name_string != NULL && *name_string != 0) 10616 { 10617 if (demangle_name_func) 10618 name_string = (*demangle_name_func) (name_string); 10619 10620 add_AT_string (die, DW_AT_name, name_string); 10621 } 10622} 10623 10624/* Generate a DW_AT_comp_dir attribute for DIE. */ 10625 10626static void 10627add_comp_dir_attribute (dw_die_ref die) 10628{ 10629 const char *wd = get_src_pwd (); 10630 if (wd != NULL) 10631 add_AT_string (die, DW_AT_comp_dir, wd); 10632} 10633 10634/* Given a tree node describing an array bound (either lower or upper) output 10635 a representation for that bound. */ 10636 10637static void 10638add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound) 10639{ 10640 switch (TREE_CODE (bound)) 10641 { 10642 case ERROR_MARK: 10643 return; 10644 10645 /* All fixed-bounds are represented by INTEGER_CST nodes. */ 10646 case INTEGER_CST: 10647 if (! host_integerp (bound, 0) 10648 || (bound_attr == DW_AT_lower_bound 10649 && (((is_c_family () || is_java ()) && integer_zerop (bound)) 10650 || (is_fortran () && integer_onep (bound))))) 10651 /* Use the default. */ 10652 ; 10653 else 10654 add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0)); 10655 break; 10656 10657 case CONVERT_EXPR: 10658 case NOP_EXPR: 10659 case NON_LVALUE_EXPR: 10660 case VIEW_CONVERT_EXPR: 10661 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0)); 10662 break; 10663 10664 case SAVE_EXPR: 10665 break; 10666 10667 case VAR_DECL: 10668 case PARM_DECL: 10669 case RESULT_DECL: 10670 { 10671 dw_die_ref decl_die = lookup_decl_die (bound); 10672 10673 /* ??? Can this happen, or should the variable have been bound 10674 first? Probably it can, since I imagine that we try to create 10675 the types of parameters in the order in which they exist in 10676 the list, and won't have created a forward reference to a 10677 later parameter. */ 10678 if (decl_die != NULL) 10679 add_AT_die_ref (subrange_die, bound_attr, decl_die); 10680 break; 10681 } 10682 10683 default: 10684 { 10685 /* Otherwise try to create a stack operation procedure to 10686 evaluate the value of the array bound. */ 10687 10688 dw_die_ref ctx, decl_die; 10689 dw_loc_descr_ref loc; 10690 10691 loc = loc_descriptor_from_tree (bound); 10692 if (loc == NULL) 10693 break; 10694 10695 if (current_function_decl == 0) 10696 ctx = comp_unit_die; 10697 else 10698 ctx = lookup_decl_die (current_function_decl); 10699 10700 decl_die = new_die (DW_TAG_variable, ctx, bound); 10701 add_AT_flag (decl_die, DW_AT_artificial, 1); 10702 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx); 10703 add_AT_loc (decl_die, DW_AT_location, loc); 10704 10705 add_AT_die_ref (subrange_die, bound_attr, decl_die); 10706 break; 10707 } 10708 } 10709} 10710 10711/* Note that the block of subscript information for an array type also 10712 includes information about the element type of type given array type. */ 10713 10714static void 10715add_subscript_info (dw_die_ref type_die, tree type) 10716{ 10717#ifndef MIPS_DEBUGGING_INFO 10718 unsigned dimension_number; 10719#endif 10720 tree lower, upper; 10721 dw_die_ref subrange_die; 10722 10723 /* The GNU compilers represent multidimensional array types as sequences of 10724 one dimensional array types whose element types are themselves array 10725 types. Here we squish that down, so that each multidimensional array 10726 type gets only one array_type DIE in the Dwarf debugging info. The draft 10727 Dwarf specification say that we are allowed to do this kind of 10728 compression in C (because there is no difference between an array or 10729 arrays and a multidimensional array in C) but for other source languages 10730 (e.g. Ada) we probably shouldn't do this. */ 10731 10732 /* ??? The SGI dwarf reader fails for multidimensional arrays with a 10733 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10]. 10734 We work around this by disabling this feature. See also 10735 gen_array_type_die. */ 10736#ifndef MIPS_DEBUGGING_INFO 10737 for (dimension_number = 0; 10738 TREE_CODE (type) == ARRAY_TYPE; 10739 type = TREE_TYPE (type), dimension_number++) 10740#endif 10741 { 10742 tree domain = TYPE_DOMAIN (type); 10743 10744 /* Arrays come in three flavors: Unspecified bounds, fixed bounds, 10745 and (in GNU C only) variable bounds. Handle all three forms 10746 here. */ 10747 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL); 10748 if (domain) 10749 { 10750 /* We have an array type with specified bounds. */ 10751 lower = TYPE_MIN_VALUE (domain); 10752 upper = TYPE_MAX_VALUE (domain); 10753 10754 /* Define the index type. */ 10755 if (TREE_TYPE (domain)) 10756 { 10757 /* ??? This is probably an Ada unnamed subrange type. Ignore the 10758 TREE_TYPE field. We can't emit debug info for this 10759 because it is an unnamed integral type. */ 10760 if (TREE_CODE (domain) == INTEGER_TYPE 10761 && TYPE_NAME (domain) == NULL_TREE 10762 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE 10763 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE) 10764 ; 10765 else 10766 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0, 10767 type_die); 10768 } 10769 10770 /* ??? If upper is NULL, the array has unspecified length, 10771 but it does have a lower bound. This happens with Fortran 10772 dimension arr(N:*) 10773 Since the debugger is definitely going to need to know N 10774 to produce useful results, go ahead and output the lower 10775 bound solo, and hope the debugger can cope. */ 10776 10777 add_bound_info (subrange_die, DW_AT_lower_bound, lower); 10778 if (upper) 10779 add_bound_info (subrange_die, DW_AT_upper_bound, upper); 10780 } 10781 10782 /* Otherwise we have an array type with an unspecified length. The 10783 DWARF-2 spec does not say how to handle this; let's just leave out the 10784 bounds. */ 10785 } 10786} 10787 10788static void 10789add_byte_size_attribute (dw_die_ref die, tree tree_node) 10790{ 10791 unsigned size; 10792 10793 switch (TREE_CODE (tree_node)) 10794 { 10795 case ERROR_MARK: 10796 size = 0; 10797 break; 10798 case ENUMERAL_TYPE: 10799 case RECORD_TYPE: 10800 case UNION_TYPE: 10801 case QUAL_UNION_TYPE: 10802 size = int_size_in_bytes (tree_node); 10803 break; 10804 case FIELD_DECL: 10805 /* For a data member of a struct or union, the DW_AT_byte_size is 10806 generally given as the number of bytes normally allocated for an 10807 object of the *declared* type of the member itself. This is true 10808 even for bit-fields. */ 10809 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT; 10810 break; 10811 default: 10812 gcc_unreachable (); 10813 } 10814 10815 /* Note that `size' might be -1 when we get to this point. If it is, that 10816 indicates that the byte size of the entity in question is variable. We 10817 have no good way of expressing this fact in Dwarf at the present time. 10818 GCC/35998: Avoid passing negative sizes to Dtrace and gdb. */ 10819 add_AT_unsigned (die, DW_AT_byte_size, (size != (unsigned)-1 ? size : 0)); 10820} 10821 10822/* For a FIELD_DECL node which represents a bit-field, output an attribute 10823 which specifies the distance in bits from the highest order bit of the 10824 "containing object" for the bit-field to the highest order bit of the 10825 bit-field itself. 10826 10827 For any given bit-field, the "containing object" is a hypothetical object 10828 (of some integral or enum type) within which the given bit-field lives. The 10829 type of this hypothetical "containing object" is always the same as the 10830 declared type of the individual bit-field itself. The determination of the 10831 exact location of the "containing object" for a bit-field is rather 10832 complicated. It's handled by the `field_byte_offset' function (above). 10833 10834 Note that it is the size (in bytes) of the hypothetical "containing object" 10835 which will be given in the DW_AT_byte_size attribute for this bit-field. 10836 (See `byte_size_attribute' above). */ 10837 10838static inline void 10839add_bit_offset_attribute (dw_die_ref die, tree decl) 10840{ 10841 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl); 10842 tree type = DECL_BIT_FIELD_TYPE (decl); 10843 HOST_WIDE_INT bitpos_int; 10844 HOST_WIDE_INT highest_order_object_bit_offset; 10845 HOST_WIDE_INT highest_order_field_bit_offset; 10846 HOST_WIDE_INT unsigned bit_offset; 10847 10848 /* Must be a field and a bit field. */ 10849 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL); 10850 10851 /* We can't yet handle bit-fields whose offsets are variable, so if we 10852 encounter such things, just return without generating any attribute 10853 whatsoever. Likewise for variable or too large size. */ 10854 if (! host_integerp (bit_position (decl), 0) 10855 || ! host_integerp (DECL_SIZE (decl), 1)) 10856 return; 10857 10858 bitpos_int = int_bit_position (decl); 10859 10860 /* Note that the bit offset is always the distance (in bits) from the 10861 highest-order bit of the "containing object" to the highest-order bit of 10862 the bit-field itself. Since the "high-order end" of any object or field 10863 is different on big-endian and little-endian machines, the computation 10864 below must take account of these differences. */ 10865 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT; 10866 highest_order_field_bit_offset = bitpos_int; 10867 10868 if (! BYTES_BIG_ENDIAN) 10869 { 10870 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0); 10871 highest_order_object_bit_offset += simple_type_size_in_bits (type); 10872 } 10873 10874 bit_offset 10875 = (! BYTES_BIG_ENDIAN 10876 ? highest_order_object_bit_offset - highest_order_field_bit_offset 10877 : highest_order_field_bit_offset - highest_order_object_bit_offset); 10878 10879 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset); 10880} 10881 10882/* For a FIELD_DECL node which represents a bit field, output an attribute 10883 which specifies the length in bits of the given field. */ 10884 10885static inline void 10886add_bit_size_attribute (dw_die_ref die, tree decl) 10887{ 10888 /* Must be a field and a bit field. */ 10889 gcc_assert (TREE_CODE (decl) == FIELD_DECL 10890 && DECL_BIT_FIELD_TYPE (decl)); 10891 10892 if (host_integerp (DECL_SIZE (decl), 1)) 10893 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1)); 10894} 10895 10896/* If the compiled language is ANSI C, then add a 'prototyped' 10897 attribute, if arg types are given for the parameters of a function. */ 10898 10899static inline void 10900add_prototyped_attribute (dw_die_ref die, tree func_type) 10901{ 10902 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89 10903 && TYPE_ARG_TYPES (func_type) != NULL) 10904 add_AT_flag (die, DW_AT_prototyped, 1); 10905} 10906 10907/* Add an 'abstract_origin' attribute below a given DIE. The DIE is found 10908 by looking in either the type declaration or object declaration 10909 equate table. */ 10910 10911static inline void 10912add_abstract_origin_attribute (dw_die_ref die, tree origin) 10913{ 10914 dw_die_ref origin_die = NULL; 10915 10916 if (TREE_CODE (origin) != FUNCTION_DECL) 10917 { 10918 /* We may have gotten separated from the block for the inlined 10919 function, if we're in an exception handler or some such; make 10920 sure that the abstract function has been written out. 10921 10922 Doing this for nested functions is wrong, however; functions are 10923 distinct units, and our context might not even be inline. */ 10924 tree fn = origin; 10925 10926 if (TYPE_P (fn)) 10927 fn = TYPE_STUB_DECL (fn); 10928 10929 fn = decl_function_context (fn); 10930 if (fn) 10931 dwarf2out_abstract_function (fn); 10932 } 10933 10934 if (DECL_P (origin)) 10935 origin_die = lookup_decl_die (origin); 10936 else if (TYPE_P (origin)) 10937 origin_die = lookup_type_die (origin); 10938 10939 /* XXX: Functions that are never lowered don't always have correct block 10940 trees (in the case of java, they simply have no block tree, in some other 10941 languages). For these functions, there is nothing we can really do to 10942 output correct debug info for inlined functions in all cases. Rather 10943 than die, we'll just produce deficient debug info now, in that we will 10944 have variables without a proper abstract origin. In the future, when all 10945 functions are lowered, we should re-add a gcc_assert (origin_die) 10946 here. */ 10947 10948 if (origin_die) 10949 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die); 10950} 10951 10952/* We do not currently support the pure_virtual attribute. */ 10953 10954static inline void 10955add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl) 10956{ 10957 if (DECL_VINDEX (func_decl)) 10958 { 10959 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual); 10960 10961 if (host_integerp (DECL_VINDEX (func_decl), 0)) 10962 add_AT_loc (die, DW_AT_vtable_elem_location, 10963 new_loc_descr (DW_OP_constu, 10964 tree_low_cst (DECL_VINDEX (func_decl), 0), 10965 0)); 10966 10967 /* GNU extension: Record what type this method came from originally. */ 10968 if (debug_info_level > DINFO_LEVEL_TERSE) 10969 add_AT_die_ref (die, DW_AT_containing_type, 10970 lookup_type_die (DECL_CONTEXT (func_decl))); 10971 } 10972} 10973 10974/* Add source coordinate attributes for the given decl. */ 10975 10976static void 10977add_src_coords_attributes (dw_die_ref die, tree decl) 10978{ 10979 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl)); 10980 10981 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file)); 10982 add_AT_unsigned (die, DW_AT_decl_line, s.line); 10983} 10984 10985/* Add a DW_AT_name attribute and source coordinate attribute for the 10986 given decl, but only if it actually has a name. */ 10987 10988static void 10989add_name_and_src_coords_attributes (dw_die_ref die, tree decl) 10990{ 10991 tree decl_name; 10992 10993 decl_name = DECL_NAME (decl); 10994 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL) 10995 { 10996 add_name_attribute (die, dwarf2_name (decl, 0)); 10997 if (! DECL_ARTIFICIAL (decl)) 10998 add_src_coords_attributes (die, decl); 10999 11000 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL) 11001 && TREE_PUBLIC (decl) 11002 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl) 11003 && !DECL_ABSTRACT (decl) 11004 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))) 11005 add_AT_string (die, DW_AT_MIPS_linkage_name, 11006 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); 11007 } 11008 11009#ifdef VMS_DEBUGGING_INFO 11010 /* Get the function's name, as described by its RTL. This may be different 11011 from the DECL_NAME name used in the source file. */ 11012 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl)) 11013 { 11014 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address, 11015 XEXP (DECL_RTL (decl), 0)); 11016 VEC_safe_push (tree, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0)); 11017 } 11018#endif 11019} 11020 11021/* Push a new declaration scope. */ 11022 11023static void 11024push_decl_scope (tree scope) 11025{ 11026 VEC_safe_push (tree, gc, decl_scope_table, scope); 11027} 11028 11029/* Pop a declaration scope. */ 11030 11031static inline void 11032pop_decl_scope (void) 11033{ 11034 VEC_pop (tree, decl_scope_table); 11035} 11036 11037/* Return the DIE for the scope that immediately contains this type. 11038 Non-named types get global scope. Named types nested in other 11039 types get their containing scope if it's open, or global scope 11040 otherwise. All other types (i.e. function-local named types) get 11041 the current active scope. */ 11042 11043static dw_die_ref 11044scope_die_for (tree t, dw_die_ref context_die) 11045{ 11046 dw_die_ref scope_die = NULL; 11047 tree containing_scope; 11048 int i; 11049 11050 /* Non-types always go in the current scope. */ 11051 gcc_assert (TYPE_P (t)); 11052 11053 containing_scope = TYPE_CONTEXT (t); 11054 11055 /* Use the containing namespace if it was passed in (for a declaration). */ 11056 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL) 11057 { 11058 if (context_die == lookup_decl_die (containing_scope)) 11059 /* OK */; 11060 else 11061 containing_scope = NULL_TREE; 11062 } 11063 11064 /* Ignore function type "scopes" from the C frontend. They mean that 11065 a tagged type is local to a parmlist of a function declarator, but 11066 that isn't useful to DWARF. */ 11067 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE) 11068 containing_scope = NULL_TREE; 11069 11070 if (containing_scope == NULL_TREE) 11071 scope_die = comp_unit_die; 11072 else if (TYPE_P (containing_scope)) 11073 { 11074 /* For types, we can just look up the appropriate DIE. But 11075 first we check to see if we're in the middle of emitting it 11076 so we know where the new DIE should go. */ 11077 for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i) 11078 if (VEC_index (tree, decl_scope_table, i) == containing_scope) 11079 break; 11080 11081 if (i < 0) 11082 { 11083 gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE 11084 || TREE_ASM_WRITTEN (containing_scope)); 11085 11086 /* If none of the current dies are suitable, we get file scope. */ 11087 scope_die = comp_unit_die; 11088 } 11089 else 11090 scope_die = lookup_type_die (containing_scope); 11091 } 11092 else 11093 scope_die = context_die; 11094 11095 return scope_die; 11096} 11097 11098/* Returns nonzero if CONTEXT_DIE is internal to a function. */ 11099 11100static inline int 11101local_scope_p (dw_die_ref context_die) 11102{ 11103 for (; context_die; context_die = context_die->die_parent) 11104 if (context_die->die_tag == DW_TAG_inlined_subroutine 11105 || context_die->die_tag == DW_TAG_subprogram) 11106 return 1; 11107 11108 return 0; 11109} 11110 11111/* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding 11112 whether or not to treat a DIE in this context as a declaration. */ 11113 11114static inline int 11115class_or_namespace_scope_p (dw_die_ref context_die) 11116{ 11117 return (context_die 11118 && (context_die->die_tag == DW_TAG_structure_type 11119 || context_die->die_tag == DW_TAG_union_type 11120 || context_die->die_tag == DW_TAG_namespace)); 11121} 11122 11123/* Many forms of DIEs require a "type description" attribute. This 11124 routine locates the proper "type descriptor" die for the type given 11125 by 'type', and adds a DW_AT_type attribute below the given die. */ 11126 11127static void 11128add_type_attribute (dw_die_ref object_die, tree type, int decl_const, 11129 int decl_volatile, dw_die_ref context_die) 11130{ 11131 enum tree_code code = TREE_CODE (type); 11132 dw_die_ref type_die = NULL; 11133 11134 /* ??? If this type is an unnamed subrange type of an integral or 11135 floating-point type, use the inner type. This is because we have no 11136 support for unnamed types in base_type_die. This can happen if this is 11137 an Ada subrange type. Correct solution is emit a subrange type die. */ 11138 if ((code == INTEGER_TYPE || code == REAL_TYPE) 11139 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0) 11140 type = TREE_TYPE (type), code = TREE_CODE (type); 11141 11142 if (code == ERROR_MARK 11143 /* Handle a special case. For functions whose return type is void, we 11144 generate *no* type attribute. (Note that no object may have type 11145 `void', so this only applies to function return types). */ 11146 || code == VOID_TYPE) 11147 return; 11148 11149 type_die = modified_type_die (type, 11150 decl_const || TYPE_READONLY (type), 11151 decl_volatile || TYPE_VOLATILE (type), 11152 context_die); 11153 11154 if (type_die != NULL) 11155 add_AT_die_ref (object_die, DW_AT_type, type_die); 11156} 11157 11158/* Given an object die, add the calling convention attribute for the 11159 function call type. */ 11160static void 11161add_calling_convention_attribute (dw_die_ref subr_die, tree type) 11162{ 11163 enum dwarf_calling_convention value = DW_CC_normal; 11164 11165 value = targetm.dwarf_calling_convention (type); 11166 11167 /* Only add the attribute if the backend requests it, and 11168 is not DW_CC_normal. */ 11169 if (value && (value != DW_CC_normal)) 11170 add_AT_unsigned (subr_die, DW_AT_calling_convention, value); 11171} 11172 11173/* Given a tree pointer to a struct, class, union, or enum type node, return 11174 a pointer to the (string) tag name for the given type, or zero if the type 11175 was declared without a tag. */ 11176 11177static const char * 11178type_tag (tree type) 11179{ 11180 const char *name = 0; 11181 11182 if (TYPE_NAME (type) != 0) 11183 { 11184 tree t = 0; 11185 11186 /* Find the IDENTIFIER_NODE for the type name. */ 11187 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) 11188 t = TYPE_NAME (type); 11189 11190 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to 11191 a TYPE_DECL node, regardless of whether or not a `typedef' was 11192 involved. */ 11193 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 11194 && ! DECL_IGNORED_P (TYPE_NAME (type))) 11195 t = DECL_NAME (TYPE_NAME (type)); 11196 11197 /* Now get the name as a string, or invent one. */ 11198 if (t != 0) 11199 name = IDENTIFIER_POINTER (t); 11200 } 11201 11202 return (name == 0 || *name == '\0') ? 0 : name; 11203} 11204 11205/* Return the type associated with a data member, make a special check 11206 for bit field types. */ 11207 11208static inline tree 11209member_declared_type (tree member) 11210{ 11211 return (DECL_BIT_FIELD_TYPE (member) 11212 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member)); 11213} 11214 11215/* Get the decl's label, as described by its RTL. This may be different 11216 from the DECL_NAME name used in the source file. */ 11217 11218#if 0 11219static const char * 11220decl_start_label (tree decl) 11221{ 11222 rtx x; 11223 const char *fnname; 11224 11225 x = DECL_RTL (decl); 11226 gcc_assert (MEM_P (x)); 11227 11228 x = XEXP (x, 0); 11229 gcc_assert (GET_CODE (x) == SYMBOL_REF); 11230 11231 fnname = XSTR (x, 0); 11232 return fnname; 11233} 11234#endif 11235 11236/* These routines generate the internal representation of the DIE's for 11237 the compilation unit. Debugging information is collected by walking 11238 the declaration trees passed in from dwarf2out_decl(). */ 11239 11240static void 11241gen_array_type_die (tree type, dw_die_ref context_die) 11242{ 11243 dw_die_ref scope_die = scope_die_for (type, context_die); 11244 dw_die_ref array_die; 11245 tree element_type; 11246 11247 /* ??? The SGI dwarf reader fails for array of array of enum types unless 11248 the inner array type comes before the outer array type. Thus we must 11249 call gen_type_die before we call new_die. See below also. */ 11250#ifdef MIPS_DEBUGGING_INFO 11251 gen_type_die (TREE_TYPE (type), context_die); 11252#endif 11253 11254 array_die = new_die (DW_TAG_array_type, scope_die, type); 11255 add_name_attribute (array_die, type_tag (type)); 11256 equate_type_number_to_die (type, array_die); 11257 11258 if (TREE_CODE (type) == VECTOR_TYPE) 11259 { 11260 /* The frontend feeds us a representation for the vector as a struct 11261 containing an array. Pull out the array type. */ 11262 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type))); 11263 add_AT_flag (array_die, DW_AT_GNU_vector, 1); 11264 } 11265 11266#if 0 11267 /* We default the array ordering. SDB will probably do 11268 the right things even if DW_AT_ordering is not present. It's not even 11269 an issue until we start to get into multidimensional arrays anyway. If 11270 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays, 11271 then we'll have to put the DW_AT_ordering attribute back in. (But if 11272 and when we find out that we need to put these in, we will only do so 11273 for multidimensional arrays. */ 11274 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major); 11275#endif 11276 11277#ifdef MIPS_DEBUGGING_INFO 11278 /* The SGI compilers handle arrays of unknown bound by setting 11279 AT_declaration and not emitting any subrange DIEs. */ 11280 if (! TYPE_DOMAIN (type)) 11281 add_AT_flag (array_die, DW_AT_declaration, 1); 11282 else 11283#endif 11284 add_subscript_info (array_die, type); 11285 11286 /* Add representation of the type of the elements of this array type. */ 11287 element_type = TREE_TYPE (type); 11288 11289 /* ??? The SGI dwarf reader fails for multidimensional arrays with a 11290 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10]. 11291 We work around this by disabling this feature. See also 11292 add_subscript_info. */ 11293#ifndef MIPS_DEBUGGING_INFO 11294 while (TREE_CODE (element_type) == ARRAY_TYPE) 11295 element_type = TREE_TYPE (element_type); 11296 11297 gen_type_die (element_type, context_die); 11298#endif 11299 11300 add_type_attribute (array_die, element_type, 0, 0, context_die); 11301} 11302 11303#if 0 11304static void 11305gen_entry_point_die (tree decl, dw_die_ref context_die) 11306{ 11307 tree origin = decl_ultimate_origin (decl); 11308 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl); 11309 11310 if (origin != NULL) 11311 add_abstract_origin_attribute (decl_die, origin); 11312 else 11313 { 11314 add_name_and_src_coords_attributes (decl_die, decl); 11315 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)), 11316 0, 0, context_die); 11317 } 11318 11319 if (DECL_ABSTRACT (decl)) 11320 equate_decl_number_to_die (decl, decl_die); 11321 else 11322 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl)); 11323} 11324#endif 11325 11326/* Walk through the list of incomplete types again, trying once more to 11327 emit full debugging info for them. */ 11328 11329static void 11330retry_incomplete_types (void) 11331{ 11332 int i; 11333 11334 for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--) 11335 gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die); 11336} 11337 11338/* Generate a DIE to represent an inlined instance of an enumeration type. */ 11339 11340static void 11341gen_inlined_enumeration_type_die (tree type, dw_die_ref context_die) 11342{ 11343 dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type); 11344 11345 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may 11346 be incomplete and such types are not marked. */ 11347 add_abstract_origin_attribute (type_die, type); 11348} 11349 11350/* Generate a DIE to represent an inlined instance of a structure type. */ 11351 11352static void 11353gen_inlined_structure_type_die (tree type, dw_die_ref context_die) 11354{ 11355 dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die, type); 11356 11357 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may 11358 be incomplete and such types are not marked. */ 11359 add_abstract_origin_attribute (type_die, type); 11360} 11361 11362/* Generate a DIE to represent an inlined instance of a union type. */ 11363 11364static void 11365gen_inlined_union_type_die (tree type, dw_die_ref context_die) 11366{ 11367 dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type); 11368 11369 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may 11370 be incomplete and such types are not marked. */ 11371 add_abstract_origin_attribute (type_die, type); 11372} 11373 11374/* Generate a DIE to represent an enumeration type. Note that these DIEs 11375 include all of the information about the enumeration values also. Each 11376 enumerated type name/value is listed as a child of the enumerated type 11377 DIE. */ 11378 11379static dw_die_ref 11380gen_enumeration_type_die (tree type, dw_die_ref context_die) 11381{ 11382 dw_die_ref type_die = lookup_type_die (type); 11383 11384 if (type_die == NULL) 11385 { 11386 type_die = new_die (DW_TAG_enumeration_type, 11387 scope_die_for (type, context_die), type); 11388 equate_type_number_to_die (type, type_die); 11389 add_name_attribute (type_die, type_tag (type)); 11390 } 11391 else if (! TYPE_SIZE (type)) 11392 return type_die; 11393 else 11394 remove_AT (type_die, DW_AT_declaration); 11395 11396 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the 11397 given enum type is incomplete, do not generate the DW_AT_byte_size 11398 attribute or the DW_AT_element_list attribute. */ 11399 if (TYPE_SIZE (type)) 11400 { 11401 tree link; 11402 11403 TREE_ASM_WRITTEN (type) = 1; 11404 add_byte_size_attribute (type_die, type); 11405 if (TYPE_STUB_DECL (type) != NULL_TREE) 11406 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type)); 11407 11408 /* If the first reference to this type was as the return type of an 11409 inline function, then it may not have a parent. Fix this now. */ 11410 if (type_die->die_parent == NULL) 11411 add_child_die (scope_die_for (type, context_die), type_die); 11412 11413 for (link = TYPE_VALUES (type); 11414 link != NULL; link = TREE_CHAIN (link)) 11415 { 11416 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link); 11417 tree value = TREE_VALUE (link); 11418 11419 add_name_attribute (enum_die, 11420 IDENTIFIER_POINTER (TREE_PURPOSE (link))); 11421 11422 if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value)))) 11423 /* DWARF2 does not provide a way of indicating whether or 11424 not enumeration constants are signed or unsigned. GDB 11425 always assumes the values are signed, so we output all 11426 values as if they were signed. That means that 11427 enumeration constants with very large unsigned values 11428 will appear to have negative values in the debugger. */ 11429 add_AT_int (enum_die, DW_AT_const_value, 11430 tree_low_cst (value, tree_int_cst_sgn (value) > 0)); 11431 } 11432 } 11433 else 11434 add_AT_flag (type_die, DW_AT_declaration, 1); 11435 11436 return type_die; 11437} 11438 11439/* Generate a DIE to represent either a real live formal parameter decl or to 11440 represent just the type of some formal parameter position in some function 11441 type. 11442 11443 Note that this routine is a bit unusual because its argument may be a 11444 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which 11445 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE 11446 node. If it's the former then this function is being called to output a 11447 DIE to represent a formal parameter object (or some inlining thereof). If 11448 it's the latter, then this function is only being called to output a 11449 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal 11450 argument type of some subprogram type. */ 11451 11452static dw_die_ref 11453gen_formal_parameter_die (tree node, dw_die_ref context_die) 11454{ 11455 dw_die_ref parm_die 11456 = new_die (DW_TAG_formal_parameter, context_die, node); 11457 tree origin; 11458 11459 switch (TREE_CODE_CLASS (TREE_CODE (node))) 11460 { 11461 case tcc_declaration: 11462 origin = decl_ultimate_origin (node); 11463 if (origin != NULL) 11464 add_abstract_origin_attribute (parm_die, origin); 11465 else 11466 { 11467 add_name_and_src_coords_attributes (parm_die, node); 11468 add_type_attribute (parm_die, TREE_TYPE (node), 11469 TREE_READONLY (node), 11470 TREE_THIS_VOLATILE (node), 11471 context_die); 11472 if (DECL_ARTIFICIAL (node)) 11473 add_AT_flag (parm_die, DW_AT_artificial, 1); 11474 } 11475 11476 equate_decl_number_to_die (node, parm_die); 11477 if (! DECL_ABSTRACT (node)) 11478 add_location_or_const_value_attribute (parm_die, node, DW_AT_location); 11479 11480 break; 11481 11482 case tcc_type: 11483 /* We were called with some kind of a ..._TYPE node. */ 11484 add_type_attribute (parm_die, node, 0, 0, context_die); 11485 break; 11486 11487 default: 11488 gcc_unreachable (); 11489 } 11490 11491 return parm_die; 11492} 11493 11494/* Generate a special type of DIE used as a stand-in for a trailing ellipsis 11495 at the end of an (ANSI prototyped) formal parameters list. */ 11496 11497static void 11498gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die) 11499{ 11500 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type); 11501} 11502 11503/* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a 11504 DW_TAG_unspecified_parameters DIE) to represent the types of the formal 11505 parameters as specified in some function type specification (except for 11506 those which appear as part of a function *definition*). */ 11507 11508static void 11509gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die) 11510{ 11511 tree link; 11512 tree formal_type = NULL; 11513 tree first_parm_type; 11514 tree arg; 11515 11516 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL) 11517 { 11518 arg = DECL_ARGUMENTS (function_or_method_type); 11519 function_or_method_type = TREE_TYPE (function_or_method_type); 11520 } 11521 else 11522 arg = NULL_TREE; 11523 11524 first_parm_type = TYPE_ARG_TYPES (function_or_method_type); 11525 11526 /* Make our first pass over the list of formal parameter types and output a 11527 DW_TAG_formal_parameter DIE for each one. */ 11528 for (link = first_parm_type; link; ) 11529 { 11530 dw_die_ref parm_die; 11531 11532 formal_type = TREE_VALUE (link); 11533 if (formal_type == void_type_node) 11534 break; 11535 11536 /* Output a (nameless) DIE to represent the formal parameter itself. */ 11537 parm_die = gen_formal_parameter_die (formal_type, context_die); 11538 if ((TREE_CODE (function_or_method_type) == METHOD_TYPE 11539 && link == first_parm_type) 11540 || (arg && DECL_ARTIFICIAL (arg))) 11541 add_AT_flag (parm_die, DW_AT_artificial, 1); 11542 11543 link = TREE_CHAIN (link); 11544 if (arg) 11545 arg = TREE_CHAIN (arg); 11546 } 11547 11548 /* If this function type has an ellipsis, add a 11549 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */ 11550 if (formal_type != void_type_node) 11551 gen_unspecified_parameters_die (function_or_method_type, context_die); 11552 11553 /* Make our second (and final) pass over the list of formal parameter types 11554 and output DIEs to represent those types (as necessary). */ 11555 for (link = TYPE_ARG_TYPES (function_or_method_type); 11556 link && TREE_VALUE (link); 11557 link = TREE_CHAIN (link)) 11558 gen_type_die (TREE_VALUE (link), context_die); 11559} 11560 11561/* We want to generate the DIE for TYPE so that we can generate the 11562 die for MEMBER, which has been defined; we will need to refer back 11563 to the member declaration nested within TYPE. If we're trying to 11564 generate minimal debug info for TYPE, processing TYPE won't do the 11565 trick; we need to attach the member declaration by hand. */ 11566 11567static void 11568gen_type_die_for_member (tree type, tree member, dw_die_ref context_die) 11569{ 11570 gen_type_die (type, context_die); 11571 11572 /* If we're trying to avoid duplicate debug info, we may not have 11573 emitted the member decl for this function. Emit it now. */ 11574 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type)) 11575 && ! lookup_decl_die (member)) 11576 { 11577 dw_die_ref type_die; 11578 gcc_assert (!decl_ultimate_origin (member)); 11579 11580 push_decl_scope (type); 11581 type_die = lookup_type_die (type); 11582 if (TREE_CODE (member) == FUNCTION_DECL) 11583 gen_subprogram_die (member, type_die); 11584 else if (TREE_CODE (member) == FIELD_DECL) 11585 { 11586 /* Ignore the nameless fields that are used to skip bits but handle 11587 C++ anonymous unions and structs. */ 11588 if (DECL_NAME (member) != NULL_TREE 11589 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE 11590 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE) 11591 { 11592 gen_type_die (member_declared_type (member), type_die); 11593 gen_field_die (member, type_die); 11594 } 11595 } 11596 else 11597 gen_variable_die (member, type_die); 11598 11599 pop_decl_scope (); 11600 } 11601} 11602 11603/* Generate the DWARF2 info for the "abstract" instance of a function which we 11604 may later generate inlined and/or out-of-line instances of. */ 11605 11606static void 11607dwarf2out_abstract_function (tree decl) 11608{ 11609 dw_die_ref old_die; 11610 tree save_fn; 11611 struct function *save_cfun; 11612 tree context; 11613 int was_abstract = DECL_ABSTRACT (decl); 11614 11615 /* Make sure we have the actual abstract inline, not a clone. */ 11616 decl = DECL_ORIGIN (decl); 11617 11618 old_die = lookup_decl_die (decl); 11619 if (old_die && get_AT (old_die, DW_AT_inline)) 11620 /* We've already generated the abstract instance. */ 11621 return; 11622 11623 /* Be sure we've emitted the in-class declaration DIE (if any) first, so 11624 we don't get confused by DECL_ABSTRACT. */ 11625 if (debug_info_level > DINFO_LEVEL_TERSE) 11626 { 11627 context = decl_class_context (decl); 11628 if (context) 11629 gen_type_die_for_member 11630 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die); 11631 } 11632 11633 /* Pretend we've just finished compiling this function. */ 11634 save_fn = current_function_decl; 11635 save_cfun = cfun; 11636 current_function_decl = decl; 11637 cfun = DECL_STRUCT_FUNCTION (decl); 11638 11639 set_decl_abstract_flags (decl, 1); 11640 dwarf2out_decl (decl); 11641 if (! was_abstract) 11642 set_decl_abstract_flags (decl, 0); 11643 11644 current_function_decl = save_fn; 11645 cfun = save_cfun; 11646} 11647 11648/* Helper function of premark_used_types() which gets called through 11649 htab_traverse_resize(). 11650 11651 Marks the DIE of a given type in *SLOT as perennial, so it never gets 11652 marked as unused by prune_unused_types. */ 11653static int 11654premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED) 11655{ 11656 tree type; 11657 dw_die_ref die; 11658 11659 type = *slot; 11660 die = lookup_type_die (type); 11661 if (die != NULL) 11662 die->die_perennial_p = 1; 11663 return 1; 11664} 11665 11666/* Mark all members of used_types_hash as perennial. */ 11667static void 11668premark_used_types (void) 11669{ 11670 if (cfun && cfun->used_types_hash) 11671 htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL); 11672} 11673 11674/* Generate a DIE to represent a declared function (either file-scope or 11675 block-local). */ 11676 11677static void 11678gen_subprogram_die (tree decl, dw_die_ref context_die) 11679{ 11680 char label_id[MAX_ARTIFICIAL_LABEL_BYTES]; 11681 tree origin = decl_ultimate_origin (decl); 11682 dw_die_ref subr_die; 11683 tree fn_arg_types; 11684 tree outer_scope; 11685 dw_die_ref old_die = lookup_decl_die (decl); 11686 int declaration = (current_function_decl != decl 11687 || class_or_namespace_scope_p (context_die)); 11688 11689 premark_used_types (); 11690 11691 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we 11692 started to generate the abstract instance of an inline, decided to output 11693 its containing class, and proceeded to emit the declaration of the inline 11694 from the member list for the class. If so, DECLARATION takes priority; 11695 we'll get back to the abstract instance when done with the class. */ 11696 11697 /* The class-scope declaration DIE must be the primary DIE. */ 11698 if (origin && declaration && class_or_namespace_scope_p (context_die)) 11699 { 11700 origin = NULL; 11701 gcc_assert (!old_die); 11702 } 11703 11704 /* Now that the C++ front end lazily declares artificial member fns, we 11705 might need to retrofit the declaration into its class. */ 11706 if (!declaration && !origin && !old_die 11707 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)) 11708 && !class_or_namespace_scope_p (context_die) 11709 && debug_info_level > DINFO_LEVEL_TERSE) 11710 old_die = force_decl_die (decl); 11711 11712 if (origin != NULL) 11713 { 11714 gcc_assert (!declaration || local_scope_p (context_die)); 11715 11716 /* Fixup die_parent for the abstract instance of a nested 11717 inline function. */ 11718 if (old_die && old_die->die_parent == NULL) 11719 add_child_die (context_die, old_die); 11720 11721 subr_die = new_die (DW_TAG_subprogram, context_die, decl); 11722 add_abstract_origin_attribute (subr_die, origin); 11723 } 11724 else if (old_die) 11725 { 11726 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl)); 11727 struct dwarf_file_data * file_index = lookup_filename (s.file); 11728 11729 if (!get_AT_flag (old_die, DW_AT_declaration) 11730 /* We can have a normal definition following an inline one in the 11731 case of redefinition of GNU C extern inlines. 11732 It seems reasonable to use AT_specification in this case. */ 11733 && !get_AT (old_die, DW_AT_inline)) 11734 { 11735 /* Detect and ignore this case, where we are trying to output 11736 something we have already output. */ 11737 return; 11738 } 11739 11740 /* If the definition comes from the same place as the declaration, 11741 maybe use the old DIE. We always want the DIE for this function 11742 that has the *_pc attributes to be under comp_unit_die so the 11743 debugger can find it. We also need to do this for abstract 11744 instances of inlines, since the spec requires the out-of-line copy 11745 to have the same parent. For local class methods, this doesn't 11746 apply; we just use the old DIE. */ 11747 if ((old_die->die_parent == comp_unit_die || context_die == NULL) 11748 && (DECL_ARTIFICIAL (decl) 11749 || (get_AT_file (old_die, DW_AT_decl_file) == file_index 11750 && (get_AT_unsigned (old_die, DW_AT_decl_line) 11751 == (unsigned) s.line)))) 11752 { 11753 subr_die = old_die; 11754 11755 /* Clear out the declaration attribute and the formal parameters. 11756 Do not remove all children, because it is possible that this 11757 declaration die was forced using force_decl_die(). In such 11758 cases die that forced declaration die (e.g. TAG_imported_module) 11759 is one of the children that we do not want to remove. */ 11760 remove_AT (subr_die, DW_AT_declaration); 11761 remove_child_TAG (subr_die, DW_TAG_formal_parameter); 11762 } 11763 else 11764 { 11765 subr_die = new_die (DW_TAG_subprogram, context_die, decl); 11766 add_AT_specification (subr_die, old_die); 11767 if (get_AT_file (old_die, DW_AT_decl_file) != file_index) 11768 add_AT_file (subr_die, DW_AT_decl_file, file_index); 11769 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line) 11770 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line); 11771 } 11772 } 11773 else 11774 { 11775 subr_die = new_die (DW_TAG_subprogram, context_die, decl); 11776 11777 if (TREE_PUBLIC (decl)) 11778 add_AT_flag (subr_die, DW_AT_external, 1); 11779 11780 add_name_and_src_coords_attributes (subr_die, decl); 11781 if (debug_info_level > DINFO_LEVEL_TERSE) 11782 { 11783 add_prototyped_attribute (subr_die, TREE_TYPE (decl)); 11784 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)), 11785 0, 0, context_die); 11786 } 11787 11788 add_pure_or_virtual_attribute (subr_die, decl); 11789 if (DECL_ARTIFICIAL (decl)) 11790 add_AT_flag (subr_die, DW_AT_artificial, 1); 11791 11792 if (TREE_PROTECTED (decl)) 11793 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected); 11794 else if (TREE_PRIVATE (decl)) 11795 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private); 11796 } 11797 11798 if (declaration) 11799 { 11800 if (!old_die || !get_AT (old_die, DW_AT_inline)) 11801 { 11802 add_AT_flag (subr_die, DW_AT_declaration, 1); 11803 11804 /* The first time we see a member function, it is in the context of 11805 the class to which it belongs. We make sure of this by emitting 11806 the class first. The next time is the definition, which is 11807 handled above. The two may come from the same source text. 11808 11809 Note that force_decl_die() forces function declaration die. It is 11810 later reused to represent definition. */ 11811 equate_decl_number_to_die (decl, subr_die); 11812 } 11813 } 11814 else if (DECL_ABSTRACT (decl)) 11815 { 11816 if (DECL_DECLARED_INLINE_P (decl)) 11817 { 11818 if (cgraph_function_possibly_inlined_p (decl)) 11819 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined); 11820 else 11821 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined); 11822 } 11823 else 11824 { 11825 if (cgraph_function_possibly_inlined_p (decl)) 11826 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined); 11827 else 11828 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined); 11829 } 11830 11831 equate_decl_number_to_die (decl, subr_die); 11832 } 11833 else if (!DECL_EXTERNAL (decl)) 11834 { 11835 HOST_WIDE_INT cfa_fb_offset; 11836 11837 if (!old_die || !get_AT (old_die, DW_AT_inline)) 11838 equate_decl_number_to_die (decl, subr_die); 11839 11840 if (!flag_reorder_blocks_and_partition) 11841 { 11842 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL, 11843 current_function_funcdef_no); 11844 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id); 11845 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL, 11846 current_function_funcdef_no); 11847 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id); 11848 11849 add_pubname (decl, subr_die); 11850 add_arange (decl, subr_die); 11851 } 11852 else 11853 { /* Do nothing for now; maybe need to duplicate die, one for 11854 hot section and ond for cold section, then use the hot/cold 11855 section begin/end labels to generate the aranges... */ 11856 /* 11857 add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label); 11858 add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label); 11859 add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label); 11860 add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label); 11861 11862 add_pubname (decl, subr_die); 11863 add_arange (decl, subr_die); 11864 add_arange (decl, subr_die); 11865 */ 11866 } 11867 11868#ifdef MIPS_DEBUGGING_INFO 11869 /* Add a reference to the FDE for this routine. */ 11870 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde); 11871#endif 11872 11873 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl); 11874 11875 /* We define the "frame base" as the function's CFA. This is more 11876 convenient for several reasons: (1) It's stable across the prologue 11877 and epilogue, which makes it better than just a frame pointer, 11878 (2) With dwarf3, there exists a one-byte encoding that allows us 11879 to reference the .debug_frame data by proxy, but failing that, 11880 (3) We can at least reuse the code inspection and interpretation 11881 code that determines the CFA position at various points in the 11882 function. */ 11883 /* ??? Use some command-line or configury switch to enable the use 11884 of dwarf3 DW_OP_call_frame_cfa. At present there are no dwarf 11885 consumers that understand it; fall back to "pure" dwarf2 and 11886 convert the CFA data into a location list. */ 11887 { 11888 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset); 11889 if (list->dw_loc_next) 11890 add_AT_loc_list (subr_die, DW_AT_frame_base, list); 11891 else 11892 add_AT_loc (subr_die, DW_AT_frame_base, list->expr); 11893 } 11894 11895 /* Compute a displacement from the "steady-state frame pointer" to 11896 the CFA. The former is what all stack slots and argument slots 11897 will reference in the rtl; the later is what we've told the 11898 debugger about. We'll need to adjust all frame_base references 11899 by this displacement. */ 11900 compute_frame_pointer_to_fb_displacement (cfa_fb_offset); 11901 11902 if (cfun->static_chain_decl) 11903 add_AT_location_description (subr_die, DW_AT_static_link, 11904 loc_descriptor_from_tree (cfun->static_chain_decl)); 11905 } 11906 11907 /* Now output descriptions of the arguments for this function. This gets 11908 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list 11909 for a FUNCTION_DECL doesn't indicate cases where there was a trailing 11910 `...' at the end of the formal parameter list. In order to find out if 11911 there was a trailing ellipsis or not, we must instead look at the type 11912 associated with the FUNCTION_DECL. This will be a node of type 11913 FUNCTION_TYPE. If the chain of type nodes hanging off of this 11914 FUNCTION_TYPE node ends with a void_type_node then there should *not* be 11915 an ellipsis at the end. */ 11916 11917 /* In the case where we are describing a mere function declaration, all we 11918 need to do here (and all we *can* do here) is to describe the *types* of 11919 its formal parameters. */ 11920 if (debug_info_level <= DINFO_LEVEL_TERSE) 11921 ; 11922 else if (declaration) 11923 gen_formal_types_die (decl, subr_die); 11924 else 11925 { 11926 /* Generate DIEs to represent all known formal parameters. */ 11927 tree arg_decls = DECL_ARGUMENTS (decl); 11928 tree parm; 11929 11930 /* When generating DIEs, generate the unspecified_parameters DIE 11931 instead if we come across the arg "__builtin_va_alist" */ 11932 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm)) 11933 if (TREE_CODE (parm) == PARM_DECL) 11934 { 11935 if (DECL_NAME (parm) 11936 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)), 11937 "__builtin_va_alist")) 11938 gen_unspecified_parameters_die (parm, subr_die); 11939 else 11940 gen_decl_die (parm, subr_die); 11941 } 11942 11943 /* Decide whether we need an unspecified_parameters DIE at the end. 11944 There are 2 more cases to do this for: 1) the ansi ... declaration - 11945 this is detectable when the end of the arg list is not a 11946 void_type_node 2) an unprototyped function declaration (not a 11947 definition). This just means that we have no info about the 11948 parameters at all. */ 11949 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl)); 11950 if (fn_arg_types != NULL) 11951 { 11952 /* This is the prototyped case, check for.... */ 11953 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node) 11954 gen_unspecified_parameters_die (decl, subr_die); 11955 } 11956 else if (DECL_INITIAL (decl) == NULL_TREE) 11957 gen_unspecified_parameters_die (decl, subr_die); 11958 } 11959 11960 /* Output Dwarf info for all of the stuff within the body of the function 11961 (if it has one - it may be just a declaration). */ 11962 outer_scope = DECL_INITIAL (decl); 11963 11964 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent 11965 a function. This BLOCK actually represents the outermost binding contour 11966 for the function, i.e. the contour in which the function's formal 11967 parameters and labels get declared. Curiously, it appears that the front 11968 end doesn't actually put the PARM_DECL nodes for the current function onto 11969 the BLOCK_VARS list for this outer scope, but are strung off of the 11970 DECL_ARGUMENTS list for the function instead. 11971 11972 The BLOCK_VARS list for the `outer_scope' does provide us with a list of 11973 the LABEL_DECL nodes for the function however, and we output DWARF info 11974 for those in decls_for_scope. Just within the `outer_scope' there will be 11975 a BLOCK node representing the function's outermost pair of curly braces, 11976 and any blocks used for the base and member initializers of a C++ 11977 constructor function. */ 11978 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK) 11979 { 11980 /* Emit a DW_TAG_variable DIE for a named return value. */ 11981 if (DECL_NAME (DECL_RESULT (decl))) 11982 gen_decl_die (DECL_RESULT (decl), subr_die); 11983 11984 current_function_has_inlines = 0; 11985 decls_for_scope (outer_scope, subr_die, 0); 11986 11987#if 0 && defined (MIPS_DEBUGGING_INFO) 11988 if (current_function_has_inlines) 11989 { 11990 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1); 11991 if (! comp_unit_has_inlines) 11992 { 11993 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1); 11994 comp_unit_has_inlines = 1; 11995 } 11996 } 11997#endif 11998 } 11999 /* Add the calling convention attribute if requested. */ 12000 add_calling_convention_attribute (subr_die, TREE_TYPE (decl)); 12001 12002} 12003 12004/* Generate a DIE to represent a declared data object. */ 12005 12006static void 12007gen_variable_die (tree decl, dw_die_ref context_die) 12008{ 12009 tree origin = decl_ultimate_origin (decl); 12010 dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl); 12011 12012 dw_die_ref old_die = lookup_decl_die (decl); 12013 int declaration = (DECL_EXTERNAL (decl) 12014 /* If DECL is COMDAT and has not actually been 12015 emitted, we cannot take its address; there 12016 might end up being no definition anywhere in 12017 the program. For example, consider the C++ 12018 test case: 12019 12020 template <class T> 12021 struct S { static const int i = 7; }; 12022 12023 template <class T> 12024 const int S<T>::i; 12025 12026 int f() { return S<int>::i; } 12027 12028 Here, S<int>::i is not DECL_EXTERNAL, but no 12029 definition is required, so the compiler will 12030 not emit a definition. */ 12031 || (TREE_CODE (decl) == VAR_DECL 12032 && DECL_COMDAT (decl) && !TREE_ASM_WRITTEN (decl)) 12033 || class_or_namespace_scope_p (context_die)); 12034 12035 if (origin != NULL) 12036 add_abstract_origin_attribute (var_die, origin); 12037 12038 /* Loop unrolling can create multiple blocks that refer to the same 12039 static variable, so we must test for the DW_AT_declaration flag. 12040 12041 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to 12042 copy decls and set the DECL_ABSTRACT flag on them instead of 12043 sharing them. 12044 12045 ??? Duplicated blocks have been rewritten to use .debug_ranges. 12046 12047 ??? The declare_in_namespace support causes us to get two DIEs for one 12048 variable, both of which are declarations. We want to avoid considering 12049 one to be a specification, so we must test that this DIE is not a 12050 declaration. */ 12051 else if (old_die && TREE_STATIC (decl) && ! declaration 12052 && get_AT_flag (old_die, DW_AT_declaration) == 1) 12053 { 12054 /* This is a definition of a C++ class level static. */ 12055 add_AT_specification (var_die, old_die); 12056 if (DECL_NAME (decl)) 12057 { 12058 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl)); 12059 struct dwarf_file_data * file_index = lookup_filename (s.file); 12060 12061 if (get_AT_file (old_die, DW_AT_decl_file) != file_index) 12062 add_AT_file (var_die, DW_AT_decl_file, file_index); 12063 12064 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line) 12065 12066 add_AT_unsigned (var_die, DW_AT_decl_line, s.line); 12067 } 12068 } 12069 else 12070 { 12071 add_name_and_src_coords_attributes (var_die, decl); 12072 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl), 12073 TREE_THIS_VOLATILE (decl), context_die); 12074 12075 if (TREE_PUBLIC (decl)) 12076 add_AT_flag (var_die, DW_AT_external, 1); 12077 12078 if (DECL_ARTIFICIAL (decl)) 12079 add_AT_flag (var_die, DW_AT_artificial, 1); 12080 12081 if (TREE_PROTECTED (decl)) 12082 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected); 12083 else if (TREE_PRIVATE (decl)) 12084 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private); 12085 } 12086 12087 if (declaration) 12088 add_AT_flag (var_die, DW_AT_declaration, 1); 12089 12090 if (DECL_ABSTRACT (decl) || declaration) 12091 equate_decl_number_to_die (decl, var_die); 12092 12093 if (! declaration && ! DECL_ABSTRACT (decl)) 12094 { 12095 add_location_or_const_value_attribute (var_die, decl, DW_AT_location); 12096 add_pubname (decl, var_die); 12097 } 12098 else 12099 tree_add_const_value_attribute (var_die, decl); 12100} 12101 12102/* Generate a DIE to represent a label identifier. */ 12103 12104static void 12105gen_label_die (tree decl, dw_die_ref context_die) 12106{ 12107 tree origin = decl_ultimate_origin (decl); 12108 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl); 12109 rtx insn; 12110 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 12111 12112 if (origin != NULL) 12113 add_abstract_origin_attribute (lbl_die, origin); 12114 else 12115 add_name_and_src_coords_attributes (lbl_die, decl); 12116 12117 if (DECL_ABSTRACT (decl)) 12118 equate_decl_number_to_die (decl, lbl_die); 12119 else 12120 { 12121 insn = DECL_RTL_IF_SET (decl); 12122 12123 /* Deleted labels are programmer specified labels which have been 12124 eliminated because of various optimizations. We still emit them 12125 here so that it is possible to put breakpoints on them. */ 12126 if (insn 12127 && (LABEL_P (insn) 12128 || ((NOTE_P (insn) 12129 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL)))) 12130 { 12131 /* When optimization is enabled (via -O) some parts of the compiler 12132 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which 12133 represent source-level labels which were explicitly declared by 12134 the user. This really shouldn't be happening though, so catch 12135 it if it ever does happen. */ 12136 gcc_assert (!INSN_DELETED_P (insn)); 12137 12138 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn)); 12139 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label); 12140 } 12141 } 12142} 12143 12144/* A helper function for gen_inlined_subroutine_die. Add source coordinate 12145 attributes to the DIE for a block STMT, to describe where the inlined 12146 function was called from. This is similar to add_src_coords_attributes. */ 12147 12148static inline void 12149add_call_src_coords_attributes (tree stmt, dw_die_ref die) 12150{ 12151 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt)); 12152 12153 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file)); 12154 add_AT_unsigned (die, DW_AT_call_line, s.line); 12155} 12156 12157/* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die. 12158 Add low_pc and high_pc attributes to the DIE for a block STMT. */ 12159 12160static inline void 12161add_high_low_attributes (tree stmt, dw_die_ref die) 12162{ 12163 char label[MAX_ARTIFICIAL_LABEL_BYTES]; 12164 12165 if (BLOCK_FRAGMENT_CHAIN (stmt)) 12166 { 12167 tree chain; 12168 12169 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt)); 12170 12171 chain = BLOCK_FRAGMENT_CHAIN (stmt); 12172 do 12173 { 12174 add_ranges (chain); 12175 chain = BLOCK_FRAGMENT_CHAIN (chain); 12176 } 12177 while (chain); 12178 add_ranges (NULL); 12179 } 12180 else 12181 { 12182 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL, 12183 BLOCK_NUMBER (stmt)); 12184 add_AT_lbl_id (die, DW_AT_low_pc, label); 12185 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, 12186 BLOCK_NUMBER (stmt)); 12187 add_AT_lbl_id (die, DW_AT_high_pc, label); 12188 } 12189} 12190 12191/* Generate a DIE for a lexical block. */ 12192 12193static void 12194gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth) 12195{ 12196 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt); 12197 12198 if (! BLOCK_ABSTRACT (stmt)) 12199 add_high_low_attributes (stmt, stmt_die); 12200 12201 decls_for_scope (stmt, stmt_die, depth); 12202} 12203 12204/* Generate a DIE for an inlined subprogram. */ 12205 12206static void 12207gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth) 12208{ 12209 tree decl = block_ultimate_origin (stmt); 12210 12211 /* Emit info for the abstract instance first, if we haven't yet. We 12212 must emit this even if the block is abstract, otherwise when we 12213 emit the block below (or elsewhere), we may end up trying to emit 12214 a die whose origin die hasn't been emitted, and crashing. */ 12215 dwarf2out_abstract_function (decl); 12216 12217 if (! BLOCK_ABSTRACT (stmt)) 12218 { 12219 dw_die_ref subr_die 12220 = new_die (DW_TAG_inlined_subroutine, context_die, stmt); 12221 12222 add_abstract_origin_attribute (subr_die, decl); 12223 add_high_low_attributes (stmt, subr_die); 12224 add_call_src_coords_attributes (stmt, subr_die); 12225 12226 decls_for_scope (stmt, subr_die, depth); 12227 current_function_has_inlines = 1; 12228 } 12229 else 12230 /* We may get here if we're the outer block of function A that was 12231 inlined into function B that was inlined into function C. When 12232 generating debugging info for C, dwarf2out_abstract_function(B) 12233 would mark all inlined blocks as abstract, including this one. 12234 So, we wouldn't (and shouldn't) expect labels to be generated 12235 for this one. Instead, just emit debugging info for 12236 declarations within the block. This is particularly important 12237 in the case of initializers of arguments passed from B to us: 12238 if they're statement expressions containing declarations, we 12239 wouldn't generate dies for their abstract variables, and then, 12240 when generating dies for the real variables, we'd die (pun 12241 intended :-) */ 12242 gen_lexical_block_die (stmt, context_die, depth); 12243} 12244 12245/* Generate a DIE for a field in a record, or structure. */ 12246 12247static void 12248gen_field_die (tree decl, dw_die_ref context_die) 12249{ 12250 dw_die_ref decl_die; 12251 12252 if (TREE_TYPE (decl) == error_mark_node) 12253 return; 12254 12255 decl_die = new_die (DW_TAG_member, context_die, decl); 12256 add_name_and_src_coords_attributes (decl_die, decl); 12257 add_type_attribute (decl_die, member_declared_type (decl), 12258 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl), 12259 context_die); 12260 12261 if (DECL_BIT_FIELD_TYPE (decl)) 12262 { 12263 add_byte_size_attribute (decl_die, decl); 12264 add_bit_size_attribute (decl_die, decl); 12265 add_bit_offset_attribute (decl_die, decl); 12266 } 12267 12268 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE) 12269 add_data_member_location_attribute (decl_die, decl); 12270 12271 if (DECL_ARTIFICIAL (decl)) 12272 add_AT_flag (decl_die, DW_AT_artificial, 1); 12273 12274 if (TREE_PROTECTED (decl)) 12275 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected); 12276 else if (TREE_PRIVATE (decl)) 12277 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private); 12278 12279 /* Equate decl number to die, so that we can look up this decl later on. */ 12280 equate_decl_number_to_die (decl, decl_die); 12281} 12282 12283#if 0 12284/* Don't generate either pointer_type DIEs or reference_type DIEs here. 12285 Use modified_type_die instead. 12286 We keep this code here just in case these types of DIEs may be needed to 12287 represent certain things in other languages (e.g. Pascal) someday. */ 12288 12289static void 12290gen_pointer_type_die (tree type, dw_die_ref context_die) 12291{ 12292 dw_die_ref ptr_die 12293 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type); 12294 12295 equate_type_number_to_die (type, ptr_die); 12296 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die); 12297 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); 12298} 12299 12300/* Don't generate either pointer_type DIEs or reference_type DIEs here. 12301 Use modified_type_die instead. 12302 We keep this code here just in case these types of DIEs may be needed to 12303 represent certain things in other languages (e.g. Pascal) someday. */ 12304 12305static void 12306gen_reference_type_die (tree type, dw_die_ref context_die) 12307{ 12308 dw_die_ref ref_die 12309 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type); 12310 12311 equate_type_number_to_die (type, ref_die); 12312 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die); 12313 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); 12314} 12315#endif 12316 12317/* Generate a DIE for a pointer to a member type. */ 12318 12319static void 12320gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die) 12321{ 12322 dw_die_ref ptr_die 12323 = new_die (DW_TAG_ptr_to_member_type, 12324 scope_die_for (type, context_die), type); 12325 12326 equate_type_number_to_die (type, ptr_die); 12327 add_AT_die_ref (ptr_die, DW_AT_containing_type, 12328 lookup_type_die (TYPE_OFFSET_BASETYPE (type))); 12329 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die); 12330} 12331 12332/* Generate the DIE for the compilation unit. */ 12333 12334static dw_die_ref 12335gen_compile_unit_die (const char *filename) 12336{ 12337 dw_die_ref die; 12338 char producer[250]; 12339 const char *language_string = lang_hooks.name; 12340 int language; 12341 12342 die = new_die (DW_TAG_compile_unit, NULL, NULL); 12343 12344 if (filename) 12345 { 12346 add_name_attribute (die, filename); 12347 /* Don't add cwd for <built-in>. */ 12348 if (filename[0] != DIR_SEPARATOR && filename[0] != '<') 12349 add_comp_dir_attribute (die); 12350 } 12351 12352 sprintf (producer, "%s %s", language_string, version_string); 12353 12354#ifdef MIPS_DEBUGGING_INFO 12355 /* The MIPS/SGI compilers place the 'cc' command line options in the producer 12356 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do 12357 not appear in the producer string, the debugger reaches the conclusion 12358 that the object file is stripped and has no debugging information. 12359 To get the MIPS/SGI debugger to believe that there is debugging 12360 information in the object file, we add a -g to the producer string. */ 12361 if (debug_info_level > DINFO_LEVEL_TERSE) 12362 strcat (producer, " -g"); 12363#endif 12364 12365 add_AT_string (die, DW_AT_producer, producer); 12366 12367 if (strcmp (language_string, "GNU C++") == 0) 12368 language = DW_LANG_C_plus_plus; 12369 else if (strcmp (language_string, "GNU Ada") == 0) 12370 language = DW_LANG_Ada95; 12371 else if (strcmp (language_string, "GNU F77") == 0) 12372 language = DW_LANG_Fortran77; 12373 else if (strcmp (language_string, "GNU F95") == 0) 12374 language = DW_LANG_Fortran95; 12375 else if (strcmp (language_string, "GNU Pascal") == 0) 12376 language = DW_LANG_Pascal83; 12377 else if (strcmp (language_string, "GNU Java") == 0) 12378 language = DW_LANG_Java; 12379 else if (strcmp (language_string, "GNU Objective-C") == 0) 12380 language = DW_LANG_ObjC; 12381 else if (strcmp (language_string, "GNU Objective-C++") == 0) 12382 language = DW_LANG_ObjC_plus_plus; 12383 else 12384 language = DW_LANG_C89; 12385 12386 add_AT_unsigned (die, DW_AT_language, language); 12387 return die; 12388} 12389 12390/* Generate the DIE for a base class. */ 12391 12392static void 12393gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die) 12394{ 12395 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo); 12396 12397 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die); 12398 add_data_member_location_attribute (die, binfo); 12399 12400 if (BINFO_VIRTUAL_P (binfo)) 12401 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual); 12402 12403 if (access == access_public_node) 12404 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public); 12405 else if (access == access_protected_node) 12406 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected); 12407} 12408 12409/* Generate a DIE for a class member. */ 12410 12411static void 12412gen_member_die (tree type, dw_die_ref context_die) 12413{ 12414 tree member; 12415 tree binfo = TYPE_BINFO (type); 12416 dw_die_ref child; 12417 12418 /* If this is not an incomplete type, output descriptions of each of its 12419 members. Note that as we output the DIEs necessary to represent the 12420 members of this record or union type, we will also be trying to output 12421 DIEs to represent the *types* of those members. However the `type' 12422 function (above) will specifically avoid generating type DIEs for member 12423 types *within* the list of member DIEs for this (containing) type except 12424 for those types (of members) which are explicitly marked as also being 12425 members of this (containing) type themselves. The g++ front- end can 12426 force any given type to be treated as a member of some other (containing) 12427 type by setting the TYPE_CONTEXT of the given (member) type to point to 12428 the TREE node representing the appropriate (containing) type. */ 12429 12430 /* First output info about the base classes. */ 12431 if (binfo) 12432 { 12433 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo); 12434 int i; 12435 tree base; 12436 12437 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++) 12438 gen_inheritance_die (base, 12439 (accesses ? VEC_index (tree, accesses, i) 12440 : access_public_node), context_die); 12441 } 12442 12443 /* Now output info about the data members and type members. */ 12444 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member)) 12445 { 12446 /* If we thought we were generating minimal debug info for TYPE 12447 and then changed our minds, some of the member declarations 12448 may have already been defined. Don't define them again, but 12449 do put them in the right order. */ 12450 12451 child = lookup_decl_die (member); 12452 if (child) 12453 splice_child_die (context_die, child); 12454 else 12455 gen_decl_die (member, context_die); 12456 } 12457 12458 /* Now output info about the function members (if any). */ 12459 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member)) 12460 { 12461 /* Don't include clones in the member list. */ 12462 if (DECL_ABSTRACT_ORIGIN (member)) 12463 continue; 12464 12465 child = lookup_decl_die (member); 12466 if (child) 12467 splice_child_die (context_die, child); 12468 else 12469 gen_decl_die (member, context_die); 12470 } 12471} 12472 12473/* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG 12474 is set, we pretend that the type was never defined, so we only get the 12475 member DIEs needed by later specification DIEs. */ 12476 12477static void 12478gen_struct_or_union_type_die (tree type, dw_die_ref context_die, 12479 enum debug_info_usage usage) 12480{ 12481 dw_die_ref type_die = lookup_type_die (type); 12482 dw_die_ref scope_die = 0; 12483 int nested = 0; 12484 int complete = (TYPE_SIZE (type) 12485 && (! TYPE_STUB_DECL (type) 12486 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type)))); 12487 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace); 12488 complete = complete && should_emit_struct_debug (type, usage); 12489 12490 if (type_die && ! complete) 12491 return; 12492 12493 if (TYPE_CONTEXT (type) != NULL_TREE 12494 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type)) 12495 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL)) 12496 nested = 1; 12497 12498 scope_die = scope_die_for (type, context_die); 12499 12500 if (! type_die || (nested && scope_die == comp_unit_die)) 12501 /* First occurrence of type or toplevel definition of nested class. */ 12502 { 12503 dw_die_ref old_die = type_die; 12504 12505 type_die = new_die (TREE_CODE (type) == RECORD_TYPE 12506 ? DW_TAG_structure_type : DW_TAG_union_type, 12507 scope_die, type); 12508 equate_type_number_to_die (type, type_die); 12509 if (old_die) 12510 add_AT_specification (type_die, old_die); 12511 else 12512 add_name_attribute (type_die, type_tag (type)); 12513 } 12514 else 12515 remove_AT (type_die, DW_AT_declaration); 12516 12517 /* If this type has been completed, then give it a byte_size attribute and 12518 then give a list of members. */ 12519 if (complete && !ns_decl) 12520 { 12521 /* Prevent infinite recursion in cases where the type of some member of 12522 this type is expressed in terms of this type itself. */ 12523 TREE_ASM_WRITTEN (type) = 1; 12524 add_byte_size_attribute (type_die, type); 12525 if (TYPE_STUB_DECL (type) != NULL_TREE) 12526 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type)); 12527 12528 /* If the first reference to this type was as the return type of an 12529 inline function, then it may not have a parent. Fix this now. */ 12530 if (type_die->die_parent == NULL) 12531 add_child_die (scope_die, type_die); 12532 12533 push_decl_scope (type); 12534 gen_member_die (type, type_die); 12535 pop_decl_scope (); 12536 12537 /* GNU extension: Record what type our vtable lives in. */ 12538 if (TYPE_VFIELD (type)) 12539 { 12540 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type)); 12541 12542 gen_type_die (vtype, context_die); 12543 add_AT_die_ref (type_die, DW_AT_containing_type, 12544 lookup_type_die (vtype)); 12545 } 12546 } 12547 else 12548 { 12549 add_AT_flag (type_die, DW_AT_declaration, 1); 12550 12551 /* We don't need to do this for function-local types. */ 12552 if (TYPE_STUB_DECL (type) 12553 && ! decl_function_context (TYPE_STUB_DECL (type))) 12554 VEC_safe_push (tree, gc, incomplete_types, type); 12555 } 12556} 12557 12558/* Generate a DIE for a subroutine _type_. */ 12559 12560static void 12561gen_subroutine_type_die (tree type, dw_die_ref context_die) 12562{ 12563 tree return_type = TREE_TYPE (type); 12564 dw_die_ref subr_die 12565 = new_die (DW_TAG_subroutine_type, 12566 scope_die_for (type, context_die), type); 12567 12568 equate_type_number_to_die (type, subr_die); 12569 add_prototyped_attribute (subr_die, type); 12570 add_type_attribute (subr_die, return_type, 0, 0, context_die); 12571 gen_formal_types_die (type, subr_die); 12572} 12573 12574/* Generate a DIE for a type definition. */ 12575 12576static void 12577gen_typedef_die (tree decl, dw_die_ref context_die) 12578{ 12579 dw_die_ref type_die; 12580 tree origin; 12581 12582 if (TREE_ASM_WRITTEN (decl)) 12583 return; 12584 12585 TREE_ASM_WRITTEN (decl) = 1; 12586 type_die = new_die (DW_TAG_typedef, context_die, decl); 12587 origin = decl_ultimate_origin (decl); 12588 if (origin != NULL) 12589 add_abstract_origin_attribute (type_die, origin); 12590 else 12591 { 12592 tree type; 12593 12594 add_name_and_src_coords_attributes (type_die, decl); 12595 if (DECL_ORIGINAL_TYPE (decl)) 12596 { 12597 type = DECL_ORIGINAL_TYPE (decl); 12598 12599 gcc_assert (type != TREE_TYPE (decl)); 12600 equate_type_number_to_die (TREE_TYPE (decl), type_die); 12601 } 12602 else 12603 type = TREE_TYPE (decl); 12604 12605 add_type_attribute (type_die, type, TREE_READONLY (decl), 12606 TREE_THIS_VOLATILE (decl), context_die); 12607 } 12608 12609 if (DECL_ABSTRACT (decl)) 12610 equate_decl_number_to_die (decl, type_die); 12611} 12612 12613/* Generate a type description DIE. */ 12614 12615static void 12616gen_type_die_with_usage (tree type, dw_die_ref context_die, 12617 enum debug_info_usage usage) 12618{ 12619 int need_pop; 12620 12621 if (type == NULL_TREE || type == error_mark_node) 12622 return; 12623 12624 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 12625 && DECL_ORIGINAL_TYPE (TYPE_NAME (type))) 12626 { 12627 if (TREE_ASM_WRITTEN (type)) 12628 return; 12629 12630 /* Prevent broken recursion; we can't hand off to the same type. */ 12631 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type); 12632 12633 TREE_ASM_WRITTEN (type) = 1; 12634 gen_decl_die (TYPE_NAME (type), context_die); 12635 return; 12636 } 12637 12638 /* We are going to output a DIE to represent the unqualified version 12639 of this type (i.e. without any const or volatile qualifiers) so 12640 get the main variant (i.e. the unqualified version) of this type 12641 now. (Vectors are special because the debugging info is in the 12642 cloned type itself). */ 12643 if (TREE_CODE (type) != VECTOR_TYPE) 12644 type = type_main_variant (type); 12645 12646 if (TREE_ASM_WRITTEN (type)) 12647 return; 12648 12649 switch (TREE_CODE (type)) 12650 { 12651 case ERROR_MARK: 12652 break; 12653 12654 case POINTER_TYPE: 12655 case REFERENCE_TYPE: 12656 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This 12657 ensures that the gen_type_die recursion will terminate even if the 12658 type is recursive. Recursive types are possible in Ada. */ 12659 /* ??? We could perhaps do this for all types before the switch 12660 statement. */ 12661 TREE_ASM_WRITTEN (type) = 1; 12662 12663 /* For these types, all that is required is that we output a DIE (or a 12664 set of DIEs) to represent the "basis" type. */ 12665 gen_type_die_with_usage (TREE_TYPE (type), context_die, 12666 DINFO_USAGE_IND_USE); 12667 break; 12668 12669 case OFFSET_TYPE: 12670 /* This code is used for C++ pointer-to-data-member types. 12671 Output a description of the relevant class type. */ 12672 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die, 12673 DINFO_USAGE_IND_USE); 12674 12675 /* Output a description of the type of the object pointed to. */ 12676 gen_type_die_with_usage (TREE_TYPE (type), context_die, 12677 DINFO_USAGE_IND_USE); 12678 12679 /* Now output a DIE to represent this pointer-to-data-member type 12680 itself. */ 12681 gen_ptr_to_mbr_type_die (type, context_die); 12682 break; 12683 12684 case FUNCTION_TYPE: 12685 /* Force out return type (in case it wasn't forced out already). */ 12686 gen_type_die_with_usage (TREE_TYPE (type), context_die, 12687 DINFO_USAGE_DIR_USE); 12688 gen_subroutine_type_die (type, context_die); 12689 break; 12690 12691 case METHOD_TYPE: 12692 /* Force out return type (in case it wasn't forced out already). */ 12693 gen_type_die_with_usage (TREE_TYPE (type), context_die, 12694 DINFO_USAGE_DIR_USE); 12695 gen_subroutine_type_die (type, context_die); 12696 break; 12697 12698 case ARRAY_TYPE: 12699 gen_array_type_die (type, context_die); 12700 break; 12701 12702 case VECTOR_TYPE: 12703 gen_array_type_die (type, context_die); 12704 break; 12705 12706 case ENUMERAL_TYPE: 12707 case RECORD_TYPE: 12708 case UNION_TYPE: 12709 case QUAL_UNION_TYPE: 12710 /* If this is a nested type whose containing class hasn't been written 12711 out yet, writing it out will cover this one, too. This does not apply 12712 to instantiations of member class templates; they need to be added to 12713 the containing class as they are generated. FIXME: This hurts the 12714 idea of combining type decls from multiple TUs, since we can't predict 12715 what set of template instantiations we'll get. */ 12716 if (TYPE_CONTEXT (type) 12717 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)) 12718 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type))) 12719 { 12720 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage); 12721 12722 if (TREE_ASM_WRITTEN (type)) 12723 return; 12724 12725 /* If that failed, attach ourselves to the stub. */ 12726 push_decl_scope (TYPE_CONTEXT (type)); 12727 context_die = lookup_type_die (TYPE_CONTEXT (type)); 12728 need_pop = 1; 12729 } 12730 else 12731 { 12732 declare_in_namespace (type, context_die); 12733 need_pop = 0; 12734 } 12735 12736 if (TREE_CODE (type) == ENUMERAL_TYPE) 12737 { 12738 /* This might have been written out by the call to 12739 declare_in_namespace. */ 12740 if (!TREE_ASM_WRITTEN (type)) 12741 gen_enumeration_type_die (type, context_die); 12742 } 12743 else 12744 gen_struct_or_union_type_die (type, context_die, usage); 12745 12746 if (need_pop) 12747 pop_decl_scope (); 12748 12749 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix 12750 it up if it is ever completed. gen_*_type_die will set it for us 12751 when appropriate. */ 12752 return; 12753 12754 case VOID_TYPE: 12755 case INTEGER_TYPE: 12756 case REAL_TYPE: 12757 case COMPLEX_TYPE: 12758 case BOOLEAN_TYPE: 12759 /* No DIEs needed for fundamental types. */ 12760 break; 12761 12762 case LANG_TYPE: 12763 /* No Dwarf representation currently defined. */ 12764 break; 12765 12766 default: 12767 gcc_unreachable (); 12768 } 12769 12770 TREE_ASM_WRITTEN (type) = 1; 12771} 12772 12773static void 12774gen_type_die (tree type, dw_die_ref context_die) 12775{ 12776 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE); 12777} 12778 12779/* Generate a DIE for a tagged type instantiation. */ 12780 12781static void 12782gen_tagged_type_instantiation_die (tree type, dw_die_ref context_die) 12783{ 12784 if (type == NULL_TREE || type == error_mark_node) 12785 return; 12786 12787 /* We are going to output a DIE to represent the unqualified version of 12788 this type (i.e. without any const or volatile qualifiers) so make sure 12789 that we have the main variant (i.e. the unqualified version) of this 12790 type now. */ 12791 gcc_assert (type == type_main_variant (type)); 12792 12793 /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is 12794 an instance of an unresolved type. */ 12795 12796 switch (TREE_CODE (type)) 12797 { 12798 case ERROR_MARK: 12799 break; 12800 12801 case ENUMERAL_TYPE: 12802 gen_inlined_enumeration_type_die (type, context_die); 12803 break; 12804 12805 case RECORD_TYPE: 12806 gen_inlined_structure_type_die (type, context_die); 12807 break; 12808 12809 case UNION_TYPE: 12810 case QUAL_UNION_TYPE: 12811 gen_inlined_union_type_die (type, context_die); 12812 break; 12813 12814 default: 12815 gcc_unreachable (); 12816 } 12817} 12818 12819/* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the 12820 things which are local to the given block. */ 12821 12822static void 12823gen_block_die (tree stmt, dw_die_ref context_die, int depth) 12824{ 12825 int must_output_die = 0; 12826 tree origin; 12827 tree decl; 12828 enum tree_code origin_code; 12829 12830 /* Ignore blocks that are NULL. */ 12831 if (stmt == NULL_TREE) 12832 return; 12833 12834 /* If the block is one fragment of a non-contiguous block, do not 12835 process the variables, since they will have been done by the 12836 origin block. Do process subblocks. */ 12837 if (BLOCK_FRAGMENT_ORIGIN (stmt)) 12838 { 12839 tree sub; 12840 12841 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub)) 12842 gen_block_die (sub, context_die, depth + 1); 12843 12844 return; 12845 } 12846 12847 /* Determine the "ultimate origin" of this block. This block may be an 12848 inlined instance of an inlined instance of inline function, so we have 12849 to trace all of the way back through the origin chain to find out what 12850 sort of node actually served as the original seed for the creation of 12851 the current block. */ 12852 origin = block_ultimate_origin (stmt); 12853 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK; 12854 12855 /* Determine if we need to output any Dwarf DIEs at all to represent this 12856 block. */ 12857 if (origin_code == FUNCTION_DECL) 12858 /* The outer scopes for inlinings *must* always be represented. We 12859 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */ 12860 must_output_die = 1; 12861 else 12862 { 12863 /* In the case where the current block represents an inlining of the 12864 "body block" of an inline function, we must *NOT* output any DIE for 12865 this block because we have already output a DIE to represent the whole 12866 inlined function scope and the "body block" of any function doesn't 12867 really represent a different scope according to ANSI C rules. So we 12868 check here to make sure that this block does not represent a "body 12869 block inlining" before trying to set the MUST_OUTPUT_DIE flag. */ 12870 if (! is_body_block (origin ? origin : stmt)) 12871 { 12872 /* Determine if this block directly contains any "significant" 12873 local declarations which we will need to output DIEs for. */ 12874 if (debug_info_level > DINFO_LEVEL_TERSE) 12875 /* We are not in terse mode so *any* local declaration counts 12876 as being a "significant" one. */ 12877 must_output_die = (BLOCK_VARS (stmt) != NULL 12878 && (TREE_USED (stmt) 12879 || TREE_ASM_WRITTEN (stmt) 12880 || BLOCK_ABSTRACT (stmt))); 12881 else 12882 /* We are in terse mode, so only local (nested) function 12883 definitions count as "significant" local declarations. */ 12884 for (decl = BLOCK_VARS (stmt); 12885 decl != NULL; decl = TREE_CHAIN (decl)) 12886 if (TREE_CODE (decl) == FUNCTION_DECL 12887 && DECL_INITIAL (decl)) 12888 { 12889 must_output_die = 1; 12890 break; 12891 } 12892 } 12893 } 12894 12895 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block 12896 DIE for any block which contains no significant local declarations at 12897 all. Rather, in such cases we just call `decls_for_scope' so that any 12898 needed Dwarf info for any sub-blocks will get properly generated. Note 12899 that in terse mode, our definition of what constitutes a "significant" 12900 local declaration gets restricted to include only inlined function 12901 instances and local (nested) function definitions. */ 12902 if (must_output_die) 12903 { 12904 if (origin_code == FUNCTION_DECL) 12905 gen_inlined_subroutine_die (stmt, context_die, depth); 12906 else 12907 gen_lexical_block_die (stmt, context_die, depth); 12908 } 12909 else 12910 decls_for_scope (stmt, context_die, depth); 12911} 12912 12913/* Generate all of the decls declared within a given scope and (recursively) 12914 all of its sub-blocks. */ 12915 12916static void 12917decls_for_scope (tree stmt, dw_die_ref context_die, int depth) 12918{ 12919 tree decl; 12920 tree subblocks; 12921 12922 /* Ignore NULL blocks. */ 12923 if (stmt == NULL_TREE) 12924 return; 12925 12926 if (TREE_USED (stmt)) 12927 { 12928 /* Output the DIEs to represent all of the data objects and typedefs 12929 declared directly within this block but not within any nested 12930 sub-blocks. Also, nested function and tag DIEs have been 12931 generated with a parent of NULL; fix that up now. */ 12932 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl)) 12933 { 12934 dw_die_ref die; 12935 12936 if (TREE_CODE (decl) == FUNCTION_DECL) 12937 die = lookup_decl_die (decl); 12938 else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)) 12939 die = lookup_type_die (TREE_TYPE (decl)); 12940 else 12941 die = NULL; 12942 12943 if (die != NULL && die->die_parent == NULL) 12944 add_child_die (context_die, die); 12945 /* Do not produce debug information for static variables since 12946 these might be optimized out. We are called for these later 12947 in cgraph_varpool_analyze_pending_decls. */ 12948 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)) 12949 ; 12950 else 12951 gen_decl_die (decl, context_die); 12952 } 12953 } 12954 12955 /* If we're at -g1, we're not interested in subblocks. */ 12956 if (debug_info_level <= DINFO_LEVEL_TERSE) 12957 return; 12958 12959 /* Output the DIEs to represent all sub-blocks (and the items declared 12960 therein) of this block. */ 12961 for (subblocks = BLOCK_SUBBLOCKS (stmt); 12962 subblocks != NULL; 12963 subblocks = BLOCK_CHAIN (subblocks)) 12964 gen_block_die (subblocks, context_die, depth + 1); 12965} 12966 12967/* Is this a typedef we can avoid emitting? */ 12968 12969static inline int 12970is_redundant_typedef (tree decl) 12971{ 12972 if (TYPE_DECL_IS_STUB (decl)) 12973 return 1; 12974 12975 if (DECL_ARTIFICIAL (decl) 12976 && DECL_CONTEXT (decl) 12977 && is_tagged_type (DECL_CONTEXT (decl)) 12978 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL 12979 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))) 12980 /* Also ignore the artificial member typedef for the class name. */ 12981 return 1; 12982 12983 return 0; 12984} 12985 12986/* Returns the DIE for decl. A DIE will always be returned. */ 12987 12988static dw_die_ref 12989force_decl_die (tree decl) 12990{ 12991 dw_die_ref decl_die; 12992 unsigned saved_external_flag; 12993 tree save_fn = NULL_TREE; 12994 decl_die = lookup_decl_die (decl); 12995 if (!decl_die) 12996 { 12997 dw_die_ref context_die; 12998 tree decl_context = DECL_CONTEXT (decl); 12999 if (decl_context) 13000 { 13001 /* Find die that represents this context. */ 13002 if (TYPE_P (decl_context)) 13003 context_die = force_type_die (decl_context); 13004 else 13005 context_die = force_decl_die (decl_context); 13006 } 13007 else 13008 context_die = comp_unit_die; 13009 13010 decl_die = lookup_decl_die (decl); 13011 if (decl_die) 13012 return decl_die; 13013 13014 switch (TREE_CODE (decl)) 13015 { 13016 case FUNCTION_DECL: 13017 /* Clear current_function_decl, so that gen_subprogram_die thinks 13018 that this is a declaration. At this point, we just want to force 13019 declaration die. */ 13020 save_fn = current_function_decl; 13021 current_function_decl = NULL_TREE; 13022 gen_subprogram_die (decl, context_die); 13023 current_function_decl = save_fn; 13024 break; 13025 13026 case VAR_DECL: 13027 /* Set external flag to force declaration die. Restore it after 13028 gen_decl_die() call. */ 13029 saved_external_flag = DECL_EXTERNAL (decl); 13030 DECL_EXTERNAL (decl) = 1; 13031 gen_decl_die (decl, context_die); 13032 DECL_EXTERNAL (decl) = saved_external_flag; 13033 break; 13034 13035 case NAMESPACE_DECL: 13036 dwarf2out_decl (decl); 13037 break; 13038 13039 default: 13040 gcc_unreachable (); 13041 } 13042 13043 /* We should be able to find the DIE now. */ 13044 if (!decl_die) 13045 decl_die = lookup_decl_die (decl); 13046 gcc_assert (decl_die); 13047 } 13048 13049 return decl_die; 13050} 13051 13052/* Returns the DIE for TYPE, that must not be a base type. A DIE is 13053 always returned. */ 13054 13055static dw_die_ref 13056force_type_die (tree type) 13057{ 13058 dw_die_ref type_die; 13059 13060 type_die = lookup_type_die (type); 13061 if (!type_die) 13062 { 13063 dw_die_ref context_die; 13064 if (TYPE_CONTEXT (type)) 13065 { 13066 if (TYPE_P (TYPE_CONTEXT (type))) 13067 context_die = force_type_die (TYPE_CONTEXT (type)); 13068 else 13069 context_die = force_decl_die (TYPE_CONTEXT (type)); 13070 } 13071 else 13072 context_die = comp_unit_die; 13073 13074 type_die = lookup_type_die (type); 13075 if (type_die) 13076 return type_die; 13077 gen_type_die (type, context_die); 13078 type_die = lookup_type_die (type); 13079 gcc_assert (type_die); 13080 } 13081 return type_die; 13082} 13083 13084/* Force out any required namespaces to be able to output DECL, 13085 and return the new context_die for it, if it's changed. */ 13086 13087static dw_die_ref 13088setup_namespace_context (tree thing, dw_die_ref context_die) 13089{ 13090 tree context = (DECL_P (thing) 13091 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing)); 13092 if (context && TREE_CODE (context) == NAMESPACE_DECL) 13093 /* Force out the namespace. */ 13094 context_die = force_decl_die (context); 13095 13096 return context_die; 13097} 13098 13099/* Emit a declaration DIE for THING (which is either a DECL or a tagged 13100 type) within its namespace, if appropriate. 13101 13102 For compatibility with older debuggers, namespace DIEs only contain 13103 declarations; all definitions are emitted at CU scope. */ 13104 13105static void 13106declare_in_namespace (tree thing, dw_die_ref context_die) 13107{ 13108 dw_die_ref ns_context; 13109 13110 if (debug_info_level <= DINFO_LEVEL_TERSE) 13111 return; 13112 13113 /* If this decl is from an inlined function, then don't try to emit it in its 13114 namespace, as we will get confused. It would have already been emitted 13115 when the abstract instance of the inline function was emitted anyways. */ 13116 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing)) 13117 return; 13118 13119 ns_context = setup_namespace_context (thing, context_die); 13120 13121 if (ns_context != context_die) 13122 { 13123 if (DECL_P (thing)) 13124 gen_decl_die (thing, ns_context); 13125 else 13126 gen_type_die (thing, ns_context); 13127 } 13128} 13129 13130/* Generate a DIE for a namespace or namespace alias. */ 13131 13132static void 13133gen_namespace_die (tree decl) 13134{ 13135 dw_die_ref context_die = setup_namespace_context (decl, comp_unit_die); 13136 13137 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace 13138 they are an alias of. */ 13139 if (DECL_ABSTRACT_ORIGIN (decl) == NULL) 13140 { 13141 /* Output a real namespace. */ 13142 dw_die_ref namespace_die 13143 = new_die (DW_TAG_namespace, context_die, decl); 13144 add_name_and_src_coords_attributes (namespace_die, decl); 13145 equate_decl_number_to_die (decl, namespace_die); 13146 } 13147 else 13148 { 13149 /* Output a namespace alias. */ 13150 13151 /* Force out the namespace we are an alias of, if necessary. */ 13152 dw_die_ref origin_die 13153 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl)); 13154 13155 /* Now create the namespace alias DIE. */ 13156 dw_die_ref namespace_die 13157 = new_die (DW_TAG_imported_declaration, context_die, decl); 13158 add_name_and_src_coords_attributes (namespace_die, decl); 13159 add_AT_die_ref (namespace_die, DW_AT_import, origin_die); 13160 equate_decl_number_to_die (decl, namespace_die); 13161 } 13162} 13163 13164/* Generate Dwarf debug information for a decl described by DECL. */ 13165 13166static void 13167gen_decl_die (tree decl, dw_die_ref context_die) 13168{ 13169 tree origin; 13170 13171 if (DECL_P (decl) && DECL_IGNORED_P (decl)) 13172 return; 13173 13174 switch (TREE_CODE (decl)) 13175 { 13176 case ERROR_MARK: 13177 break; 13178 13179 case CONST_DECL: 13180 /* The individual enumerators of an enum type get output when we output 13181 the Dwarf representation of the relevant enum type itself. */ 13182 break; 13183 13184 case FUNCTION_DECL: 13185 /* Don't output any DIEs to represent mere function declarations, 13186 unless they are class members or explicit block externs. */ 13187 if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE 13188 && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl))) 13189 break; 13190 13191#if 0 13192 /* FIXME */ 13193 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN 13194 on local redeclarations of global functions. That seems broken. */ 13195 if (current_function_decl != decl) 13196 /* This is only a declaration. */; 13197#endif 13198 13199 /* If we're emitting a clone, emit info for the abstract instance. */ 13200 if (DECL_ORIGIN (decl) != decl) 13201 dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl)); 13202 13203 /* If we're emitting an out-of-line copy of an inline function, 13204 emit info for the abstract instance and set up to refer to it. */ 13205 else if (cgraph_function_possibly_inlined_p (decl) 13206 && ! DECL_ABSTRACT (decl) 13207 && ! class_or_namespace_scope_p (context_die) 13208 /* dwarf2out_abstract_function won't emit a die if this is just 13209 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in 13210 that case, because that works only if we have a die. */ 13211 && DECL_INITIAL (decl) != NULL_TREE) 13212 { 13213 dwarf2out_abstract_function (decl); 13214 set_decl_origin_self (decl); 13215 } 13216 13217 /* Otherwise we're emitting the primary DIE for this decl. */ 13218 else if (debug_info_level > DINFO_LEVEL_TERSE) 13219 { 13220 /* Before we describe the FUNCTION_DECL itself, make sure that we 13221 have described its return type. */ 13222 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die); 13223 13224 /* And its virtual context. */ 13225 if (DECL_VINDEX (decl) != NULL_TREE) 13226 gen_type_die (DECL_CONTEXT (decl), context_die); 13227 13228 /* And its containing type. */ 13229 origin = decl_class_context (decl); 13230 if (origin != NULL_TREE) 13231 gen_type_die_for_member (origin, decl, context_die); 13232 13233 /* And its containing namespace. */ 13234 declare_in_namespace (decl, context_die); 13235 } 13236 13237 /* Now output a DIE to represent the function itself. */ 13238 gen_subprogram_die (decl, context_die); 13239 break; 13240 13241 case TYPE_DECL: 13242 /* If we are in terse mode, don't generate any DIEs to represent any 13243 actual typedefs. */ 13244 if (debug_info_level <= DINFO_LEVEL_TERSE) 13245 break; 13246 13247 /* In the special case of a TYPE_DECL node representing the declaration 13248 of some type tag, if the given TYPE_DECL is marked as having been 13249 instantiated from some other (original) TYPE_DECL node (e.g. one which 13250 was generated within the original definition of an inline function) we 13251 have to generate a special (abbreviated) DW_TAG_structure_type, 13252 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. */ 13253 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE 13254 && is_tagged_type (TREE_TYPE (decl))) 13255 { 13256 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die); 13257 break; 13258 } 13259 13260 if (is_redundant_typedef (decl)) 13261 gen_type_die (TREE_TYPE (decl), context_die); 13262 else 13263 /* Output a DIE to represent the typedef itself. */ 13264 gen_typedef_die (decl, context_die); 13265 break; 13266 13267 case LABEL_DECL: 13268 if (debug_info_level >= DINFO_LEVEL_NORMAL) 13269 gen_label_die (decl, context_die); 13270 break; 13271 13272 case VAR_DECL: 13273 case RESULT_DECL: 13274 /* If we are in terse mode, don't generate any DIEs to represent any 13275 variable declarations or definitions. */ 13276 if (debug_info_level <= DINFO_LEVEL_TERSE) 13277 break; 13278 13279 /* Output any DIEs that are needed to specify the type of this data 13280 object. */ 13281 gen_type_die (TREE_TYPE (decl), context_die); 13282 13283 /* And its containing type. */ 13284 origin = decl_class_context (decl); 13285 if (origin != NULL_TREE) 13286 gen_type_die_for_member (origin, decl, context_die); 13287 13288 /* And its containing namespace. */ 13289 declare_in_namespace (decl, context_die); 13290 13291 /* Now output the DIE to represent the data object itself. This gets 13292 complicated because of the possibility that the VAR_DECL really 13293 represents an inlined instance of a formal parameter for an inline 13294 function. */ 13295 origin = decl_ultimate_origin (decl); 13296 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL) 13297 gen_formal_parameter_die (decl, context_die); 13298 else 13299 gen_variable_die (decl, context_die); 13300 break; 13301 13302 case FIELD_DECL: 13303 /* Ignore the nameless fields that are used to skip bits but handle C++ 13304 anonymous unions and structs. */ 13305 if (DECL_NAME (decl) != NULL_TREE 13306 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE 13307 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE) 13308 { 13309 gen_type_die (member_declared_type (decl), context_die); 13310 gen_field_die (decl, context_die); 13311 } 13312 break; 13313 13314 case PARM_DECL: 13315 gen_type_die (TREE_TYPE (decl), context_die); 13316 gen_formal_parameter_die (decl, context_die); 13317 break; 13318 13319 case NAMESPACE_DECL: 13320 gen_namespace_die (decl); 13321 break; 13322 13323 default: 13324 /* Probably some frontend-internal decl. Assume we don't care. */ 13325 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES); 13326 break; 13327 } 13328} 13329 13330/* Output debug information for global decl DECL. Called from toplev.c after 13331 compilation proper has finished. */ 13332 13333static void 13334dwarf2out_global_decl (tree decl) 13335{ 13336 /* Output DWARF2 information for file-scope tentative data object 13337 declarations, file-scope (extern) function declarations (which had no 13338 corresponding body) and file-scope tagged type declarations and 13339 definitions which have not yet been forced out. */ 13340 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl)) 13341 dwarf2out_decl (decl); 13342} 13343 13344/* Output debug information for type decl DECL. Called from toplev.c 13345 and from language front ends (to record built-in types). */ 13346static void 13347dwarf2out_type_decl (tree decl, int local) 13348{ 13349 if (!local) 13350 dwarf2out_decl (decl); 13351} 13352 13353/* Output debug information for imported module or decl. */ 13354 13355static void 13356dwarf2out_imported_module_or_decl (tree decl, tree context) 13357{ 13358 dw_die_ref imported_die, at_import_die; 13359 dw_die_ref scope_die; 13360 expanded_location xloc; 13361 13362 if (debug_info_level <= DINFO_LEVEL_TERSE) 13363 return; 13364 13365 gcc_assert (decl); 13366 13367 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs. 13368 We need decl DIE for reference and scope die. First, get DIE for the decl 13369 itself. */ 13370 13371 /* Get the scope die for decl context. Use comp_unit_die for global module 13372 or decl. If die is not found for non globals, force new die. */ 13373 if (!context) 13374 scope_die = comp_unit_die; 13375 else if (TYPE_P (context)) 13376 { 13377 if (!should_emit_struct_debug (context, DINFO_USAGE_DIR_USE)) 13378 return; 13379 scope_die = force_type_die (context); 13380 } 13381 else 13382 scope_die = force_decl_die (context); 13383 13384 /* For TYPE_DECL or CONST_DECL, lookup TREE_TYPE. */ 13385 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL) 13386 { 13387 if (is_base_type (TREE_TYPE (decl))) 13388 at_import_die = base_type_die (TREE_TYPE (decl)); 13389 else 13390 at_import_die = force_type_die (TREE_TYPE (decl)); 13391 } 13392 else 13393 { 13394 at_import_die = lookup_decl_die (decl); 13395 if (!at_import_die) 13396 { 13397 /* If we're trying to avoid duplicate debug info, we may not have 13398 emitted the member decl for this field. Emit it now. */ 13399 if (TREE_CODE (decl) == FIELD_DECL) 13400 { 13401 tree type = DECL_CONTEXT (decl); 13402 dw_die_ref type_context_die; 13403 13404 if (TYPE_CONTEXT (type)) 13405 if (TYPE_P (TYPE_CONTEXT (type))) 13406 { 13407 if (!should_emit_struct_debug (TYPE_CONTEXT (type), 13408 DINFO_USAGE_DIR_USE)) 13409 return; 13410 type_context_die = force_type_die (TYPE_CONTEXT (type)); 13411 } 13412 else 13413 type_context_die = force_decl_die (TYPE_CONTEXT (type)); 13414 else 13415 type_context_die = comp_unit_die; 13416 gen_type_die_for_member (type, decl, type_context_die); 13417 } 13418 at_import_die = force_decl_die (decl); 13419 } 13420 } 13421 13422 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */ 13423 if (TREE_CODE (decl) == NAMESPACE_DECL) 13424 imported_die = new_die (DW_TAG_imported_module, scope_die, context); 13425 else 13426 imported_die = new_die (DW_TAG_imported_declaration, scope_die, context); 13427 13428 xloc = expand_location (input_location); 13429 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file)); 13430 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line); 13431 add_AT_die_ref (imported_die, DW_AT_import, at_import_die); 13432} 13433 13434/* Write the debugging output for DECL. */ 13435 13436void 13437dwarf2out_decl (tree decl) 13438{ 13439 dw_die_ref context_die = comp_unit_die; 13440 13441 switch (TREE_CODE (decl)) 13442 { 13443 case ERROR_MARK: 13444 return; 13445 13446 case FUNCTION_DECL: 13447 /* What we would really like to do here is to filter out all mere 13448 file-scope declarations of file-scope functions which are never 13449 referenced later within this translation unit (and keep all of ones 13450 that *are* referenced later on) but we aren't clairvoyant, so we have 13451 no idea which functions will be referenced in the future (i.e. later 13452 on within the current translation unit). So here we just ignore all 13453 file-scope function declarations which are not also definitions. If 13454 and when the debugger needs to know something about these functions, 13455 it will have to hunt around and find the DWARF information associated 13456 with the definition of the function. 13457 13458 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL 13459 nodes represent definitions and which ones represent mere 13460 declarations. We have to check DECL_INITIAL instead. That's because 13461 the C front-end supports some weird semantics for "extern inline" 13462 function definitions. These can get inlined within the current 13463 translation unit (and thus, we need to generate Dwarf info for their 13464 abstract instances so that the Dwarf info for the concrete inlined 13465 instances can have something to refer to) but the compiler never 13466 generates any out-of-lines instances of such things (despite the fact 13467 that they *are* definitions). 13468 13469 The important point is that the C front-end marks these "extern 13470 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for 13471 them anyway. Note that the C++ front-end also plays some similar games 13472 for inline function definitions appearing within include files which 13473 also contain `#pragma interface' pragmas. */ 13474 if (DECL_INITIAL (decl) == NULL_TREE) 13475 return; 13476 13477 /* If we're a nested function, initially use a parent of NULL; if we're 13478 a plain function, this will be fixed up in decls_for_scope. If 13479 we're a method, it will be ignored, since we already have a DIE. */ 13480 if (decl_function_context (decl) 13481 /* But if we're in terse mode, we don't care about scope. */ 13482 && debug_info_level > DINFO_LEVEL_TERSE) 13483 context_die = NULL; 13484 break; 13485 13486 case VAR_DECL: 13487 /* Ignore this VAR_DECL if it refers to a file-scope extern data object 13488 declaration and if the declaration was never even referenced from 13489 within this entire compilation unit. We suppress these DIEs in 13490 order to save space in the .debug section (by eliminating entries 13491 which are probably useless). Note that we must not suppress 13492 block-local extern declarations (whether used or not) because that 13493 would screw-up the debugger's name lookup mechanism and cause it to 13494 miss things which really ought to be in scope at a given point. */ 13495 if (DECL_EXTERNAL (decl) && !TREE_USED (decl)) 13496 return; 13497 13498 /* For local statics lookup proper context die. */ 13499 if (TREE_STATIC (decl) && decl_function_context (decl)) 13500 context_die = lookup_decl_die (DECL_CONTEXT (decl)); 13501 13502 /* If we are in terse mode, don't generate any DIEs to represent any 13503 variable declarations or definitions. */ 13504 if (debug_info_level <= DINFO_LEVEL_TERSE) 13505 return; 13506 break; 13507 13508 case NAMESPACE_DECL: 13509 if (debug_info_level <= DINFO_LEVEL_TERSE) 13510 return; 13511 if (lookup_decl_die (decl) != NULL) 13512 return; 13513 break; 13514 13515 case TYPE_DECL: 13516 /* Don't emit stubs for types unless they are needed by other DIEs. */ 13517 if (TYPE_DECL_SUPPRESS_DEBUG (decl)) 13518 return; 13519 13520 /* Don't bother trying to generate any DIEs to represent any of the 13521 normal built-in types for the language we are compiling. */ 13522 if (DECL_IS_BUILTIN (decl)) 13523 { 13524 /* OK, we need to generate one for `bool' so GDB knows what type 13525 comparisons have. */ 13526 if (is_cxx () 13527 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE 13528 && ! DECL_IGNORED_P (decl)) 13529 modified_type_die (TREE_TYPE (decl), 0, 0, NULL); 13530 13531 return; 13532 } 13533 13534 /* If we are in terse mode, don't generate any DIEs for types. */ 13535 if (debug_info_level <= DINFO_LEVEL_TERSE) 13536 return; 13537 13538 /* If we're a function-scope tag, initially use a parent of NULL; 13539 this will be fixed up in decls_for_scope. */ 13540 if (decl_function_context (decl)) 13541 context_die = NULL; 13542 13543 break; 13544 13545 default: 13546 return; 13547 } 13548 13549 gen_decl_die (decl, context_die); 13550} 13551 13552/* Output a marker (i.e. a label) for the beginning of the generated code for 13553 a lexical block. */ 13554 13555static void 13556dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED, 13557 unsigned int blocknum) 13558{ 13559 switch_to_section (current_function_section ()); 13560 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum); 13561} 13562 13563/* Output a marker (i.e. a label) for the end of the generated code for a 13564 lexical block. */ 13565 13566static void 13567dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum) 13568{ 13569 switch_to_section (current_function_section ()); 13570 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum); 13571} 13572 13573/* Returns nonzero if it is appropriate not to emit any debugging 13574 information for BLOCK, because it doesn't contain any instructions. 13575 13576 Don't allow this for blocks with nested functions or local classes 13577 as we would end up with orphans, and in the presence of scheduling 13578 we may end up calling them anyway. */ 13579 13580static bool 13581dwarf2out_ignore_block (tree block) 13582{ 13583 tree decl; 13584 13585 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl)) 13586 if (TREE_CODE (decl) == FUNCTION_DECL 13587 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))) 13588 return 0; 13589 13590 return 1; 13591} 13592 13593/* Hash table routines for file_hash. */ 13594 13595static int 13596file_table_eq (const void *p1_p, const void *p2_p) 13597{ 13598 const struct dwarf_file_data * p1 = p1_p; 13599 const char * p2 = p2_p; 13600 return strcmp (p1->filename, p2) == 0; 13601} 13602 13603static hashval_t 13604file_table_hash (const void *p_p) 13605{ 13606 const struct dwarf_file_data * p = p_p; 13607 return htab_hash_string (p->filename); 13608} 13609 13610/* Lookup FILE_NAME (in the list of filenames that we know about here in 13611 dwarf2out.c) and return its "index". The index of each (known) filename is 13612 just a unique number which is associated with only that one filename. We 13613 need such numbers for the sake of generating labels (in the .debug_sfnames 13614 section) and references to those files numbers (in the .debug_srcinfo 13615 and.debug_macinfo sections). If the filename given as an argument is not 13616 found in our current list, add it to the list and assign it the next 13617 available unique index number. In order to speed up searches, we remember 13618 the index of the filename was looked up last. This handles the majority of 13619 all searches. */ 13620 13621static struct dwarf_file_data * 13622lookup_filename (const char *file_name) 13623{ 13624 void ** slot; 13625 struct dwarf_file_data * created; 13626 13627 /* Check to see if the file name that was searched on the previous 13628 call matches this file name. If so, return the index. */ 13629 if (file_table_last_lookup 13630 && (file_name == file_table_last_lookup->filename 13631 || strcmp (file_table_last_lookup->filename, file_name) == 0)) 13632 return file_table_last_lookup; 13633 13634 /* Didn't match the previous lookup, search the table. */ 13635 slot = htab_find_slot_with_hash (file_table, file_name, 13636 htab_hash_string (file_name), INSERT); 13637 if (*slot) 13638 return *slot; 13639 13640 created = ggc_alloc (sizeof (struct dwarf_file_data)); 13641 created->filename = file_name; 13642 created->emitted_number = 0; 13643 *slot = created; 13644 return created; 13645} 13646 13647/* If the assembler will construct the file table, then translate the compiler 13648 internal file table number into the assembler file table number, and emit 13649 a .file directive if we haven't already emitted one yet. The file table 13650 numbers are different because we prune debug info for unused variables and 13651 types, which may include filenames. */ 13652 13653static int 13654maybe_emit_file (struct dwarf_file_data * fd) 13655{ 13656 if (! fd->emitted_number) 13657 { 13658 if (last_emitted_file) 13659 fd->emitted_number = last_emitted_file->emitted_number + 1; 13660 else 13661 fd->emitted_number = 1; 13662 last_emitted_file = fd; 13663 13664 if (DWARF2_ASM_LINE_DEBUG_INFO) 13665 { 13666 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number); 13667 output_quoted_string (asm_out_file, fd->filename); 13668 fputc ('\n', asm_out_file); 13669 } 13670 } 13671 13672 return fd->emitted_number; 13673} 13674 13675/* Called by the final INSN scan whenever we see a var location. We 13676 use it to drop labels in the right places, and throw the location in 13677 our lookup table. */ 13678 13679static void 13680dwarf2out_var_location (rtx loc_note) 13681{ 13682 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES]; 13683 struct var_loc_node *newloc; 13684 rtx prev_insn; 13685 static rtx last_insn; 13686 static const char *last_label; 13687 tree decl; 13688 13689 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note))) 13690 return; 13691 prev_insn = PREV_INSN (loc_note); 13692 13693 newloc = ggc_alloc_cleared (sizeof (struct var_loc_node)); 13694 /* If the insn we processed last time is the previous insn 13695 and it is also a var location note, use the label we emitted 13696 last time. */ 13697 if (last_insn != NULL_RTX 13698 && last_insn == prev_insn 13699 && NOTE_P (prev_insn) 13700 && NOTE_LINE_NUMBER (prev_insn) == NOTE_INSN_VAR_LOCATION) 13701 { 13702 newloc->label = last_label; 13703 } 13704 else 13705 { 13706 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num); 13707 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num); 13708 loclabel_num++; 13709 newloc->label = ggc_strdup (loclabel); 13710 } 13711 newloc->var_loc_note = loc_note; 13712 newloc->next = NULL; 13713 13714 if (cfun && in_cold_section_p) 13715 newloc->section_label = cfun->cold_section_label; 13716 else 13717 newloc->section_label = text_section_label; 13718 13719 last_insn = loc_note; 13720 last_label = newloc->label; 13721 decl = NOTE_VAR_LOCATION_DECL (loc_note); 13722 add_var_loc_to_decl (decl, newloc); 13723} 13724 13725/* We need to reset the locations at the beginning of each 13726 function. We can't do this in the end_function hook, because the 13727 declarations that use the locations won't have been output when 13728 that hook is called. Also compute have_multiple_function_sections here. */ 13729 13730static void 13731dwarf2out_begin_function (tree fun) 13732{ 13733 htab_empty (decl_loc_table); 13734 13735 if (function_section (fun) != text_section) 13736 have_multiple_function_sections = true; 13737} 13738 13739/* Output a label to mark the beginning of a source code line entry 13740 and record information relating to this source line, in 13741 'line_info_table' for later output of the .debug_line section. */ 13742 13743static void 13744dwarf2out_source_line (unsigned int line, const char *filename) 13745{ 13746 if (debug_info_level >= DINFO_LEVEL_NORMAL 13747 && line != 0) 13748 { 13749 int file_num = maybe_emit_file (lookup_filename (filename)); 13750 13751 switch_to_section (current_function_section ()); 13752 13753 /* If requested, emit something human-readable. */ 13754 if (flag_debug_asm) 13755 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START, 13756 filename, line); 13757 13758 if (DWARF2_ASM_LINE_DEBUG_INFO) 13759 { 13760 /* Emit the .loc directive understood by GNU as. */ 13761 fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line); 13762 13763 /* Indicate that line number info exists. */ 13764 line_info_table_in_use++; 13765 } 13766 else if (function_section (current_function_decl) != text_section) 13767 { 13768 dw_separate_line_info_ref line_info; 13769 targetm.asm_out.internal_label (asm_out_file, 13770 SEPARATE_LINE_CODE_LABEL, 13771 separate_line_info_table_in_use); 13772 13773 /* Expand the line info table if necessary. */ 13774 if (separate_line_info_table_in_use 13775 == separate_line_info_table_allocated) 13776 { 13777 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT; 13778 separate_line_info_table 13779 = ggc_realloc (separate_line_info_table, 13780 separate_line_info_table_allocated 13781 * sizeof (dw_separate_line_info_entry)); 13782 memset (separate_line_info_table 13783 + separate_line_info_table_in_use, 13784 0, 13785 (LINE_INFO_TABLE_INCREMENT 13786 * sizeof (dw_separate_line_info_entry))); 13787 } 13788 13789 /* Add the new entry at the end of the line_info_table. */ 13790 line_info 13791 = &separate_line_info_table[separate_line_info_table_in_use++]; 13792 line_info->dw_file_num = file_num; 13793 line_info->dw_line_num = line; 13794 line_info->function = current_function_funcdef_no; 13795 } 13796 else 13797 { 13798 dw_line_info_ref line_info; 13799 13800 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL, 13801 line_info_table_in_use); 13802 13803 /* Expand the line info table if necessary. */ 13804 if (line_info_table_in_use == line_info_table_allocated) 13805 { 13806 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT; 13807 line_info_table 13808 = ggc_realloc (line_info_table, 13809 (line_info_table_allocated 13810 * sizeof (dw_line_info_entry))); 13811 memset (line_info_table + line_info_table_in_use, 0, 13812 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry)); 13813 } 13814 13815 /* Add the new entry at the end of the line_info_table. */ 13816 line_info = &line_info_table[line_info_table_in_use++]; 13817 line_info->dw_file_num = file_num; 13818 line_info->dw_line_num = line; 13819 } 13820 } 13821} 13822 13823/* Record the beginning of a new source file. */ 13824 13825static void 13826dwarf2out_start_source_file (unsigned int lineno, const char *filename) 13827{ 13828 if (flag_eliminate_dwarf2_dups) 13829 { 13830 /* Record the beginning of the file for break_out_includes. */ 13831 dw_die_ref bincl_die; 13832 13833 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL); 13834 add_AT_string (bincl_die, DW_AT_name, filename); 13835 } 13836 13837 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 13838 { 13839 int file_num = maybe_emit_file (lookup_filename (filename)); 13840 13841 switch_to_section (debug_macinfo_section); 13842 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file"); 13843 dw2_asm_output_data_uleb128 (lineno, "Included from line number %d", 13844 lineno); 13845 13846 dw2_asm_output_data_uleb128 (file_num, "file %s", filename); 13847 } 13848} 13849 13850/* Record the end of a source file. */ 13851 13852static void 13853dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED) 13854{ 13855 if (flag_eliminate_dwarf2_dups) 13856 /* Record the end of the file for break_out_includes. */ 13857 new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL); 13858 13859 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 13860 { 13861 switch_to_section (debug_macinfo_section); 13862 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file"); 13863 } 13864} 13865 13866/* Called from debug_define in toplev.c. The `buffer' parameter contains 13867 the tail part of the directive line, i.e. the part which is past the 13868 initial whitespace, #, whitespace, directive-name, whitespace part. */ 13869 13870static void 13871dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED, 13872 const char *buffer ATTRIBUTE_UNUSED) 13873{ 13874 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 13875 { 13876 switch_to_section (debug_macinfo_section); 13877 dw2_asm_output_data (1, DW_MACINFO_define, "Define macro"); 13878 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno); 13879 dw2_asm_output_nstring (buffer, -1, "The macro"); 13880 } 13881} 13882 13883/* Called from debug_undef in toplev.c. The `buffer' parameter contains 13884 the tail part of the directive line, i.e. the part which is past the 13885 initial whitespace, #, whitespace, directive-name, whitespace part. */ 13886 13887static void 13888dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED, 13889 const char *buffer ATTRIBUTE_UNUSED) 13890{ 13891 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 13892 { 13893 switch_to_section (debug_macinfo_section); 13894 dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro"); 13895 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno); 13896 dw2_asm_output_nstring (buffer, -1, "The macro"); 13897 } 13898} 13899 13900/* Set up for Dwarf output at the start of compilation. */ 13901 13902static void 13903dwarf2out_init (const char *filename ATTRIBUTE_UNUSED) 13904{ 13905 /* Allocate the file_table. */ 13906 file_table = htab_create_ggc (50, file_table_hash, 13907 file_table_eq, NULL); 13908 13909 /* Allocate the decl_die_table. */ 13910 decl_die_table = htab_create_ggc (10, decl_die_table_hash, 13911 decl_die_table_eq, NULL); 13912 13913 /* Allocate the decl_loc_table. */ 13914 decl_loc_table = htab_create_ggc (10, decl_loc_table_hash, 13915 decl_loc_table_eq, NULL); 13916 13917 /* Allocate the initial hunk of the decl_scope_table. */ 13918 decl_scope_table = VEC_alloc (tree, gc, 256); 13919 13920 /* Allocate the initial hunk of the abbrev_die_table. */ 13921 abbrev_die_table = ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT 13922 * sizeof (dw_die_ref)); 13923 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT; 13924 /* Zero-th entry is allocated, but unused. */ 13925 abbrev_die_table_in_use = 1; 13926 13927 /* Allocate the initial hunk of the line_info_table. */ 13928 line_info_table = ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT 13929 * sizeof (dw_line_info_entry)); 13930 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT; 13931 13932 /* Zero-th entry is allocated, but unused. */ 13933 line_info_table_in_use = 1; 13934 13935 /* Generate the initial DIE for the .debug section. Note that the (string) 13936 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE 13937 will (typically) be a relative pathname and that this pathname should be 13938 taken as being relative to the directory from which the compiler was 13939 invoked when the given (base) source file was compiled. We will fill 13940 in this value in dwarf2out_finish. */ 13941 comp_unit_die = gen_compile_unit_die (NULL); 13942 13943 incomplete_types = VEC_alloc (tree, gc, 64); 13944 13945 used_rtx_array = VEC_alloc (rtx, gc, 32); 13946 13947 debug_info_section = get_section (DEBUG_INFO_SECTION, 13948 SECTION_DEBUG, NULL); 13949 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION, 13950 SECTION_DEBUG, NULL); 13951 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION, 13952 SECTION_DEBUG, NULL); 13953 debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION, 13954 SECTION_DEBUG, NULL); 13955 debug_line_section = get_section (DEBUG_LINE_SECTION, 13956 SECTION_DEBUG, NULL); 13957 debug_loc_section = get_section (DEBUG_LOC_SECTION, 13958 SECTION_DEBUG, NULL); 13959 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION, 13960 SECTION_DEBUG, NULL); 13961 debug_str_section = get_section (DEBUG_STR_SECTION, 13962 DEBUG_STR_SECTION_FLAGS, NULL); 13963 debug_ranges_section = get_section (DEBUG_RANGES_SECTION, 13964 SECTION_DEBUG, NULL); 13965 debug_frame_section = get_section (DEBUG_FRAME_SECTION, 13966 SECTION_DEBUG, NULL); 13967 13968 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0); 13969 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label, 13970 DEBUG_ABBREV_SECTION_LABEL, 0); 13971 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0); 13972 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label, 13973 COLD_TEXT_SECTION_LABEL, 0); 13974 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0); 13975 13976 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label, 13977 DEBUG_INFO_SECTION_LABEL, 0); 13978 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label, 13979 DEBUG_LINE_SECTION_LABEL, 0); 13980 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label, 13981 DEBUG_RANGES_SECTION_LABEL, 0); 13982 switch_to_section (debug_abbrev_section); 13983 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label); 13984 switch_to_section (debug_info_section); 13985 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label); 13986 switch_to_section (debug_line_section); 13987 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label); 13988 13989 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 13990 { 13991 switch_to_section (debug_macinfo_section); 13992 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label, 13993 DEBUG_MACINFO_SECTION_LABEL, 0); 13994 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label); 13995 } 13996 13997 switch_to_section (text_section); 13998 ASM_OUTPUT_LABEL (asm_out_file, text_section_label); 13999 if (flag_reorder_blocks_and_partition) 14000 { 14001 switch_to_section (unlikely_text_section ()); 14002 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label); 14003 } 14004} 14005 14006/* A helper function for dwarf2out_finish called through 14007 ht_forall. Emit one queued .debug_str string. */ 14008 14009static int 14010output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED) 14011{ 14012 struct indirect_string_node *node = (struct indirect_string_node *) *h; 14013 14014 if (node->form == DW_FORM_strp) 14015 { 14016 switch_to_section (debug_str_section); 14017 ASM_OUTPUT_LABEL (asm_out_file, node->label); 14018 assemble_string (node->str, strlen (node->str) + 1); 14019 } 14020 14021 return 1; 14022} 14023 14024#if ENABLE_ASSERT_CHECKING 14025/* Verify that all marks are clear. */ 14026 14027static void 14028verify_marks_clear (dw_die_ref die) 14029{ 14030 dw_die_ref c; 14031 14032 gcc_assert (! die->die_mark); 14033 FOR_EACH_CHILD (die, c, verify_marks_clear (c)); 14034} 14035#endif /* ENABLE_ASSERT_CHECKING */ 14036 14037/* Clear the marks for a die and its children. 14038 Be cool if the mark isn't set. */ 14039 14040static void 14041prune_unmark_dies (dw_die_ref die) 14042{ 14043 dw_die_ref c; 14044 14045 if (die->die_mark) 14046 die->die_mark = 0; 14047 FOR_EACH_CHILD (die, c, prune_unmark_dies (c)); 14048} 14049 14050/* Given DIE that we're marking as used, find any other dies 14051 it references as attributes and mark them as used. */ 14052 14053static void 14054prune_unused_types_walk_attribs (dw_die_ref die) 14055{ 14056 dw_attr_ref a; 14057 unsigned ix; 14058 14059 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 14060 { 14061 if (a->dw_attr_val.val_class == dw_val_class_die_ref) 14062 { 14063 /* A reference to another DIE. 14064 Make sure that it will get emitted. */ 14065 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1); 14066 } 14067 /* Set the string's refcount to 0 so that prune_unused_types_mark 14068 accounts properly for it. */ 14069 if (AT_class (a) == dw_val_class_str) 14070 a->dw_attr_val.v.val_str->refcount = 0; 14071 } 14072} 14073 14074 14075/* Mark DIE as being used. If DOKIDS is true, then walk down 14076 to DIE's children. */ 14077 14078static void 14079prune_unused_types_mark (dw_die_ref die, int dokids) 14080{ 14081 dw_die_ref c; 14082 14083 if (die->die_mark == 0) 14084 { 14085 /* We haven't done this node yet. Mark it as used. */ 14086 die->die_mark = 1; 14087 14088 /* We also have to mark its parents as used. 14089 (But we don't want to mark our parents' kids due to this.) */ 14090 if (die->die_parent) 14091 prune_unused_types_mark (die->die_parent, 0); 14092 14093 /* Mark any referenced nodes. */ 14094 prune_unused_types_walk_attribs (die); 14095 14096 /* If this node is a specification, 14097 also mark the definition, if it exists. */ 14098 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition) 14099 prune_unused_types_mark (die->die_definition, 1); 14100 } 14101 14102 if (dokids && die->die_mark != 2) 14103 { 14104 /* We need to walk the children, but haven't done so yet. 14105 Remember that we've walked the kids. */ 14106 die->die_mark = 2; 14107 14108 /* If this is an array type, we need to make sure our 14109 kids get marked, even if they're types. */ 14110 if (die->die_tag == DW_TAG_array_type) 14111 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1)); 14112 else 14113 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c)); 14114 } 14115} 14116 14117 14118/* Walk the tree DIE and mark types that we actually use. */ 14119 14120static void 14121prune_unused_types_walk (dw_die_ref die) 14122{ 14123 dw_die_ref c; 14124 14125 /* Don't do anything if this node is already marked. */ 14126 if (die->die_mark) 14127 return; 14128 14129 switch (die->die_tag) { 14130 case DW_TAG_const_type: 14131 case DW_TAG_packed_type: 14132 case DW_TAG_pointer_type: 14133 case DW_TAG_reference_type: 14134 case DW_TAG_volatile_type: 14135 case DW_TAG_typedef: 14136 case DW_TAG_array_type: 14137 case DW_TAG_structure_type: 14138 case DW_TAG_union_type: 14139 case DW_TAG_class_type: 14140 case DW_TAG_friend: 14141 case DW_TAG_variant_part: 14142 case DW_TAG_enumeration_type: 14143 case DW_TAG_subroutine_type: 14144 case DW_TAG_string_type: 14145 case DW_TAG_set_type: 14146 case DW_TAG_subrange_type: 14147 case DW_TAG_ptr_to_member_type: 14148 case DW_TAG_file_type: 14149 if (die->die_perennial_p) 14150 break; 14151 14152 /* It's a type node --- don't mark it. */ 14153 return; 14154 14155 default: 14156 /* Mark everything else. */ 14157 break; 14158 } 14159 14160 die->die_mark = 1; 14161 14162 /* Now, mark any dies referenced from here. */ 14163 prune_unused_types_walk_attribs (die); 14164 14165 /* Mark children. */ 14166 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c)); 14167} 14168 14169/* Increment the string counts on strings referred to from DIE's 14170 attributes. */ 14171 14172static void 14173prune_unused_types_update_strings (dw_die_ref die) 14174{ 14175 dw_attr_ref a; 14176 unsigned ix; 14177 14178 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++) 14179 if (AT_class (a) == dw_val_class_str) 14180 { 14181 struct indirect_string_node *s = a->dw_attr_val.v.val_str; 14182 s->refcount++; 14183 /* Avoid unnecessarily putting strings that are used less than 14184 twice in the hash table. */ 14185 if (s->refcount 14186 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2)) 14187 { 14188 void ** slot; 14189 slot = htab_find_slot_with_hash (debug_str_hash, s->str, 14190 htab_hash_string (s->str), 14191 INSERT); 14192 gcc_assert (*slot == NULL); 14193 *slot = s; 14194 } 14195 } 14196} 14197 14198/* Remove from the tree DIE any dies that aren't marked. */ 14199 14200static void 14201prune_unused_types_prune (dw_die_ref die) 14202{ 14203 dw_die_ref c; 14204 14205 gcc_assert (die->die_mark); 14206 prune_unused_types_update_strings (die); 14207 14208 if (! die->die_child) 14209 return; 14210 14211 c = die->die_child; 14212 do { 14213 dw_die_ref prev = c; 14214 for (c = c->die_sib; ! c->die_mark; c = c->die_sib) 14215 if (c == die->die_child) 14216 { 14217 /* No marked children between 'prev' and the end of the list. */ 14218 if (prev == c) 14219 /* No marked children at all. */ 14220 die->die_child = NULL; 14221 else 14222 { 14223 prev->die_sib = c->die_sib; 14224 die->die_child = prev; 14225 } 14226 return; 14227 } 14228 14229 if (c != prev->die_sib) 14230 prev->die_sib = c; 14231 prune_unused_types_prune (c); 14232 } while (c != die->die_child); 14233} 14234 14235 14236/* Remove dies representing declarations that we never use. */ 14237 14238static void 14239prune_unused_types (void) 14240{ 14241 unsigned int i; 14242 limbo_die_node *node; 14243 14244#if ENABLE_ASSERT_CHECKING 14245 /* All the marks should already be clear. */ 14246 verify_marks_clear (comp_unit_die); 14247 for (node = limbo_die_list; node; node = node->next) 14248 verify_marks_clear (node->die); 14249#endif /* ENABLE_ASSERT_CHECKING */ 14250 14251 /* Set the mark on nodes that are actually used. */ 14252 prune_unused_types_walk (comp_unit_die); 14253 for (node = limbo_die_list; node; node = node->next) 14254 prune_unused_types_walk (node->die); 14255 14256 /* Also set the mark on nodes referenced from the 14257 pubname_table or arange_table. */ 14258 for (i = 0; i < pubname_table_in_use; i++) 14259 prune_unused_types_mark (pubname_table[i].die, 1); 14260 for (i = 0; i < arange_table_in_use; i++) 14261 prune_unused_types_mark (arange_table[i], 1); 14262 14263 /* Get rid of nodes that aren't marked; and update the string counts. */ 14264 if (debug_str_hash) 14265 htab_empty (debug_str_hash); 14266 prune_unused_types_prune (comp_unit_die); 14267 for (node = limbo_die_list; node; node = node->next) 14268 prune_unused_types_prune (node->die); 14269 14270 /* Leave the marks clear. */ 14271 prune_unmark_dies (comp_unit_die); 14272 for (node = limbo_die_list; node; node = node->next) 14273 prune_unmark_dies (node->die); 14274} 14275 14276/* Set the parameter to true if there are any relative pathnames in 14277 the file table. */ 14278static int 14279file_table_relative_p (void ** slot, void *param) 14280{ 14281 bool *p = param; 14282 struct dwarf_file_data *d = *slot; 14283 if (d->emitted_number && d->filename[0] != DIR_SEPARATOR) 14284 { 14285 *p = true; 14286 return 0; 14287 } 14288 return 1; 14289} 14290 14291/* Output stuff that dwarf requires at the end of every file, 14292 and generate the DWARF-2 debugging info. */ 14293 14294static void 14295dwarf2out_finish (const char *filename) 14296{ 14297 limbo_die_node *node, *next_node; 14298 dw_die_ref die = 0; 14299 14300 /* Add the name for the main input file now. We delayed this from 14301 dwarf2out_init to avoid complications with PCH. */ 14302 add_name_attribute (comp_unit_die, filename); 14303 if (filename[0] != DIR_SEPARATOR) 14304 add_comp_dir_attribute (comp_unit_die); 14305 else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL) 14306 { 14307 bool p = false; 14308 htab_traverse (file_table, file_table_relative_p, &p); 14309 if (p) 14310 add_comp_dir_attribute (comp_unit_die); 14311 } 14312 14313 /* Traverse the limbo die list, and add parent/child links. The only 14314 dies without parents that should be here are concrete instances of 14315 inline functions, and the comp_unit_die. We can ignore the comp_unit_die. 14316 For concrete instances, we can get the parent die from the abstract 14317 instance. */ 14318 for (node = limbo_die_list; node; node = next_node) 14319 { 14320 next_node = node->next; 14321 die = node->die; 14322 14323 if (die->die_parent == NULL) 14324 { 14325 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin); 14326 14327 if (origin) 14328 add_child_die (origin->die_parent, die); 14329 else if (die == comp_unit_die) 14330 ; 14331 else if (errorcount > 0 || sorrycount > 0) 14332 /* It's OK to be confused by errors in the input. */ 14333 add_child_die (comp_unit_die, die); 14334 else 14335 { 14336 /* In certain situations, the lexical block containing a 14337 nested function can be optimized away, which results 14338 in the nested function die being orphaned. Likewise 14339 with the return type of that nested function. Force 14340 this to be a child of the containing function. 14341 14342 It may happen that even the containing function got fully 14343 inlined and optimized out. In that case we are lost and 14344 assign the empty child. This should not be big issue as 14345 the function is likely unreachable too. */ 14346 tree context = NULL_TREE; 14347 14348 gcc_assert (node->created_for); 14349 14350 if (DECL_P (node->created_for)) 14351 context = DECL_CONTEXT (node->created_for); 14352 else if (TYPE_P (node->created_for)) 14353 context = TYPE_CONTEXT (node->created_for); 14354 14355 gcc_assert (context 14356 && (TREE_CODE (context) == FUNCTION_DECL 14357 || TREE_CODE (context) == NAMESPACE_DECL)); 14358 14359 origin = lookup_decl_die (context); 14360 if (origin) 14361 add_child_die (origin, die); 14362 else 14363 add_child_die (comp_unit_die, die); 14364 } 14365 } 14366 } 14367 14368 limbo_die_list = NULL; 14369 14370 /* Walk through the list of incomplete types again, trying once more to 14371 emit full debugging info for them. */ 14372 retry_incomplete_types (); 14373 14374 if (flag_eliminate_unused_debug_types) 14375 prune_unused_types (); 14376 14377 /* Generate separate CUs for each of the include files we've seen. 14378 They will go into limbo_die_list. */ 14379 if (flag_eliminate_dwarf2_dups) 14380 break_out_includes (comp_unit_die); 14381 14382 /* Traverse the DIE's and add add sibling attributes to those DIE's 14383 that have children. */ 14384 add_sibling_attributes (comp_unit_die); 14385 for (node = limbo_die_list; node; node = node->next) 14386 add_sibling_attributes (node->die); 14387 14388 /* Output a terminator label for the .text section. */ 14389 switch_to_section (text_section); 14390 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0); 14391 if (flag_reorder_blocks_and_partition) 14392 { 14393 switch_to_section (unlikely_text_section ()); 14394 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0); 14395 } 14396 14397 /* We can only use the low/high_pc attributes if all of the code was 14398 in .text. */ 14399 if (!have_multiple_function_sections) 14400 { 14401 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label); 14402 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label); 14403 } 14404 14405 /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate 14406 "base address". Use zero so that these addresses become absolute. */ 14407 else if (have_location_lists || ranges_table_in_use) 14408 add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx); 14409 14410 /* Output location list section if necessary. */ 14411 if (have_location_lists) 14412 { 14413 /* Output the location lists info. */ 14414 switch_to_section (debug_loc_section); 14415 ASM_GENERATE_INTERNAL_LABEL (loc_section_label, 14416 DEBUG_LOC_SECTION_LABEL, 0); 14417 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label); 14418 output_location_lists (die); 14419 } 14420 14421 if (debug_info_level >= DINFO_LEVEL_NORMAL) 14422 add_AT_lineptr (comp_unit_die, DW_AT_stmt_list, 14423 debug_line_section_label); 14424 14425 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 14426 add_AT_macptr (comp_unit_die, DW_AT_macro_info, macinfo_section_label); 14427 14428 /* Output all of the compilation units. We put the main one last so that 14429 the offsets are available to output_pubnames. */ 14430 for (node = limbo_die_list; node; node = node->next) 14431 output_comp_unit (node->die, 0); 14432 14433 output_comp_unit (comp_unit_die, 0); 14434 14435 /* Output the abbreviation table. */ 14436 switch_to_section (debug_abbrev_section); 14437 output_abbrev_section (); 14438 14439 /* Output public names table if necessary. */ 14440 if (pubname_table_in_use) 14441 { 14442 switch_to_section (debug_pubnames_section); 14443 output_pubnames (); 14444 } 14445 14446 /* Output the address range information. We only put functions in the arange 14447 table, so don't write it out if we don't have any. */ 14448 if (fde_table_in_use) 14449 { 14450 switch_to_section (debug_aranges_section); 14451 output_aranges (); 14452 } 14453 14454 /* Output ranges section if necessary. */ 14455 if (ranges_table_in_use) 14456 { 14457 switch_to_section (debug_ranges_section); 14458 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label); 14459 output_ranges (); 14460 } 14461 14462 /* Output the source line correspondence table. We must do this 14463 even if there is no line information. Otherwise, on an empty 14464 translation unit, we will generate a present, but empty, 14465 .debug_info section. IRIX 6.5 `nm' will then complain when 14466 examining the file. This is done late so that any filenames 14467 used by the debug_info section are marked as 'used'. */ 14468 if (! DWARF2_ASM_LINE_DEBUG_INFO) 14469 { 14470 switch_to_section (debug_line_section); 14471 output_line_info (); 14472 } 14473 14474 /* Have to end the macro section. */ 14475 if (debug_info_level >= DINFO_LEVEL_VERBOSE) 14476 { 14477 switch_to_section (debug_macinfo_section); 14478 dw2_asm_output_data (1, 0, "End compilation unit"); 14479 } 14480 14481 /* If we emitted any DW_FORM_strp form attribute, output the string 14482 table too. */ 14483 if (debug_str_hash) 14484 htab_traverse (debug_str_hash, output_indirect_string, NULL); 14485} 14486#else 14487 14488/* This should never be used, but its address is needed for comparisons. */ 14489const struct gcc_debug_hooks dwarf2_debug_hooks; 14490 14491#endif /* DWARF2_DEBUGGING_INFO */ 14492 14493#include "gt-dwarf2out.h" 14494